glue_gun_dsl 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a744558606a85cbfc6641c33ba4aae92925712e9ee8b30555aad1309773def0e
-  data.tar.gz: 49d3742eccba3ed436ee950b74c8aa5627d5a36ac1cca8fafe625904f9cd567d
+  metadata.gz: a573097a1db8e4af5573a1b0374e43dc12dcadc22f4e4a950bd6d5fe4a9084a1
+  data.tar.gz: 1db836fbee10ab0594495e5f137f0337ec62a8b90eeabc29bc55be0dab6ade9b
 SHA512:
-  metadata.gz: 3fd64a4f71a0fd2fee778ce93609bbda6bbf38aff76feeeb9c8bd8d427c75def7c83471ac091cf40dbcc6f7ca16070ed2a89cf1d19e3e1d3eb48c2196d213edf
-  data.tar.gz: 46e927fdfe42d553b6ee39e069cfea564fa2d10afd6548618d5bfd1b35db964024d0156a84986f126f85929b78a89de31c3994f61b43780906a3b3cf0b0c2194
+  metadata.gz: ad634073ed8206277b1eb502b2da7eff90e92cc820adcabc1dc647dee8e2f0c7cdf4ea7c2cc9fdd4b8a3b5f46caff7a6d4c55f82d3780a180b719af5729d4a51
+  data.tar.gz: 3048844dcbae257696ab142798ead0957b97bda029c151da4d9e5181b90d3da43099ecd6ec79784efb2499b0fd699a0dca2e24513e1fc20c461dae3648a4390d

data/lib/glue_gun/dsl.rb

@@ -28,7 +28,7 @@ module GlueGun
         prepend ClassMethods
       end
 
-      # Overriding ActiveModel.assign_attributes to ensure change propagation to dependenices
+      # Overriding ActiveModel.assign_attributes to ensure change propagation to dependencies
       def assign_attributes(new_attributes)
         super(new_attributes)
         propagate_changes if initialized?
@@ -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)
@@ -79,6 +82,7 @@ module GlueGun
                      elsif ActiveModel.version >= Gem::Version.new("5")
                        ActiveModel::Type::Value.new
                      end
+
       # Override the attribute method to define custom setters
       def attribute(name, type = DEFAULT_TYPE, **options)
         super(name, type, **options)
@@ -97,10 +101,20 @@ module GlueGun
         end
       end
 
-      def dependency(component_type, &block)
-        dependency_builder = DependencyBuilder.new(component_type)
-        dependency_builder.instance_eval(&block)
-        dependency_definitions[component_type] = dependency_builder
+      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] = { builder: dependency_builder, array: is_array }
+        end
 
         # Define singleton method to allow hardcoding dependencies in subclasses
         define_singleton_method component_type do |option = nil, options = {}|
@@ -157,16 +171,57 @@ module GlueGun
     end
 
     def initialize_dependencies(attributes)
-      self.class.dependency_definitions.each do |component_type, _|
+      self.class.dependency_definitions.each do |component_type, definition|
         value = attributes[component_type] || self.class.hardcoded_dependencies[component_type]
-        instance_variable_set("@#{component_type}", initialize_dependency(component_type, value))
+        instance_variable_set("@#{component_type}", initialize_dependency(component_type, value, definition))
       end
     end
 
-    def initialize_dependency(component_type, init_args = {})
-      return init_args if dependency_injected?(component_type, init_args)
+    def initialize_dependency(component_type, init_args = {}, definition = nil)
+      definition ||= self.class.dependency_definitions[component_type]
+      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
+
+      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 = self.class.dependency_definitions[component_type]
+      # 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]
@@ -179,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
@@ -210,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
@@ -222,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
 
@@ -256,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
@@ -274,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.13"
+  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.13
+  version: 0.1.15
 platform: ruby
 authors:
 - Brett Shollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-08 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel