lib/ruote/storage/composite_storage.rb in ruote-2.2.0 vs lib/ruote/storage/composite_storage.rb in ruote-2.3.0

@@ -1,7 +1,7 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, [e-mail]
+# Copyright (c) 2005-2012, John Mettraux, [e-mail]
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
@@ -31,12 +31,12 @@
   # This storage allows for mixing of storage implementation or simply
   # mixing of storage physical backend.
   #
   #   opts = {}
   #
-  #   engine =
-  #     Ruote::Engine.new(
+  #   dashboard =
+  #     Ruote::Dashboard.new(
   #       Ruote::Worker.new(
   #         Ruote::CompositeStorage.new(
   #           Ruote::FsStorage.new('ruote_work', opts),
   #           'msgs' => Ruote::HashStorage.new(opts))))
   #
@@ -49,84 +49,74 @@
 
     def initialize(default_storage, storages)
 
       @default_storage = default_storage
       @storages = storages
-
-      prepare_base_methods
     end
 
-    def put(doc, opts={})
+    # A class method 'delegate', to tell this storage how to deal with
+    # each method composing a storage.
+    #
+    # Followed by a list of 'delegations'.
+    #
+    def self.delegate(method_name, type=nil)
 
-      storage(doc['type']).put(doc, opts)
+      if type == nil
+        define_method(method_name) do |*args|
+          storage_for(args.first['type']).send(method_name, *args)
+        end
+      elsif type.is_a?(Fixnum)
+        define_method(method_name) do |*args|
+          storage_for(args[type]).send(method_name, *args)
+        end
+      else
+        type = type.to_s
+        define_method(method_name) do |*args|
+          storage_for(type).send(method_name, *args)
+        end
+      end
     end
 
-    def get(type, key)
+    delegate :put
+    delegate :get, 0
+    delegate :get_many, 0
+    delegate :delete
 
-      storage(type).get(type, key)
-    end
+    delegate :reserve
+    delegate :ids, 0
+    delegate :purge_type!, 0
+    delegate :empty?, 0
 
-    def delete(doc)
+    delegate :put_msg, :msgs
+    delegate :get_msgs, :msgs
+    delegate :put_schedule, :schedules
+    delegate :get_schedules, :schedules
+    delegate :delete_schedule, :schedules
+    delegate :find_root_expression, :expressions
+    delegate :expression_wfids, :expressions
+    delegate :get_trackers, :variables
+    delegate :get_engine_variable, :variables
+    delegate :put_engine_variable, :variables
 
-      storage(doc['type']).delete(doc)
+    # The dilemma for the CompositeStorage with add_type is "to which
+    # real storage should the new type get added". The solution: do nothing.
+    #
+    def add_type(type)
     end
 
-    def get_many(type, key=nil, opts={})
-
-      storage(type).get_many(type, key, opts)
-    end
-
-    def ids(type)
-
-      storage(type).ids(type)
-    end
-
-    def purge!
-
-      TYPES.collect { |t| storage(t) }.uniq.each { |s| s.purge! }
-    end
-
-    def purge_type!(type)
-
-      storage(type).purge_type!(type)
-    end
-
-    #def add_type (type)
-    #end
-
-    protected
-
-    STORAGE_BASE_METHODS = {
-      'put_msg' => 'msgs',
-      'get_msgs' => 'msgs',
-      'find_root_expression' => 'expressions',
-      'get_schedules' => 'schedules',
-      'put_schedule' => 'schedules'
-    }
-
     TYPES = %w[
       variables
       msgs
       expressions
       errors
       schedules
       configurations
       workitems
     ]
 
-    def prepare_base_methods
+    protected
 
-      singleton = class << self; self; end
-
-      STORAGE_BASE_METHODS.each do |method, type|
-
-        singleton.send(:define_method, method) do |*args|
-          storage(type).send(method, *args)
-        end
-      end
-    end
-
-    def storage(type)
+    def storage_for(type)
 
       @storages[type] || @default_storage
     end
   end
 end