glue_gun_dsl 0.1.20 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d372ee94e1c1e2eea155447eb1cdb85a2e0b064e2645528dc8c624cc48a10825
-  data.tar.gz: 766a7cdad82a723ad9e0dd38bc151be81782ef6f3420473c5a912319fe648691
+  metadata.gz: d8f609405b59c865b180e5e07a5a74ebbf4867cea468444983820202b17fbcb7
+  data.tar.gz: b71c914a42fe7175f41b7faa674c30c58d03fcc2c1f54c281bcbf0b8876b1800
 SHA512:
-  metadata.gz: 8776e38f53fa08187a26349fced6d516b57afb72469dca06421d583aa9c50b0d53cef3be513bb9bdb131c7b69e44ba4637afc0ec66634aa06f3527f3808ad8ac
-  data.tar.gz: 15faafc27a3812f4ec9ddb9b76d56c79512737e2960b8f746e680bd88954484b1274ef79f735b45fa116edd831a18ea564962e489cdba2983b2923a421d81737
+  metadata.gz: 425a1e574b7a54826b2d2881a38d5efc190d14c46e7f5c85cd9b779c17182ad01a1427a746a1dce10780d4243bf575e9ac8e3a467497c41cd1a1e74ac8466be7
+  data.tar.gz: e819aacabb11e0c6174f167cd9fee3eaf2fdd882797631b0c383abbbf9c0bb69431c28cde2bfc024cd391d6c4e526fb8e5c1fa1862396d28d3d3fc889ae737f4

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,14 +432,19 @@ module GlueGun
           end
         end
 
-        dep_attributes
+        dep_attributes.deep_compact
       end
 
       def determine_option_name(init_args, instance)
         option_name = nil
 
-        # Use when block if defined
-        if when_block
+        user_specified_option = init_args.is_a?(Hash) && init_args.keys.size == 1
+        user_specified_valid_option = user_specified_option && option_configs.key?(init_args.keys.first)
+
+        if user_specified_valid_option
+          option_name = init_args.keys.first
+          init_args = init_args[option_name] # Extract the inner value
+        elsif when_block.present?
           result = instance.instance_exec(init_args, &when_block)
           if result.is_a?(Hash) && result[:option]
             option_name = result[:option]
@@ -448,24 +453,6 @@ module GlueGun
           end
         end
 
-        # Detect option from user input
-        if option_name.nil? && (init_args.is_a?(Hash) && init_args.keys.size == 1)
-          if option_configs.key?(init_args.keys.first)
-            option_name = init_args.keys.first
-            init_args = init_args[option_name] # Extract the inner value
-          else
-            default_option = get_option(default_option_name)
-            unless default_option.only?
-              raise ArgumentError,
-                    "Unknown #{component_type} option: #{init_args.keys.first}."
-            end
-            unless default_option.attributes.keys.include?(init_args.keys.first)
-              raise ArgumentError, "#{default_option.class_name} does not respond to #{init_args.keys.first}"
-            end
-          end
-        end
-
-        # Use default option if none determined
         option_name ||= default_option_name
 
         [option_name, init_args]

data/lib/glue_gun/model.rb

@@ -0,0 +1,196 @@
+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
+
+      def find_or_create_by!(attributes)
+        attributes = attributes.deep_symbolize_keys
+        db_attributes = extract_db_attributes(attributes)
+        attributes.except(*db_attributes.keys)
+
+        record = where(db_attributes).first_or_initialize(attributes)
+
+        record.save! if record.new_record?
+
+        record
+      end
+
+      def find_or_create_by(attributes)
+        attributes = attributes.deep_symbolize_keys
+        db_attributes = extract_db_attributes(attributes)
+        attributes.except(*db_attributes.keys)
+
+        record = where(db_attributes).first_or_initialize(attributes)
+
+        record.save if record.new_record?
+
+        record
+      end
+
+      def extract_db_attributes(attributes)
+        # Extract attributes that correspond to database columns or associations
+        column_names = self.column_names.map(&:to_sym)
+        association_names = reflect_on_all_associations.map(&:name)
+
+        attributes.slice(*(column_names + association_names))
+      end
+    end
+
+    def initialize(attributes = {})
+      attributes = attributes.deep_symbolize_keys
+      db_attributes = self.class.extract_db_attributes(attributes)
+      super(db_attributes)
+      self.class.send(:attr_reader, service_attribute_name)
+      build_service_object(attributes)
+    end
+
+    private
+
+    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 = serializable!(attrs.merge(deps.deep_compact).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_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)
+      service_instance = build_service_object(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 method_missing(method_name, *args, **kwargs, &block)
+      service_object = instance_variable_get("@#{service_attribute_name}")
+
+      if service_object && service_object.respond_to?(method_name)
+        service_object.send(method_name, *args, **kwargs, &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.22"
 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.22
 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