eac_rails_utils 0.22.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d70491a91afe401a5ff75d1ecf1d1820e9164bb725d33ecbf5a233508e70faa
-  data.tar.gz: 59c3693a4563491e0da78bf4496d620c75025b7b70fb4cda760405ac04c3f436
+  metadata.gz: 8a88b255d31abb1059b16e75e33cb24b9ba2ad64a3d35afd63e27bc1d01dbbbe
+  data.tar.gz: b50b1587013cb361fe0eb2d7d56ee46dd5bdd87ed6aacf836aee7867ec7c152e
 SHA512:
-  metadata.gz: ed28ed741a6dc380f97f1b3a1af9afaba32baebeee1c06ccf81790eab178ac8eadf022051a3dd5dffd98c01bf421fc749ce69d4db8b4a078c8d347795a286949
-  data.tar.gz: d5b26dc72e4a8d36e9b609b606a95264432c81e612a08fa705c40da2db94fe3e6ba23108121f170dcd1f395cea969133c6799ab15ccb6520e0f3a8a22e2ed025
+  metadata.gz: 1249f9ba2a9598117e86de27b315fdd2f6f0f55330ee39916ea9e03f25c97b9c966a99a476628a1dfda677ea14b518cdf7478ad21eafc41868b4bcf4222fe65e
+  data.tar.gz: a7def8aa5c32a906ecae3e29b5c42ba669f962c368ad3ae01153de142ce74cc3f3da22f9090cc4d9d97fa359080ed414985be9879b8d3f42ec476e7b6f0dcae9

data/lib/eac_rails_utils/models/tableless_associations/active_record_reflection.rb

@@ -1,36 +1,42 @@
-module EacRailsUtils::Models::TablelessAssociations
-  module ActiveRecordReflection
-    extend ActiveSupport::Concern
+# frozen_string_literal: true
 
-    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 EacRailsUtils
+  module Models
+    module TablelessAssociations
+      module ActiveRecordReflection
+        extend ActiveSupport::Concern
 
-    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)
+        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
-
-          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]
+        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 = 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/eac_rails_utils/models/tableless_associations/association_scope_extension.rb

@@ -1,22 +1,28 @@
-module EacRailsUtils::Models::TablelessAssociations
-  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
+# frozen_string_literal: true
 
-        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
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      module AssociationScopeExtension
+        if ActiveRecord.version >= Gem::Version.new('5.0.0.beta')
+          def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail) # rubocop:disable Metrics/ParameterLists
+            if refl.options[:active_model]
+              target_ids = refl.options[:target_ids]
+              return scope.where(id: owner[target_ids])
+            end
 
-        super
+            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
   end

data/lib/eac_rails_utils/models/tableless_associations/autosave_association.rb

@@ -1,12 +1,18 @@
-module EacRailsUtils::Models::TablelessAssociations
-  module AutosaveAssociation
-    extend ActiveSupport::Concern
+# frozen_string_literal: true
 
-    include ActiveRecord::AutosaveAssociation
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      module AutosaveAssociation
+        extend ActiveSupport::Concern
 
-    included do
-      extend ActiveModel::Callbacks
-      define_model_callbacks :save, :create, :update
+        include ActiveRecord::AutosaveAssociation
+
+        included do
+          extend ActiveModel::Callbacks
+          define_model_callbacks :save, :create, :update
+        end
+      end
     end
   end
 end

data/lib/eac_rails_utils/models/tableless_associations/hooks.rb

@@ -1,9 +1,17 @@
-module EacRailsUtils::Models::TablelessAssociations
-  module Hooks
-    def self.init
-      ActiveSupport.on_load(:active_record) do
-        require 'eac_rails_utils/models/tableless_associations/association_scope_extension'
-        ActiveRecord::Associations::AssociationScope.send(:prepend, EacRailsUtils::Models::TablelessAssociations::AssociationScopeExtension)
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      module Hooks
+        def self.init
+          ActiveSupport.on_load(:active_record) do
+            require 'eac_rails_utils/models/tableless_associations/association_scope_extension'
+            ActiveRecord::Associations::AssociationScope.prepend(
+              EacRailsUtils::Models::TablelessAssociations::AssociationScopeExtension
+            )
+          end
+        end
       end
     end
   end

data/lib/eac_rails_utils/models/tableless_associations/initialize_extension.rb

@@ -1,15 +1,21 @@
-module EacRailsUtils::Models::TablelessAssociations
-  module InitializeExtension
-    extend ActiveSupport::Concern
+# frozen_string_literal: true
 
-    included do
-      prepend WithAssociationCache
-    end
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      module InitializeExtension
+        extend ActiveSupport::Concern
+
+        included do
+          prepend WithAssociationCache
+        end
 
-    module WithAssociationCache
-      def initialize(*args)
-        @association_cache = {}
-        super
+        module WithAssociationCache
+          def initialize(*args)
+            @association_cache = {}
+            super
+          end
+        end
       end
     end
   end

data/lib/eac_rails_utils/models/tableless_associations/override_methods.rb

@@ -1,111 +1,128 @@
-module EacRailsUtils::Models::TablelessAssociations
-  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")
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      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
+          # override
+          def dangerous_attribute_method?(_name)
+            false
+          end
 
-      # dummy table name
-      def pluralize_table_names
-        self.to_s.pluralize
-      end
+          # dummy table name
+          def pluralize_table_names
+            to_s.pluralize
+          end
 
-      def clear_reflections_cache
-        @__reflections = nil
-      end
+          def clear_reflections_cache
+            @__reflections = nil
+          end
 
-      def default_scopes
-        []
-      end
+          def default_scopes
+            []
+          end
+
+          protected
 
-      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
+              compute_type_from_candidates(type_name)
+            end
+          end
 
-      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
+          def compute_type_candidates(type_name)
+            candidates = []
+            name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+            candidates << type_name
+          end
 
-          candidates.each do |candidate|
-            begin
+          def compute_type_from_candidates(type_name)
+            compute_type_candidates(type_name).each do |candidate|
               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
+            rescue NameError # rubocop:disable Lint/SuppressedException
             end
-          end
 
-          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+            raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+          end
         end
-      end
-    end
 
-    # use by association accessor
-    def association(name) #:nodoc:
-      association = association_instance_get(name)
+        # use by association accessor
+        def association(name) #:nodoc:
+          association = association_instance_get(name)
+
+          if association.nil?
+            association = association_by_reflection(name)
+            association_instance_set(name, association)
+          end
 
-      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)
+          association
         end
-        association_instance_set(name, association)
-      end
 
-      association
-    end
+        def read_attribute(name)
+          send(name)
+        end
+        alias _read_attribute read_attribute
 
-    def read_attribute(name)
-      send(name)
-    end
-    alias :_read_attribute :read_attribute
+        # dummy
+        def new_record?
+          false
+        end
 
-    # dummy
-    def new_record?
-      false
-    end
+        private
 
-    private
+        def association_by_reflection(name)
+          reflection = self.class.reflect_on_association(name)
+          if reflection.options[:active_model]
+            ::ActiveRecord::Associations::HasManyForActiveModelAssociation.new(self, reflection)
+          else
+            reflection.association_class.new(self, reflection)
+          end
+        end
+
+        # override
+        def validate_collection_association(reflection)
+          return unless (association = association_instance_get(reflection.name))
 
-    # 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) }
+          if (records = associated_records_to_validate_or_save(
+            association,
+            false, reflection.options[:autosave]
+          ))
+            records.each { |record| association_valid?(reflection, record) }
+          end
         end
-      end
-    end
 
-    # use in Rails internal
-    def association_instance_get(name)
-      @association_cache[name]
-    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
+        # use in Rails internal
+        def association_instance_set(name, association)
+          @association_cache[name] = association
+        end
+      end
     end
   end
 end

data/lib/eac_rails_utils/models/tableless_associations/railtie.rb

@@ -1,7 +1,13 @@
-module EacRailsUtils::Models::TablelessAssociations
-  class Railtie < ::Rails::Railtie #:nodoc:
-    initializer 'activemodel-associations' do |_|
-      EacRailsUtils::Models::TablelessAssociations::Hooks.init
+# frozen_string_literal: true
+
+module EacRailsUtils
+  module Models
+    module TablelessAssociations
+      class Railtie < ::Rails::Railtie #:nodoc:
+        initializer 'activemodel-associations' do |_|
+          EacRailsUtils::Models::TablelessAssociations::Hooks.init
+        end
+      end
     end
   end
 end

data/lib/eac_rails_utils/models/tableless_associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'eac_rails_utils/models/tableless_associations/initialize_extension'
 require 'eac_rails_utils/models/tableless_associations/active_record_reflection'
 require 'eac_rails_utils/models/tableless_associations/autosave_association'
@@ -23,19 +25,21 @@ module EacRailsUtils
       module ClassMethods
         # define association like ActiveRecord
         def belongs_to(name, scope = nil, options = {})
-          reflection = ActiveRecord::Associations::Builder::BelongsTo.build(self, name, scope, 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)
+        def has_many(name, scope = nil, options = {}, &extension) # rubocop:disable Naming/PredicateName
           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)
+          reflection = ActiveRecord::Associations::Builder::HasManyForActiveModel
+                       .build(self, name, scope, options, &extension)
           ActiveRecord::Reflection.add_reflection self, name, reflection
 
           mixin = generated_association_methods

data/lib/eac_rails_utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eac_rails_utils
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.22.1
 platform: ruby
 authors:
 - E.A.C.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-18 00:00:00.000000000 Z
+date: 2023-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bootstrap-sass
@@ -225,7 +225,6 @@ files:
 - lib/eac_rails_utils/models/tableless_associations/initialize_extension.rb
 - lib/eac_rails_utils/models/tableless_associations/override_methods.rb
 - lib/eac_rails_utils/models/tableless_associations/railtie.rb
-- lib/eac_rails_utils/models/tableless_associations/version.rb
 - lib/eac_rails_utils/models/test_utils.rb
 - lib/eac_rails_utils/models/validations.rb
 - lib/eac_rails_utils/patches.rb

data/lib/eac_rails_utils/models/tableless_associations/version.rb

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