eac_rails_utils 0.18.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e69ab406dd1dd999da6a2fdefa92e15ad6c1a2faeb14f0474fa7fd20938a71ef
-  data.tar.gz: f91fdd425c80747f432acbcdd4ed80c399eed2e80f3d1e862699dbb0839d9077
+  metadata.gz: 424e322548e7f55ef6044d3c7e4339cd8336b272604d40678c7016b218b69494
+  data.tar.gz: 28dd2d2a83760c49bbb30e0210e2c4aa096be75a77f7edf720cff7700f2cce9c
 SHA512:
-  metadata.gz: 0f772b792fb6684dfff2e450286e5f014d04e4b9c45630a8cc7d3486c9a70cb895381ba4480e973a4b2cdc4cde5a29bfa94392c8e2efc9e141a08e2ce0e126d4
-  data.tar.gz: 2a5cc246cb003b694e2701bb70409cc7df7e2e69fc80d093a47912dbed5d50c2e1cdab740e4e9d36f29469cc84fd8bc83a50fd15f66cbda35b4ecd328093139a
+  metadata.gz: c7ebba5d2e7736bcefdef37c3a015130047b12ff880b2862e871b3cbd7cd1e9c9ca5bde9ab7d51def8215d4c9049bfeb2cb1a9c2ed072011dd5402e850135d59
+  data.tar.gz: cc57e040cca6a24be309903034e74d7ff63394efd1090191f0c90b8620404ec2f31594fa4d166b40a872aa67481486c6093713722998cb77ad5d04e1298e6cea

data/app/helpers/eac_rails_utils/data_table_helper/column.rb

@@ -1,48 +1,51 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/core_ext'
+
 module EacRailsUtils
   module DataTableHelper
     class Column
       EMPTY_VALUE = '-'
 
-      attr_reader :label
+      common_constructor :args, :block
+
+      # @return [String]
+      def label
+        args[0]
+      end
 
-      def initialize(label, path, block)
-        @label = label
-        @path = path.to_s.split('.')
-        @block = block
+      # @return [String]
+      def path
+        args[1].to_s.split('.')
       end
 
       def record_value(record)
-        v = Node.new(record, @path).value
+        v = ::EacRailsUtils::DataTableHelper::ColumnNode.new(record, path).value
         if v.present?
-          @block ? @block.call(v) : v
+          block ? block.call(v) : v
         else
           EMPTY_VALUE
         end
       end
 
-      private
+      # @param attribute [Symbol]
+      # @param value [Proc, Object]
+      # @return [self]
+      def value_cell(attribute, value = nil, &block)
+        value_cell_attributes[attribute.to_sym] = block.if_present(value)
 
-      def node_value(node, subpath)
-        return node if subpath.empty?
+        self
       end
 
-      class Node
-        def initialize(node, path)
-          @node = node
-          @path = path
-        end
-
-        def value
-          return @node if @node.nil? || @path.empty?
+      # @return [Hash]
+      def value_cell_attributes
+        @value_cell_attributes ||= {}
+      end
 
-          subpath = @path.dup
-          n = subpath.shift
-          return Node.new(@node.send(n), subpath).value if @node.respond_to?(n)
+      private
 
-          raise "Instance of #{@node.class} does not respond to #{n}"
-        end
+      def node_value(node, subpath)
+        return node if subpath.empty?
       end
     end
   end

data/app/helpers/eac_rails_utils/data_table_helper/column_node.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRailsUtils
+  module DataTableHelper
+    class ColumnNode
+      common_constructor :node, :path
+
+      # @return [Boolean]
+      def ended?
+        node.nil? || path.empty?
+      end
+
+      # @return [Object]
+      def value
+        ended? ? node : child_value
+      end
+
+      private
+
+      # @return [Object]
+      def child_value
+        subpath = path.dup
+        n = subpath.shift
+        return self.class.new(node.send(n), subpath).value if node.respond_to?(n)
+
+        raise "Instance of #{node.class} does not respond to #{n}"
+      end
+    end
+  end
+end

data/app/helpers/eac_rails_utils/data_table_helper/data_table/value_cell.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRailsUtils
+  module DataTableHelper
+    class DataTable
+      class ValueCell
+        enable_method_class
+        common_constructor :data_table, :column, :record
+        delegate :view, to: :data_table
+
+        # @return [ActiveSupport::SafeBuffer]
+        def result
+          view.content_tag('td', column.record_value(record), tag_attributes)
+        end
+
+        # @return [Object]
+        def tag_attribute_value(value)
+          value.is_a?(::Proc) ? value.call(record) : value
+        end
+
+        # @return [Hash]
+        def tag_attributes
+          column.value_cell_attributes.map { |k, v| [k, tag_attribute_value(v)] }.to_h
+        end
+      end
+    end
+  end
+end

data/app/helpers/eac_rails_utils/data_table_helper/data_table.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/core_ext'
+
 module EacRailsUtils
   module DataTableHelper
     class DataTable
-      def initialize(view, dataset)
-        @view = view
-        @dataset = dataset
-        @setup = ::EacRailsUtils::DataTableHelper::Setup.new
-        yield(@setup)
-      end
+      common_constructor :view, :dataset, :setup_block, block_arg: true
 
       def output
-        @view.content_tag(:table, id: id) do
+        view.content_tag(:table, id: id) do
           head << body
         end << script
       end
@@ -19,29 +16,29 @@ module EacRailsUtils
       private
 
       def head
-        @view.content_tag(:thead) do
-          @view.content_tag(:tr) do
-            @view.safe_join(@setup.columns.map { |c| @view.content_tag('th', c.label) })
+        view.content_tag(:thead) do
+          view.content_tag(:tr) do
+            view.safe_join(setup.columns.map { |c| view.content_tag('th', c.label) })
           end
         end
       end
 
       def body
-        @view.content_tag(:tbody) do
-          @view.safe_join(@dataset.map { |r| row(r) })
+        view.content_tag(:tbody) do
+          view.safe_join(dataset.map { |r| row(r) })
         end
       end
 
       def row(record)
-        @view.content_tag(:tr) do
-          @view.safe_join(
-            @setup.columns.map { |c| @view.content_tag('td', c.record_value(record)) << "\n" }
+        view.content_tag(:tr) do
+          view.safe_join(
+            setup.columns.map { |c| value_cell(c, record) << "\n" }
           )
         end << "\n"
       end
 
       def script
-        @view.javascript_tag <<~JS_CODE
+        view.javascript_tag <<~JS_CODE
           $(document).ready(function () {
             $('##{id}').DataTable({
               paging: #{@setup.paging ? 'true' : 'false'}
@@ -53,6 +50,17 @@ module EacRailsUtils
       def id
         @id ||= SecureRandom.hex(32)
       end
+
+      # @return [EacRailsUtils::DataTableHelper::Setup]
+      def setup
+        @setup ||= begin
+          r = ::EacRailsUtils::DataTableHelper::Setup.new
+          setup_block.call(r)
+          r
+        end
+      end
+
+      require_sub __FILE__, require_mode: :kernel
     end
   end
 end

data/app/helpers/eac_rails_utils/data_table_helper/setup.rb

@@ -11,8 +11,11 @@ module EacRailsUtils
         @paging = true
       end
 
-      def column(label, path = nil, &block)
-        @columns << ::EacRailsUtils::DataTableHelper::Column.new(label, path, block)
+      # @return [EacRailsUtils::DataTableHelper::Column]
+      def column(*args, &block)
+        column = ::EacRailsUtils::DataTableHelper::Column.new(args, block)
+        @columns << column
+        column
       end
     end
   end

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.18.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.18.0
+  version: 0.20.0
 platform: ruby
 authors:
 - E.A.C.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-30 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
@@ -193,7 +201,9 @@ files:
 - app/helpers/eac_rails_utils/common_form_helper/form_builder/year_month_field.rb
 - app/helpers/eac_rails_utils/data_table_helper.rb
 - app/helpers/eac_rails_utils/data_table_helper/column.rb
+- app/helpers/eac_rails_utils/data_table_helper/column_node.rb
 - app/helpers/eac_rails_utils/data_table_helper/data_table.rb
+- app/helpers/eac_rails_utils/data_table_helper/data_table/value_cell.rb
 - app/helpers/eac_rails_utils/data_table_helper/setup.rb
 - app/helpers/eac_rails_utils/formatter_helper.rb
 - app/helpers/eac_rails_utils/links_helper.rb
@@ -210,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
@@ -218,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