eac_rails_utils 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e4525483ddef206757144a407560d2b7569db1933b16935da157aef0e8645c4
-  data.tar.gz: 163bb84353cde0a519afaba18890920cf8f04920291f8e457d81431743e61bf4
+  metadata.gz: 424e322548e7f55ef6044d3c7e4339cd8336b272604d40678c7016b218b69494
+  data.tar.gz: 28dd2d2a83760c49bbb30e0210e2c4aa096be75a77f7edf720cff7700f2cce9c
 SHA512:
-  metadata.gz: 7313d2b4e45e6893a574df04e25ef627d0edea64820eda383a22ead2bd21243d377fb659ced3c58c84726f1f06d1c0904678510a6a60263e4aac88c45742d414
-  data.tar.gz: 8d5b6f1ab06c37696f0dd780e4017c519c41e1a2c717e9bbe3fa066824a30766fd84641546bdabe20978cb3adbba8808b06384bc3ec8ef3a4e93bf61c378f678
+  metadata.gz: c7ebba5d2e7736bcefdef37c3a015130047b12ff880b2862e871b3cbd7cd1e9c9ca5bde9ab7d51def8215d4c9049bfeb2cb1a9c2ed072011dd5402e850135d59
+  data.tar.gz: cc57e040cca6a24be309903034e74d7ff63394efd1090191f0c90b8620404ec2f31594fa4d166b40a872aa67481486c6093713722998cb77ad5d04e1298e6cea

data/lib/active_model/associations/active_record_reflection.rb

@@ -0,0 +1,38 @@
+module ActiveModel::Associations
+  module ActiveRecordReflection
+    extend ActiveSupport::Concern
+
+    included do
+      if ActiveRecord.version >= Gem::Version.new("4.1.2")
+        class_attribute :_reflections
+        self._reflections = ActiveSupport::HashWithIndifferentAccess.new
+      else
+        class_attribute :reflections
+        self.reflections = {}
+      end
+    end
+
+    module ClassMethods
+      if ActiveRecord.version < Gem::Version.new("4.1")
+        def create_reflection(macro, name, scope, options, active_record)
+          case macro
+          when :has_many, :belongs_to
+            klass =  ActiveRecord::Reflection::AssociationReflection
+            reflection = klass.new(macro, name, scope, options, active_record)
+          end
+
+          self.reflections = self.reflections.merge(name => reflection)
+          reflection
+        end
+      end
+
+      def reflect_on_association(association)
+        if ActiveRecord.version >= Gem::Version.new("4.1.2")
+          _reflections[association.to_s]
+        else
+          reflections[association]
+        end
+      end
+    end
+  end
+end

data/lib/active_model/associations/association_scope_extension.rb

@@ -0,0 +1,23 @@
+module ActiveModel::Associations
+  module AssociationScopeExtension
+    if ActiveRecord.version >= Gem::Version.new("5.0.0.beta")
+      def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
+        if refl.options[:active_model]
+          target_ids = refl.options[:target_ids]
+          return scope.where(id: owner[target_ids])
+        end
+
+        super
+      end
+    else
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        if refl.options[:active_model]
+          target_ids = refl.options[:target_ids]
+          return scope.where(id: owner[target_ids])
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/active_model/associations/autosave_association.rb

@@ -0,0 +1,12 @@
+module ActiveModel::Associations
+  module AutosaveAssociation
+    extend ActiveSupport::Concern
+
+    include ActiveRecord::AutosaveAssociation
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :save, :create, :update
+    end
+  end
+end

data/lib/active_model/associations/hooks.rb

@@ -0,0 +1,10 @@
+module ActiveModel::Associations
+  module Hooks
+    def self.init
+      ActiveSupport.on_load(:active_record) do
+        require 'active_model/associations/association_scope_extension'
+        ActiveRecord::Associations::AssociationScope.send(:prepend, ActiveModel::Associations::AssociationScopeExtension)
+      end
+    end
+  end
+end

data/lib/active_model/associations/initialize_extension.rb

@@ -0,0 +1,16 @@
+module ActiveModel::Associations
+  module InitializeExtension
+    extend ActiveSupport::Concern
+
+    included do
+      prepend WithAssociationCache
+    end
+
+    module WithAssociationCache
+      def initialize(*args)
+        @association_cache = {}
+        super
+      end
+    end
+  end
+end

data/lib/active_model/associations/override_methods.rb

@@ -0,0 +1,111 @@
+module ActiveModel::Associations
+  module OverrideMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def generated_association_methods
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+      alias :generated_feature_methods :generated_association_methods \
+        if ActiveRecord.version < Gem::Version.new("4.1")
+
+      # override
+      def dangerous_attribute_method?(name)
+        false
+      end
+
+      # dummy table name
+      def pluralize_table_names
+        self.to_s.pluralize
+      end
+
+      def clear_reflections_cache
+        @__reflections = nil
+      end
+
+      def default_scopes
+        []
+      end
+
+      protected
+
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+              # We don't want to swallow NoMethodError < NameError errors
+            rescue NoMethodError
+              raise
+            rescue NameError
+            end
+          end
+
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+        end
+      end
+    end
+
+    # use by association accessor
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        reflection  = self.class.reflect_on_association(name)
+        if reflection.options[:active_model]
+          association = ActiveRecord::Associations::HasManyForActiveModelAssociation.new(self, reflection)
+        else
+          association = reflection.association_class.new(self, reflection)
+        end
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def read_attribute(name)
+      send(name)
+    end
+    alias :_read_attribute :read_attribute
+
+    # dummy
+    def new_record?
+      false
+    end
+
+    private
+
+    # override
+    def validate_collection_association(reflection)
+      if association = association_instance_get(reflection.name)
+        if records = associated_records_to_validate_or_save(association, false, reflection.options[:autosave])
+          records.each { |record| association_valid?(reflection, record) }
+        end
+      end
+    end
+
+    # use in Rails internal
+    def association_instance_get(name)
+      @association_cache[name]
+    end
+
+    # use in Rails internal
+    def association_instance_set(name, association)
+      @association_cache[name] = association
+    end
+  end
+end

data/lib/active_model/associations/railtie.rb

@@ -0,0 +1,7 @@
+module ActiveModel::Associations
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'activemodel-associations' do |_|
+      ActiveModel::Associations::Hooks.init
+    end
+  end
+end

data/lib/active_model/associations/version.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  module Associations
+    VERSION = "0.2.0"
+  end
+end

data/lib/active_model/associations.rb

@@ -0,0 +1,52 @@
+require 'active_model/associations/initialize_extension'
+require 'active_model/associations/active_record_reflection'
+require 'active_model/associations/autosave_association'
+require 'active_model/associations/override_methods'
+require 'active_record/associations/builder/has_many_for_active_model'
+require 'active_record/associations/has_many_for_active_model_association'
+require 'active_support/core_ext/module'
+
+module ActiveModel
+  module Associations
+    extend ActiveSupport::Concern
+
+    include InitializeExtension
+    include AutosaveAssociation
+    include ActiveRecordReflection
+    include OverrideMethods
+
+    included do
+      mattr_accessor :belongs_to_required_by_default, instance_accessor: false
+    end
+
+    module ClassMethods
+      # define association like ActiveRecord
+      def belongs_to(name, scope = nil, options = {})
+        reflection = ActiveRecord::Associations::Builder::BelongsTo.build(self, name, scope, options)
+        ActiveRecord::Reflection.add_reflection self, name, reflection
+      end
+
+      # define association like ActiveRecord
+      def has_many(name, scope = nil, options = {}, &extension)
+        options.reverse_merge!(active_model: true, target_ids: "#{name.to_s.singularize}_ids")
+        if scope.is_a?(Hash)
+          options.merge!(scope)
+          scope = nil
+        end
+
+        reflection = ActiveRecord::Associations::Builder::HasManyForActiveModel.build(self, name, scope, options, &extension)
+        ActiveRecord::Reflection.add_reflection self, name, reflection
+
+        mixin = generated_association_methods
+        mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{options[:target_ids]}=(other_ids)
+            @#{options[:target_ids]} = other_ids
+            association(:#{name}).reset
+            association(:#{name}).reset_scope
+            @#{options[:target_ids]}
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/active_record/associations/builder/has_many_for_active_model.rb

@@ -0,0 +1,21 @@
+module ActiveRecord::Associations::Builder
+  class HasManyForActiveModel < HasMany
+    if ActiveRecord.version >= Gem::Version.new("5.0.0.beta")
+      AR_CALLBACK_METHODS = %i(define_callback before_validation after_validation before_save after_save before_update after_update)
+
+      def self.valid_options(_options)
+        super + [:active_model, :target_ids] - [:through, :dependent, :source, :source_type, :counter_cache, :as]
+      end
+
+      def self.define_callbacks(model, reflection)
+        if AR_CALLBACK_METHODS.all? { |meth| self.respond_to?(meth) }
+          super
+        end
+      end
+    else
+      def valid_options
+        super + [:active_model, :target_ids] - [:through, :dependent, :source, :source_type, :counter_cache, :as]
+      end
+    end
+  end
+end

data/lib/active_record/associations/has_many_for_active_model_association.rb

@@ -0,0 +1,72 @@
+module ActiveRecord::Associations
+  class HasManyForActiveModelAssociation < HasManyAssociation
+    # remove conditions: owner.new_record?, foreign_key_present? 
+    def find_target?
+      !loaded? && klass
+    end
+
+    # no dependent action
+    def null_scope?
+      false
+    end
+
+    # not support counter_cache
+    def empty?
+      if loaded?
+        size.zero?
+      else
+        @target.blank? && !scope.exists?
+      end
+    end
+
+    # full replace simplely
+    def replace(other_array)
+      original_target = load_target.dup
+      other_array.each { |val| raise_on_type_mismatch!(val) }
+      target_ids = reflection.options[:target_ids]
+      owner[target_ids] = other_array.map(&:id)
+
+      old_records = original_target - other_array
+      old_records.each do |record|
+        @target.delete(record)
+      end
+
+      other_array.each do |record|
+        if index = @target.index(record)
+          @target[index] = record
+        else
+          @target << record
+        end
+      end
+    end
+
+    # no need transaction
+    def concat(*records)
+      load_target
+      flatten_records = records.flatten
+      flatten_records.each { |val| raise_on_type_mismatch!(val) }
+      target_ids = reflection.options[:target_ids]
+      owner[target_ids] ||= []
+      owner[target_ids].concat(flatten_records.map(&:id))
+
+      flatten_records.each do |record|
+        if index = @target.index(record)
+          @target[index] = record
+        else
+          @target << record
+        end
+      end
+
+      target
+    end
+
+    private
+
+    def get_records
+      return scope.to_a if reflection.scope_chain.any?(&:any?)
+
+      target_ids = reflection.options[:target_ids]
+      klass.where(id: owner[target_ids]).to_a
+    end
+  end
+end

data/lib/activemodel/associations.rb

@@ -0,0 +1,15 @@
+require "active_model"
+require "active_record"
+require "active_support"
+require "active_model/associations"
+require "active_model/associations/hooks"
+
+# Load Railtie
+begin
+  require "rails"
+rescue LoadError
+end
+
+if defined?(Rails)
+  require "active_model/associations/railtie"
+end

data/lib/eac_rails_utils/models/tableless/attributes.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRailsUtils
+  module Models
+    class Tableless
+      module Attributes
+        common_concern
+
+        def attributes=(values)
+          super(build_attributes(values))
+        end
+
+        # need hash like accessor, used internal Rails
+        def [](attr)
+          send(attr)
+        end
+
+        # need hash like accessor, used internal Rails
+        def []=(attr, value)
+          send("#{attr}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/eac_rails_utils/models/tableless/build_attributes.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    class Tableless
+      class BuildAttributes
+        acts_as_instance_method
+        DATE_TIME_FIELDS = %i[year month day hour min sec].freeze
+
+        def initialize(model_class, values)
+          @model_class = model_class
+          @values = {}
+          values.each { |k, v| add(k, v) }
+        end
+
+        def result
+          @values
+        end
+
+        private
+
+        def add(key, value)
+          array_attr = parse_array_attr_key(key)
+          if array_attr
+            array_value_set(array_attr, value)
+          else
+            @values[key] = value
+          end
+        end
+
+        def parse_array_attr_key(key)
+          m = /\A(.+)\(([0-9]+)(.)\)\z/.match(key)
+          return unless m
+
+          ::OpenStruct.new(key: m[1], index: m[2].to_i - 1, converter: array_value_converter(m[3]))
+        end
+
+        def array_value_set(array_attr, value)
+          @values[array_attr.key] ||= {}
+          @values[array_attr.key].merge!(
+            DATE_TIME_FIELDS[array_attr.index] => value.send(array_attr.converter)
+          )
+        end
+
+        def array_value_converter(str_type)
+          case str_type
+          when 'i'
+            'to_i'
+          else
+            raise "Unknown array type: \"#{str_type}\""
+          end
+        end
+
+        def date_time_attribute?(key)
+          attr = @model_class.attributes[key]
+          return false unless attr
+
+          raise attr.to_s
+        end
+      end
+    end
+  end
+end

data/lib/eac_rails_utils/models/tableless/columns.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRailsUtils
+  module Models
+    class Tableless
+      module Columns
+        common_concern
+
+        class_methods do
+          def columns
+            attribute_set.each.to_a
+          end
+
+          def columns_names
+            columns.map(&:name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eac_rails_utils/models/tableless.rb

@@ -10,98 +10,15 @@ module EacRailsUtils
       include Virtus.model
       include ActiveModel::Associations
 
-      class << self
-        def columns
-          attribute_set.each.to_a
-        end
-
-        def columns_names
-          columns.map(&:name)
-        end
-      end
-
       def initialize(values = {})
         super(build_attributes(values))
       end
 
-      def attributes=(values)
-        super(build_attributes(values))
-      end
-
-      # need hash like accessor, used internal Rails
-      def [](attr)
-        send(attr)
-      end
-
-      # need hash like accessor, used internal Rails
-      def []=(attr, value)
-        send("#{attr}=", value)
-      end
-
       def save!
         save || raise("#{self.class}.save failed: #{errors.messages}")
       end
 
-      private
-
-      def build_attributes(values)
-        AttributesBuilder.new(self.class, values).to_attributes
-      end
-
-      class AttributesBuilder
-        DATE_TIME_FIELDS = %i[year month day hour min sec].freeze
-
-        def initialize(model_class, values)
-          @model_class = model_class
-          @values = {}
-          values.each { |k, v| add(k, v) }
-        end
-
-        def to_attributes
-          @values
-        end
-
-        private
-
-        def add(key, value)
-          array_attr = parse_array_attr_key(key)
-          if array_attr
-            array_value_set(array_attr, value)
-          else
-            @values[key] = value
-          end
-        end
-
-        def parse_array_attr_key(key)
-          m = /\A(.+)\(([0-9]+)(.)\)\z/.match(key)
-          return unless m
-
-          ::OpenStruct.new(key: m[1], index: m[2].to_i - 1, converter: array_value_converter(m[3]))
-        end
-
-        def array_value_set(array_attr, value)
-          @values[array_attr.key] ||= {}
-          @values[array_attr.key].merge!(
-            DATE_TIME_FIELDS[array_attr.index] => value.send(array_attr.converter)
-          )
-        end
-
-        def array_value_converter(str_type)
-          case str_type
-          when 'i'
-            'to_i'
-          else
-            raise "Unknown array type: \"#{str_type}\""
-          end
-        end
-
-        def date_time_attribute?(key)
-          attr = @model_class.attributes[key]
-          return false unless attr
-
-          raise attr.to_s
-        end
-      end
+      require_sub __FILE__, require_mode: :kernel, include_modules: :include
     end
   end
 end

data/lib/eac_rails_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRailsUtils
-  VERSION = '0.19.0'
+  VERSION = '0.20.0'
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: eac_rails_utils
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - E.A.C.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-11 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activemodel-associations
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bootstrap-sass
   requirement: !ruby/object:Gem::Requirement
@@ -50,20 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.117'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.117.1
+        version: '0.118'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.117'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.117.1
+        version: '0.118'
 - !ruby/object:Gem::Dependency
   name: htmlbeautifier
   requirement: !ruby/object:Gem::Requirement
@@ -212,6 +220,18 @@ files:
 - config/initializers/json.rb
 - config/locales/en.yml
 - config/locales/pt-BR.yml
+- lib/active_model/associations.rb
+- lib/active_model/associations/active_record_reflection.rb
+- lib/active_model/associations/association_scope_extension.rb
+- lib/active_model/associations/autosave_association.rb
+- lib/active_model/associations/hooks.rb
+- lib/active_model/associations/initialize_extension.rb
+- lib/active_model/associations/override_methods.rb
+- lib/active_model/associations/railtie.rb
+- lib/active_model/associations/version.rb
+- lib/active_record/associations/builder/has_many_for_active_model.rb
+- lib/active_record/associations/has_many_for_active_model_association.rb
+- lib/activemodel/associations.rb
 - lib/eac_rails_utils.rb
 - lib/eac_rails_utils/engine.rb
 - lib/eac_rails_utils/engine_helper.rb
@@ -220,6 +240,9 @@ files:
 - lib/eac_rails_utils/models/fetch_errors.rb
 - lib/eac_rails_utils/models/inequality_queries.rb
 - lib/eac_rails_utils/models/tableless.rb
+- lib/eac_rails_utils/models/tableless/attributes.rb
+- lib/eac_rails_utils/models/tableless/build_attributes.rb
+- lib/eac_rails_utils/models/tableless/columns.rb
 - lib/eac_rails_utils/models/test_utils.rb
 - lib/eac_rails_utils/models/validations.rb
 - lib/eac_rails_utils/patches.rb