glue_gun_dsl 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 204effd0afcc5b7a8b1ac6f80ec1ddde4f99039817b0fe84e1a6747c76c13e27
-  data.tar.gz: 227f7029e97ef1639ffbbebf5b0d8273ff0c7a084b5950aa8040c9f91e3be26c
+  metadata.gz: a573097a1db8e4af5573a1b0374e43dc12dcadc22f4e4a950bd6d5fe4a9084a1
+  data.tar.gz: 1db836fbee10ab0594495e5f137f0337ec62a8b90eeabc29bc55be0dab6ade9b
 SHA512:
-  metadata.gz: 3ee786e7b526c47e62de741a0fd0eb686e890d8e176e4424157d7bd4488f81e0750b7efb2d1d27ee0092e415d92b342ae7d4f6575e1c82ce932aaebcaf56cc26
-  data.tar.gz: 67434b47dc06d5b258d5a1f1286859879c414b4131d17e66a8651378586312ff0b157825e45e2a939625b3a355a0dcbcff7691f0220d5f61cf6fbe8ba2933746
+  metadata.gz: ad634073ed8206277b1eb502b2da7eff90e92cc820adcabc1dc647dee8e2f0c7cdf4ea7c2cc9fdd4b8a3b5f46caff7a6d4c55f82d3780a180b719af5729d4a51
+  data.tar.gz: 3048844dcbae257696ab142798ead0957b97bda029c151da4d9e5181b90d3da43099ecd6ec79784efb2499b0fd699a0dca2e24513e1fc20c461dae3648a4390d

data/lib/glue_gun/dsl.rb

@@ -61,7 +61,10 @@ module GlueGun
           end
         end
 
-        normal_attributes.reverse_merge!(root_dir: detect_root_dir) if attribute_definitions.keys.include?(:root_dir)
+        if attribute_definitions.keys.include?(:root_dir) && attribute_definitions.dig(:root_dir, :options,
+                                                                                       :default).nil?
+          normal_attributes.reverse_merge!(root_dir: detect_root_dir)
+        end
 
         # Call super to allow ActiveModel to assign attributes
         super(normal_attributes)
@@ -98,13 +101,19 @@ module GlueGun
         end
       end
 
-      def dependency(component_type, factory_class = nil, &block)
-        if factory_class
-          dependency_definitions[component_type] = factory_class
+      def dependency(component_type, options = {}, factory_class = nil, &block)
+        if options.is_a?(Class)
+          factory_class = options
+          options = {}
+        end
+        is_array = options[:array] || false
+
+        if factory_class.present?
+          dependency_definitions[component_type] = { factory_class: factory_class, array: is_array }
         else
           dependency_builder = DependencyBuilder.new(component_type)
           dependency_builder.instance_eval(&block)
-          dependency_definitions[component_type] = dependency_builder
+          dependency_definitions[component_type] = { builder: dependency_builder, array: is_array }
         end
 
         # Define singleton method to allow hardcoding dependencies in subclasses
@@ -170,16 +179,49 @@ module GlueGun
 
     def initialize_dependency(component_type, init_args = {}, definition = nil)
       definition ||= self.class.dependency_definitions[component_type]
-
-      if definition.is_a?(Class) && definition.include?(GlueGun::DSL)
-        # If the definition is a factory class, use it to create the dependency
-        factory_instance = definition.new
-        return factory_instance.send(:initialize_dependency, component_type, init_args)
+      is_array = definition[:array]
+
+      if is_array
+        dep = []
+        config = []
+        Array(init_args).each do |args|
+          d, c = initialize_single_dependency(component_type, args, definition)
+          dep.push(d)
+          config.push(c)
+        end
+      else
+        dep, config = initialize_single_dependency(component_type, init_args, definition)
       end
 
-      return init_args if dependency_injected?(component_type, init_args)
+      dependencies[component_type] = {
+        instance: dep,
+        option: config
+      }
+
+      dep
+    end
+
+    def initialize_factory_dependency(component_type, init_args, definition)
+      factory_instance = definition[:factory_class].new
 
-      dependency_builder = definition
+      # Pass the parent instance to the factory
+      factory_instance.instance_variable_set(:@parent, self)
+
+      dep_defs = factory_instance.dependency_definitions
+      definition = dep_defs[dep_defs.keys.first]
+
+      if dep_defs.key?(component_type)
+        factory_instance.send(:initialize_single_dependency, component_type, init_args, definition)
+      elsif dep_defs.keys.one?
+        factory_instance.send(:initialize_single_dependency, dep_defs.keys.first, init_args, definition)
+      else
+        raise ArgumentError,
+              "Don't know how to use Factory #{factory_instance.class} to build dependency '#{component_type}'"
+      end
+    end
+
+    def initialize_builder_dependency(component_type, init_args, definition)
+      dependency_builder = definition[:builder]
 
       if init_args && init_args.is_a?(Hash) && init_args.key?(:option_name)
         option_name = init_args[:option_name]
@@ -192,30 +234,24 @@ module GlueGun
 
       raise ArgumentError, "Unknown #{component_type} option '#{option_name}'" unless option_config
 
-      dep_attributes = init_args.is_a?(Hash) ? init_args : {}
-
-      # Build dependency attributes, including sourcing from parent
-      dep_attributes = build_dependency_attributes(option_config, dep_attributes)
+      [instantiate_dependency(option_config, init_args), option_config]
+    end
 
-      if dep_attributes.key?(:id)
-        raise ArgumentError,
-              "cannot bind attribute 'id' between #{self.class.name} and #{option_config.class_name}. ID is reserved for primary keys in Ruby on Rails"
+    def initialize_single_dependency(component_type, init_args, definition)
+      if dependency_injected?(component_type, init_args)
+        dep = init_args
+        option_config = injected_dependency(component_type, init_args)
+      elsif definition[:factory_class]
+        dep, option_config = initialize_factory_dependency(component_type, init_args, definition)
+      else
+        dep, option_config = initialize_builder_dependency(component_type, init_args, definition)
       end
 
-      dependency_instance = instantiate_dependency(option_config, dep_attributes)
-
-      # Keep track of dependencies for attribute binding
-      dependencies[component_type] = {
-        instance: dependency_instance,
-        option: option_config
-      }
-
-      dependency_instance
+      [dep, option_config]
     end
 
     def build_dependency_attributes(option_config, dep_attributes)
       option_config.attributes.each do |attr_name, attr_config|
-        # If the attribute is already provided, use it
         if dep_attributes.key?(attr_name)
           value = dep_attributes[attr_name]
         else
@@ -223,6 +259,8 @@ module GlueGun
                     send(attr_config.source)
                   elsif respond_to?(attr_name)
                     send(attr_name)
+                  elsif instance_variable_defined?(:@parent) && @parent.respond_to?(attr_name)
+                    @parent.send(attr_name)
                   else
                     attr_config.default
                   end
@@ -235,7 +273,7 @@ module GlueGun
     end
 
     def determine_option_name(component_type, init_args)
-      dependency_builder = self.class.dependency_definitions[component_type]
+      dependency_builder = self.class.dependency_definitions[component_type][:builder]
 
       option_name = nil
 
@@ -269,11 +307,18 @@ module GlueGun
       [option_name, init_args]
     end
 
-    def instantiate_dependency(option_config, dep_attributes)
+    def instantiate_dependency(option_config, init_args)
+      dep_attributes = init_args.is_a?(Hash) ? init_args : {}
+
+      # Build dependency attributes, including sourcing from parent
+      dep_attributes = build_dependency_attributes(option_config, dep_attributes)
+
+      if dep_attributes.key?(:id)
+        raise ArgumentError,
+              "cannot bind attribute 'id' between #{self.class.name} and #{option_config.class_name}. ID is reserved for primary keys in Ruby on Rails"
+      end
       dependency_class = option_config.class_name
-      dependency_instance = dependency_class.new(dep_attributes)
-      dependency_instance.validate! if false # dependency_instance.respond_to?(:validate!)
-      dependency_instance
+      dependency_class.new(dep_attributes)
     end
 
     def propagate_changes
@@ -287,33 +332,58 @@ module GlueGun
     end
 
     def propagate_attribute_change(attr_name, value)
-      self.class.dependency_definitions.each do |component_type, _dependency_builder|
+      self.class.dependency_definitions.each do |component_type, _builder|
         dependency_instance = send(component_type)
-        option_config = dependencies.dig(component_type, :option)
-        next unless option_config
 
-        bound_attrs = option_config.attributes.select do |_, attr_config|
-          (attr_config.source == attr_name.to_sym) || (attr_config.name == attr_name.to_sym)
-        end
+        if dependency_instance.is_a?(Array)
+          option_config = dependencies.dig(component_type, :option)
 
-        bound_attrs.each do |dep_attr_name, config_attr|
-          block = config_attr.block.present? ? config_attr.block : proc { |att| att }
-          if dependency_instance.respond_to?("#{dep_attr_name}=")
-            dependency_instance.send("#{dep_attr_name}=",
-                                     block.call(value))
+          dependency_instance.zip(option_config).each do |dep, opt|
+            propagate_attribute_to_instance(attr_name, value, dep, opt)
           end
+        else
+          option_config = dependencies.dig(component_type, :option)
+          next unless option_config
+
+          propagate_attribute_to_instance(attr_name, value, dependency_instance, option_config)
         end
       end
     end
 
-    def dependency_injected?(component_type, value)
-      dependency_builder = self.class.dependency_definitions[component_type]
-      dependency_builder.option_configs.values.any? do |option|
+    def propagate_attribute_to_instance(attr_name, value, dependency_instance, option_config)
+      bound_attrs = option_config.attributes.select do |_, attr_config|
+        (attr_config.source == attr_name.to_sym) || (attr_config.name == attr_name.to_sym)
+      end
+
+      bound_attrs.each do |dep_attr_name, config_attr|
+        block = config_attr.block.present? ? config_attr.block : proc { |att| att }
+        if dependency_instance.respond_to?("#{dep_attr_name}=")
+          dependency_instance.send("#{dep_attr_name}=",
+                                   block.call(value))
+        end
+      end
+    end
+
+    def injected_dependency(component_type, value)
+      definition = self.class.dependency_definitions[component_type]
+      builder = definition[:builder]
+      factory = definition[:factory_class]
+
+      option_configs = if builder
+                         builder.option_configs
+                       else
+                         factory.dependency_definitions.values.first.values.first.option_configs
+                       end
+      option_configs.values.select do |option|
         option_class = option.class_name
         value.is_a?(option_class)
       end
     end
 
+    def dependency_injected?(component_type, value)
+      injected_dependency(component_type, value).any?
+    end
+
     def dependencies
       @dependencies ||= {}
     end

data/lib/glue_gun/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GlueGun
-  VERSION = "0.1.14"
+  VERSION = "0.1.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glue_gun_dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.15
 platform: ruby
 authors:
 - Brett Shollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel