glue_gun_dsl 0.1.24 → 0.1.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2fd5acfe5156d1581b51d68d5598ef181faea52ec3c46d730fef428f7faba15
-  data.tar.gz: c6185af99fd906dd841582b283b4559d8f1fbc4e3046086d7cf4a15ac5e1b1d3
+  metadata.gz: 697e6798ae2b2c4c3db3f4e3cd9b2c65ccc8081386636c08366e4d023cb04afe
+  data.tar.gz: f7a025244f1b5627691676d784658d2a14a289914533e17f4c1daca896c6ebdf
 SHA512:
-  metadata.gz: 587486d0afa4a7cde26ffc1a6d6a766123db4c09111b4f2e9d3b4f9f17651856a6a587b81832cb78fe93fa6d0f9f23cae88c145a61ac9905968508ffb6f8b7fc
-  data.tar.gz: 14d80f872b13ada859d605068799e8331136c36db88e9dd5ba81eadd93b34b7362918e08eb3e1a48848e8b42ea4477f597d43cc1b3633205dfdc2d2e84d66b5d
+  metadata.gz: 8d32f478f2e294ae9510abb04b0ac5b5490c8468918879363f790eebc5167d7c3e28ec5edf9675301a2a211b7f5493bcf24c1884295598e9cf859f5b6b146f21
+  data.tar.gz: ee627464ed957cffac221bd2d701e9a9deba768e1cac558349878d101b67281a2c5977379f79496af43ed7bdbc392489c60e7d3fec2d09445b2e35526d2d256f

data/lib/glue_gun/model.rb

@@ -3,6 +3,40 @@ module GlueGun
   module Model
     extend ActiveSupport::Concern
 
+    class ServiceRegistry
+      attr_accessor :services
+
+      def register(k, v)
+        @services ||= {}
+        @services[k.to_sym] = v
+      end
+
+      def options
+        services.keys
+      end
+
+      def []=(k, v)
+        register(k, v)
+      end
+
+      def [](k)
+        return nil if k.nil?
+
+        @services ||= {}
+        @services.dig(k.to_sym)
+      end
+
+      def default_key
+        return unless services.keys.count == 1
+
+        services.keys.first
+      end
+
+      def default
+        default_key.present? ? services[default_key] : nil
+      end
+    end
+
     included do
       include GlueGun::Shared
 
@@ -16,6 +50,13 @@ module GlueGun
       # Set default service attribute name based on the class name
       self.service_attribute_name = "#{name.demodulize.underscore}_service".to_sym
 
+      class_attribute :service_registry
+      self.service_registry = ServiceRegistry.new
+
+      # Set default option key based on the class name
+      class_attribute :option_key
+      self.option_key = "#{name.demodulize.underscore}_type".to_sym
+
       def assign_attributes(attributes)
         return if attributes.blank?
 
@@ -31,14 +72,8 @@ module GlueGun
     end
 
     class_methods do
-      def service(class_or_proc = nil, &block)
-        if class_or_proc.is_a?(Class)
-          self.service_class = class_or_proc
-        elsif block_given?
-          self.service_class_resolver = block
-        else
-          raise ArgumentError, "You must provide a service class, factory, or a block to resolve the service class."
-        end
+      def service(key, service_class)
+        service_registry[key] = service_class
       end
 
       def find_or_create_by!(attributes)
@@ -77,8 +112,10 @@ module GlueGun
     end
 
     def initialize(attributes = {})
-      attributes[:root_dir] = detect_root_dir
+      attributes = {} if attributes.nil?
+      attributes[:root_dir] ||= detect_root_dir
       attributes = attributes.deep_symbolize_keys
+      attributes[option_key] ||= resolve_service_type(attributes, true)
       db_attributes = self.class.extract_db_attributes(attributes)
       super(db_attributes)
       build_service_object(attributes)
@@ -119,14 +156,26 @@ module GlueGun
       instance_variable_set("@#{service_attribute_name}", service_instance)
     end
 
+    def resolve_service_type(attributes, initializing = false)
+      attrs = if initializing || !persisted? || attributes.key?(self.class.option_key)
+                attributes
+              else
+                { self.class.option_key => send(self.class.option_key) }
+              end
+      attrs[self.class.option_key] || self.class.service_registry.default_key
+    end
+
     def resolve_service_class(attributes)
-      if self.class.service_class
-        self.class.service_class
-      elsif self.class.service_class_resolver
-        self.class.service_class_resolver.call(attributes)
-      else
-        raise "Service class not defined for #{self.class.name}"
+      type = resolve_service_type(attributes)
+      service_class = self.class.service_registry[type] || self.class.service_registry.default
+
+      unless service_class
+        available_types = self.class.service_registry.options
+        raise ArgumentError,
+              "#{self.class} requires argument #{self.class.option_key}. Invalid option key received: #{type}. Allowed options are: #{available_types}"
       end
+
+      service_class
     end
 
     def extract_service_attributes(attributes, service_class)
@@ -162,29 +211,45 @@ module GlueGun
       end.symbolize_keys
     end
 
+    def serialize_dependency(dependency, dep_instance = nil)
+      dep_instance = service_object.send(dependency) if dep_instance.nil?
+      return nil unless dep_instance.present?
+
+      return dep_instance.map { |dep| serialize_dependency(dependency, dep) } if dep_instance.is_a?(Array)
+
+      opts = service_object.dependency_definitions[dependency].option_configs
+      selected_option = opts.detect do |_k, v|
+        dep_instance.class == v.class_name
+      end&.first
+      unless selected_option.present?
+        raise "Don't know how to serialize dependency of type #{dependency}, available options are #{opts.keys}. You didn't specify an option."
+      end
+
+      serialized = dep_instance.respond_to?(:serialize) ? dep_instance.serialize : dep_instance.attributes.deep_compact
+      {
+        selected_option => serialized
+      }
+    end
+
+    def service_object
+      instance_variable_get("@#{service_attribute_name}")
+    end
+
+    def service_class
+      service_object.class
+    end
+
     def serialize_service_object
-      service_object = instance_variable_get("@#{service_attribute_name}")
-      service_klass = service_object.class
-      attrs = service_klass.respond_to?(:serialize) ? service_klass.serialize(service_object) : service_object.attributes
+      attrs = service_object.respond_to?(:serialize) ? service_object.serialize : service_object.attributes.deep_compact
       deps = allowed_names(service_object.dependency_definitions.keys).inject({}) do |hash, dep|
         hash.tap do
-          this_dep = service_object.send(dep)
-          next unless this_dep.present?
-
-          opts = service_object.dependency_definitions[dep].option_configs
-          selected_option = opts.detect do |_k, v|
-            this_dep.class == v.class_name
-          end&.first
-          unless selected_option.present?
-            raise "Don't know how to serialize dependency of type #{dep}, available options are #{opts.keys}. You didn't specify an option."
-          end
+          serialized = serialize_dependency(dep)
+          next if serialized.nil?
 
-          hash[dep] = {
-            selected_option => service_object.send(dep).attributes
-          }
+          hash[dep] = serialized
         end
       end
-      json = serializable!(attrs.merge(deps.deep_compact).deep_symbolize_keys)
+      json = serializable!(attrs.merge(deps).deep_symbolize_keys)
       write_attribute(:configuration, json.to_json)
     end
 
@@ -207,12 +272,37 @@ module GlueGun
       json
     end
 
+    def deserialize_dependency(serialized, definition)
+      return serialized.map { |dep| deserialize_dependency(dep, definition) } if serialized.is_a?(Array)
+
+      dep_name = serialized.keys.first
+      selected_option = definition.option_configs[dep_name]
+      dependency_class = selected_option.class_name
+      arguments = serialized[dep_name]
+
+      dependency_class.respond_to?(:deserialize) ? dependency_class.deserialize(arguments) : arguments
+      {
+        dep_name => arguments
+      }
+    end
+
+    def deserialize_dependencies(serialized_data, service_class)
+      serialized_deps = (serialized_data.keys & allowed_names(service_class.dependency_definitions.keys))
+      serialized_deps.each do |name|
+        serialized = serialized_data[name]
+        definition = service_class.dependency_definitions[name]
+        serialized_data[name] = deserialize_dependency(serialized, definition)
+      end
+      serialized_data
+    end
+
     def deserialize_service_object
       serialized_data = JSON.parse(read_attribute(:configuration) || "{}")
       serialized_data.deep_symbolize_keys!
       service_class = resolve_service_class(serialized_data)
       serialized_data = deserialize_associations(serialized_data)
       serialized_data = service_class.deserialize(serialized_data) if service_class.respond_to?(:deserialize)
+      serialized_data = deserialize_dependencies(serialized_data, service_class)
       service_instance = build_service_object(serialized_data)
       instance_variable_set("@#{service_attribute_name}", service_instance)
     end

data/lib/glue_gun/version.rb

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

metadata

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