glue_gun_dsl 0.1.28 → 0.1.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5b050524f016e18d7b9937fbc5bbba5e8bf989690fdfda10a6bd0adf09aeb86
-  data.tar.gz: 2eab6853e671117b5253de7a88b9edb0f5274c5688ddd5817ce35ad77d8185de
+  metadata.gz: 43d8acb6f057ab8a1af500f7c179ab11799e76a5a00936e3b75c2e8d89ebf31b
+  data.tar.gz: c1eca08d776bb20638e544ccf4263a65cabde137bbc821f871b0f0898b7b062d
 SHA512:
-  metadata.gz: 30b842fe667aa8f8785a903d1b61f3e3fb65799cc417214392ecde7022251fd3ab212f81d5d26ea9d8818ca3241649729eb92b8e6454c128a8659f12d3f2f96a
-  data.tar.gz: c000b550317b50a2c17c985f8d7e574e4bef04444e20f9cfdecef46420efa14e931a11f01334e1ad06f04889a60a3dedd29cdd3118fab478236b0703a06b3bbb
+  metadata.gz: 5560e86452000ea065de2721466104a8c1f108db0b57c608c8248ab84565e317db518ea93be0ea2bad3f148075ac78666fed7c48674f59978af07196d485a8b6
+  data.tar.gz: 0b384297f71a53a34f3def7fe0542ed993e5fb9c09160f0ec4f10b39a4481a83503d7e5b38337f4eea597eba6c3f73adecce59d551886b6d1bfc6d137e61452d

data/lib/glue_gun/model.rb

@@ -1,4 +1,5 @@
 require_relative "shared"
+require_relative "serializers"
 module GlueGun
   module Model
     extend ActiveSupport::Concern
@@ -139,6 +140,10 @@ module GlueGun
 
     private
 
+    def awesome_print(message)
+      ap message
+    end
+
     def build_service_object(attributes)
       self.class.send(:attr_reader, service_attribute_name)
       service_class = resolve_service_class(attributes)
@@ -148,9 +153,9 @@ module GlueGun
       begin
         service_instance = service_class.new(service_attributes)
       rescue StandardError => e
-        ap %(Error building service object #{service_class}:)
-        ap e.message
-        ap e.backtrace
+        awesome_print %(Error building service object #{service_class}:)
+        awesome_print e.message
+        awesome_print e.backtrace
         raise e
       end
       instance_variable_set("@#{service_attribute_name}", service_instance)
@@ -159,8 +164,10 @@ module GlueGun
     def resolve_service_type(attributes, initializing = false)
       attrs = if initializing || !persisted? || attributes.key?(self.class.option_key)
                 attributes
-              else
+              elsif respond_to?(self.class.option_key)
                 { self.class.option_key => send(self.class.option_key) }
+              else
+                { self.class.option_key => self.class.service_registry.default_key }
               end
       attrs[self.class.option_key] || self.class.service_registry.default_key
     end
@@ -211,119 +218,20 @@ module GlueGun
       end.symbolize_keys
     end
 
-    def serialize_object(object)
-      if object.respond_to?(:serialize)
-        object.serialize
-      elsif object.respond_to?(:attributes)
-        object.attributes.deep_compact
-      else
-        Hash[object.instance_variables.map do |var|
-          [var.to_s.delete("@"), object.instance_variable_get(var)]
-        end].deep_compact
-      end
-    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 = serialize_object(dep_instance)
-      {
-        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
-      attrs = serialize_object(service_object)
-      deps = allowed_names(service_object.dependency_definitions.keys).inject({}) do |hash, dep|
-        hash.tap do
-          serialized = serialize_dependency(dep)
-          next if serialized.nil?
-
-          hash[dep] = serialized
-        end
-      end
-      json = serializable!(attrs.merge(deps).deep_symbolize_keys)
-      write_attribute(:configuration, json.to_json)
-    end
-
-    def serializable!(json)
-      regular_args = json.slice(*allowed_names(json.keys))
-      assoc_names = self.class.reflect_on_all_associations.map(&:name)
-      found_associations = assoc_names & json.keys
-      found_associations.each do |association|
-        regular_args[association] = true
-      end
-      regular_args
-    end
-
-    def deserialize_associations(json)
-      assoc_names = self.class.reflect_on_all_associations.map(&:name)
-      found_associations = assoc_names & json.keys
-      found_associations.each do |association|
-        json[association] = send(association)
-      end
-      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
+      GlueGun::Serializers.new(self).serialize_service_object(service_object)
     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)
+      deserialized = GlueGun::Serializers.new(self).deserialize_service_object
+      service_instance = build_service_object(deserialized)
       instance_variable_set("@#{service_attribute_name}", service_instance)
     end
 
-    def allowed_names(names)
-      assoc_names = self.class.reflect_on_all_associations.map(&:name)
-      [names.map(&:to_sym) - assoc_names.map(&:to_sym)].flatten
-    end
-
     def method_missing(method_name, *args, **kwargs, &block)
       service_object = instance_variable_get("@#{service_attribute_name}")
 

data/lib/glue_gun/serializers.rb

@@ -0,0 +1,164 @@
+module GlueGun
+  class Serializers
+    attr_accessor :instance
+
+    def initialize(instance)
+      @instance = instance
+    end
+
+    def serialize_object(object)
+      if object.respond_to?(:serialize)
+        object.serialize
+      elsif object.respond_to?(:attributes)
+        object.attributes.deep_compact
+      else
+        Hash[object.instance_variables.map do |var|
+          [var.to_s.delete("@"), object.instance_variable_get(var)]
+        end].deep_compact
+      end
+    end
+
+    def serialize_dependency(service_object, dependency, dep_instance = nil)
+      dep_instance = service_object.send(dependency) if dep_instance.nil?
+      return nil unless dep_instance.present?
+
+      if dep_instance.is_a?(Array)
+        return dep_instance.map do |dep|
+          serialize_dependency(service_object, dependency, dep)
+        end
+      end
+
+      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 = serialize_object(dep_instance)
+      {
+        selected_option => serialized
+      }
+    end
+
+    def service_class
+      service_object.class
+    end
+
+    def allowed_names(names)
+      assoc_names = instance.class.reflect_on_all_associations.map(&:name)
+      [names.map(&:to_sym) - assoc_names.map(&:to_sym)].flatten
+    end
+
+    def serialize_service_object(service_object)
+      attrs = serialize_object(service_object)
+      deps = allowed_names(service_object.dependency_definitions.keys).inject({}) do |hash, dep|
+        hash.tap do
+          serialized = serialize_dependency(service_object, dep)
+          next if serialized.nil?
+
+          hash[dep] = serialized
+        end
+      end
+      json = serializable!(serialize_attrs(attrs.merge(deps).deep_symbolize_keys))
+      instance.write_attribute(:configuration, json.to_json)
+    end
+
+    def serializable!(json)
+      regular_args = json.slice(*allowed_names(json.keys))
+      assoc_names = instance.class.reflect_on_all_associations.map(&:name)
+      found_associations = assoc_names & json.keys
+      found_associations.each do |association|
+        regular_args[association] = true
+      end
+      regular_args
+    end
+
+    def deserialize_associations(json)
+      assoc_names = instance.class.reflect_on_all_associations.map(&:name)
+      found_associations = assoc_names & json.keys
+      found_associations.each do |association|
+        json[association] = instance.send(association)
+      end
+      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(instance.read_attribute(:configuration) || "{}")
+      serialized_data.deep_symbolize_keys!
+      serialized_data = deserialize_attrs(serialized_data)
+      service_class = instance.send(:resolve_service_class, serialized_data)
+      serialized_data = deserialize_associations(serialized_data)
+      serialized_data = service_class.deserialize(serialized_data) if service_class.respond_to?(:deserialize)
+      deserialize_dependencies(serialized_data, service_class)
+    end
+
+    def serialize_attrs(attrs)
+      attrs.deep_transform_values do |value|
+        case value
+        when ActiveSupport::TimeWithZone
+          { "__type__" => "ActiveSupport::TimeWithZone", "value" => value.iso8601 }
+        else
+          value
+        end
+      end
+    end
+
+    def deserialize_attrs(attrs)
+      return nil if attrs.nil?
+
+      attrs.transform_values do |value|
+        recursive_deserialize(value)
+      end
+    end
+
+    def recursive_deserialize(value)
+      case value
+      when Hash
+        if value[:__type__]
+          deserialize_special_type(value)
+        else
+          value.transform_values { |v| recursive_deserialize(v) }
+        end
+      when Array
+        value.map { |v| recursive_deserialize(v) }
+      else
+        value
+      end
+    end
+
+    def deserialize_special_type(value)
+      case value[:__type__]
+      when "ActiveSupport::TimeWithZone"
+        Time.zone.parse(value[:value])
+      else
+        value[:value]
+      end
+    end
+  end
+end

data/lib/glue_gun/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glue_gun_dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.28
+  version: 0.1.30
 platform: ruby
 authors:
 - Brett Shollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-24 00:00:00.000000000 Z
+date: 2024-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -196,6 +196,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: GlueGun makes dependency injection and hydration a first-order concern
 email:
 - brett.shollenberger@gmail.com
@@ -208,6 +222,7 @@ files:
 - lib/glue_gun/core_ext/hash_extensions.rb
 - lib/glue_gun/dsl.rb
 - lib/glue_gun/model.rb
+- lib/glue_gun/serializers.rb
 - lib/glue_gun/shared.rb
 - lib/glue_gun/types.rb
 - lib/glue_gun/types/array_type.rb