glue_gun_dsl 0.1.20 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d372ee94e1c1e2eea155447eb1cdb85a2e0b064e2645528dc8c624cc48a10825
-  data.tar.gz: 766a7cdad82a723ad9e0dd38bc151be81782ef6f3420473c5a912319fe648691
+  metadata.gz: 1757d5bf22062e71a309eb62fd4b55aa830d36a7e7cde695f8525b960d5a0a89
+  data.tar.gz: 8f591ab19ba6b88118834b65aa210166408bc127afba0551bb2792505e7abc64
 SHA512:
-  metadata.gz: 8776e38f53fa08187a26349fced6d516b57afb72469dca06421d583aa9c50b0d53cef3be513bb9bdb131c7b69e44ba4637afc0ec66634aa06f3527f3808ad8ac
-  data.tar.gz: 15faafc27a3812f4ec9ddb9b76d56c79512737e2960b8f746e680bd88954484b1274ef79f735b45fa116edd831a18ea564962e489cdba2983b2923a421d81737
+  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

@@ -432,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.20"
+  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.20
+  version: 0.1.21
 platform: ruby
 authors:
 - Brett Shollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-18 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