lib/rom/sql/plugin/associates.rb in rom-sql-1.0.0.beta2 vs lib/rom/sql/plugin/associates.rb in rom-sql-1.0.0.beta3

@@ -10,13 +10,14 @@
           klass.class_eval do
             extend ClassMethods
             include InstanceMethods
             defines :associations
 
-            associations []
+            associations Hash.new
 
             option :associations, reader: true, optional: true, default: -> cmd { cmd.class.associations }
+            option :configured_associations, reader: true, optional: true, default: proc { [] }
           end
           super
         end
 
         module InstanceMethods
@@ -56,13 +57,23 @@
               end
           end
 
           # @api public
           def with_association(name, opts = EMPTY_HASH)
-            self.class.build(relation, options.merge(associations: [[name, opts]]))
+            self.class.build(
+              relation, options.merge(associations: associations.merge(name => opts))
+            )
           end
 
+          def associations_configured?
+            if configured_associations.empty?
+              false
+            else
+              configured_associations.all? { |name| associations.key?(name) }
+            end
+          end
+
           # @api private
           def __registry__
             relation.__registry__
           end
         end
@@ -71,33 +82,45 @@
           # @see ROM::Command::ClassInterface.build
           #
           # @api public
           def build(relation, options = EMPTY_HASH)
             command = super
+
+            if command.associations_configured?
+              return command
+            end
+
             associations = command.associations
+            assoc_names = []
 
             before_hooks = associations.each_with_object([]) do |(name, opts), acc|
               relation.associations.try(name) do |assoc|
                 unless assoc.is_a?(Association::ManyToMany)
                   acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
                 else
                   true
                 end
               end or acc << { associate: { assoc: name, keys: opts[:key] } }
+
+              assoc_names << name
             end
 
             after_hooks = associations.each_with_object([]) do |(name, opts), acc|
               next unless relation.associations.key?(name)
 
               assoc = relation.associations[name]
 
               if assoc.is_a?(Association::ManyToMany)
                 acc << { associate: { assoc: assoc, keys: assoc.join_keys(relation.__registry__) } }
+                assoc_names << name
               end
             end
 
-            command.before(*before_hooks).after(*after_hooks)
+            command.
+              with_opts(configured_associations: assoc_names).
+              before(*before_hooks).
+              after(*after_hooks)
           end
 
           # Set command to associate tuples with a parent tuple using provided keys
           #
           # @example
@@ -118,15 +141,15 @@
           # @param [Hash] options The options
           # @option options [Array] :key The association keys
           #
           # @api public
           def associates(name, options = EMPTY_HASH)
-            if associations.map(&:first).include?(name)
+            if associations.key?(name)
               raise ArgumentError,
                     "#{name} association is already defined for #{self.class}"
             end
 
-            associations(associations.dup << [name, options])
+            associations(associations.merge(name => options))
           end
         end
       end
     end
   end