glue_gun_dsl 0.1.19 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68fc0793c49beee7168734f15f10ef57334c0fbbb0f4373c74cfdad16b416a2f
-  data.tar.gz: 34ba98c7f1518de7b16ae4c2d1e4cd9f5c8224ad911c3d7bc14ed21dec139fe8
+  metadata.gz: 1757d5bf22062e71a309eb62fd4b55aa830d36a7e7cde695f8525b960d5a0a89
+  data.tar.gz: 8f591ab19ba6b88118834b65aa210166408bc127afba0551bb2792505e7abc64
 SHA512:
-  metadata.gz: 72d8a6751b6ed9d9ea22f8dfb8e89386b2217bbdfc17f922716a208ca9fce8a290762ceb43dcb301d32e9733058c1ea7433b8435a8b6f3b9feb96db83ceaeaaa
-  data.tar.gz: 4cece38fc3e06acd4c285a4e8d04e19d69c01b39ac80af8815f967b96df7f863ef225bad172fb4e5231552a107ae092445feee107b3419225db3e6c9d26f59b1
+  metadata.gz: c25769bebf3f9e450970506b45fa13c82281d223f3da07f1d3e667597678903da636422c24924525456f1063b4d142722729fc9bb240eec9801a6d67a1a5fae9
+  data.tar.gz: 13e57e0b3cc63e2ed15e26d480d0622e6413476dae3fff9ba8bf1686fc6fa4c314baad22452b157982cd10699cbb6f6574c84130168d83874d817aef0dbc98e9

data/lib/glue_gun/core_ext/hash_extensions.rb

@@ -0,0 +1,22 @@
+module GlueGun
+  module HashExtensions
+    def deep_compact
+      each_with_object({}) do |(key, value), result|
+        next if value.nil?
+
+        compacted = if value.is_a?(Hash)
+                      value.deep_compact
+                    elsif value.is_a?(Array)
+                      value.map { |v| v.is_a?(Hash) ? v.deep_compact : v }.compact
+                    else
+                      value
+                    end
+
+        result[key] = compacted unless compacted.blank?
+      end
+    end
+  end
+end
+
+# Extend Hash class with our custom method
+Hash.include GlueGun::HashExtensions

data/lib/glue_gun/core_ext.rb

@@ -0,0 +1,5 @@
+module GlueGun
+  module CoreExt
+    require_relative "core_ext/hash_extensions"
+  end
+end

data/lib/glue_gun/dsl.rb

@@ -272,6 +272,10 @@ module GlueGun
       @dependencies ||= {}
     end
 
+    def inspect
+      "#<#{self.class} #{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}>"
+    end
+
     def validate_dependencies
       errors.clear
       self.class.dependency_definitions.keys.each do |component_type|
@@ -414,7 +418,7 @@ module GlueGun
       def build_dependency_attributes(option_config, dep_attributes, parent)
         option_config.attributes.each do |attr_name, attr_config|
           if dep_attributes.key?(attr_name)
-            value = dep_attributes[attr_name]
+            dep_attributes[attr_name]
           else
             value = if attr_config.source && parent.respond_to?(attr_config.source)
                       parent.send(attr_config.source)
@@ -428,7 +432,7 @@ module GlueGun
           end
         end
 
-        dep_attributes
+        dep_attributes.deep_compact
       end
 
       def determine_option_name(init_args, instance)

data/lib/glue_gun/model.rb

@@ -0,0 +1,164 @@
+module GlueGun
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :serialize_service_object
+      after_find :deserialize_service_object
+
+      class_attribute :service_class_resolver
+      class_attribute :service_class
+      class_attribute :service_attribute_name
+
+      # Set default service attribute name based on the class name
+      self.service_attribute_name = "#{name.demodulize.underscore}_service".to_sym
+    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
+      end
+    end
+
+    def initialize(attributes = {})
+      attributes = attributes.deep_symbolize_keys
+      db_attributes = extract_db_attributes(attributes)
+      super(db_attributes)
+      self.class.send(:attr_reader, service_attribute_name)
+      build_service_object(attributes)
+    end
+
+    private
+
+    def extract_db_attributes(attributes)
+      # Extract attributes that correspond to database columns or associations
+      column_names = self.class.column_names.map(&:to_sym)
+      association_names = self.class.reflect_on_all_associations.map(&:name)
+
+      attributes.slice(*(column_names + association_names))
+    end
+
+    def build_service_object(attributes)
+      service_class = resolve_service_class(attributes)
+      service_attributes = extract_service_attributes(attributes, service_class)
+      service_instance = service_class.new(service_attributes)
+      instance_variable_set("@#{service_attribute_name}", service_instance)
+    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}"
+      end
+    end
+
+    def extract_service_attributes(attributes, service_class)
+      allowed_attrs = service_attributes(service_class)
+      attrs_and_associations(attributes).slice(*allowed_attrs)
+    end
+
+    def service_attributes(service_class)
+      service_class.dependency_definitions.keys.concat(
+        service_class.attribute_definitions.keys
+      )
+    end
+
+    def attrs_and_associations(attributes)
+      foreign_keys = foreign_key_map
+      attributes.inject({}) do |h, (k, v)|
+        h.tap do
+          if foreign_keys.include?(k)
+            assoc_name = foreign_keys[k]
+            h[assoc_name] = send(assoc_name)
+          else
+            h[k] = v
+          end
+        end
+      end
+    end
+
+    def foreign_key_map
+      self.class.reflect_on_all_associations.inject({}) do |h, assoc|
+        h.tap do
+          h[assoc.foreign_key] = assoc.name
+        end
+      end.symbolize_keys
+    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
+      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
+
+          hash[dep] = {
+            selected_option => service_object.send(dep).attributes
+          }
+        end
+      end
+      json = attrs.merge(deps.deep_compact).deep_symbolize_keys
+      write_attribute(:configuration, json.to_json)
+    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 = service_class.deserialize(serialized_data) if service_class.respond_to?(:deserialize)
+      service_instance = service_class.new(serialized_data)
+      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 serialize
+      dataset_service.attributes
+      write_attribute(:configuration, json.to_json)
+    end
+
+    def deserialize
+      options = JSON.parse(read_attribute(:configuration))
+      options.deep_symbolize_keys!
+
+      build_dataset_service(options)
+    end
+
+    def method_missing(method_name, *args, &block)
+      service_object = instance_variable_get("@#{service_attribute_name}")
+
+      if service_object && service_object.respond_to?(method_name)
+        service_object.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      service_object = instance_variable_get("@#{service_attribute_name}")
+      service_object && service_object.respond_to?(method_name) || super
+    end
+  end
+end

data/lib/glue_gun/my_model.rb

@@ -0,0 +1,73 @@
+module EasyML
+  class Dataset < ActiveRecord::Base
+    before_save :serialize
+    after_find :deserialize
+
+    validates :name, presence: true
+    belongs_to :datasource,
+               foreign_key: :datasource_id,
+               class_name: "EasyML::Datasource"
+
+    def initialize(options = {})
+      super(EasyML::DbOptions.parse(options, self))
+      build_dataset_service(options)
+    end
+
+    attr_accessor :dataset_service
+
+    private
+
+    def build_dataset_service(options)
+      options.deep_symbolize_keys!
+      service_klass = EasyML::Data::Dataset
+
+      allowed_attr_names = service_klass.dependency_definitions.keys.concat(
+        service_klass.attribute_definitions.keys
+      )
+
+      allowed_attrs = options.slice(*allowed_attr_names)
+      @dataset_service = service_klass.new(allowed_attrs)
+      define_dataset_service_delegators(allowed_attr_names)
+    end
+
+    def define_dataset_service_delegators(attr_names)
+      allowed_names(attr_names).each do |attr_name|
+        define_singleton_method(attr_name) do
+          dataset_service.send(attr_name)
+        end
+      end
+    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 serialize
+      attrs = dataset_service.attributes
+      deps = allowed_names(dataset_service.dependency_definitions.keys).inject({}) do |hash, dep|
+        hash.tap do
+          this_dep = dataset_service.send(dep)
+          next unless this_dep.present?
+
+          opts = dataset_service.dependency_definitions[dep].option_configs
+          selected_option = opts.detect do |_k, v|
+            this_dep.class == v.class_name
+          end.first
+          hash[dep] = {
+            selected_option => dataset_service.send(dep).attributes
+          }
+        end
+      end
+      json = attrs.merge(deps).deep_symbolize_keys.deep_compact
+      write_attribute(:configuration, json.to_json)
+    end
+
+    def deserialize
+      options = JSON.parse(read_attribute(:configuration))
+      options.deep_symbolize_keys!
+
+      build_dataset_service(options)
+    end
+  end
+end

data/lib/glue_gun/version.rb

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

data/lib/glue_gun.rb

@@ -4,6 +4,8 @@ require "active_support/concern"
 
 module GlueGun
   require_relative "glue_gun/version"
+  require_relative "glue_gun/core_ext"
   require_relative "glue_gun/types"
   require_relative "glue_gun/dsl"
+  require_relative "glue_gun/model"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glue_gun_dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.21
 platform: ruby
 authors:
 - Brett Shollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-17 00:00:00.000000000 Z
+date: 2024-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -190,7 +190,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/glue_gun.rb
+- lib/glue_gun/core_ext.rb
+- lib/glue_gun/core_ext/hash_extensions.rb
 - lib/glue_gun/dsl.rb
+- lib/glue_gun/model.rb
+- lib/glue_gun/my_model.rb
 - lib/glue_gun/types.rb
 - lib/glue_gun/types/array_type.rb
 - lib/glue_gun/types/date_time_type.rb