acts_as_table 0.0.1

data/app/models/concerns/acts_as_table/value_provider.rb

@@ -0,0 +1,223 @@
+module ActsAsTable
+  # ActsAsTable value provider (concern).
+  #
+  # @note The minimum implementation is the protected `_get_value` and `_set_value` instance methods.
+  module ValueProvider
+    extend ::ActiveSupport::Concern
+
+    class_methods do
+      # Returns `true` if the class is an ActsAsTable value provider. Otherwise, returns `false`.
+      #
+      # @return [Boolean]
+      def acts_as_table_value_provider?
+        false
+      end
+
+      # Mark the class as an ActsAsTable value provider.
+      #
+      # @return [void]
+      def acts_as_table_value_provider
+        unless self.acts_as_table_value_provider?
+          self.class_eval do
+            def self.acts_as_table_value_provider?
+              true
+            end
+          end
+
+          self.include(InstanceMethods)
+        end
+
+        return
+      end
+    end
+
+    # ActsAsTable wrapped value object.
+    #
+    # @!attribute [r] value_provider
+    #   Returns the ActsAsTable value provider for this ActsAsTable wrapped value object.
+    #
+    #   @return [ActsAsTable::ValueProvider::InstanceMethods]
+    # @!attribute [r] base
+    #   Returns the record for this ActsAsTable wrapped value object.
+    #
+    #   @return [ActiveRecord::Base, nil]
+    # @!attribute [r] source_value
+    #   Returns the source value of this ActsAsTable wrapped value object.
+    #
+    #   @return [Object, nil]
+    # @!attribute [r] target_value
+    #   Returns the target value of this ActsAsTable wrapped value object.
+    #
+    #   @return [Object, nil]
+    # @!attribute [r] options
+    #   Returns the options for this ActsAsTable wrapped value object.
+    #
+    #   @return [Hash<Symbol, Object>]
+    class WrappedValue
+      attr_reader :value_provider, :base, :source_value, :target_value, :options
+
+      # Returns a new ActsAsTable wrapped value object.
+      #
+      # @param [ActsAsTable::ValueProvider::InstanceMethods] value_provider
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Object, nil] source_value
+      # @param [Object, nil] target_value
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :changed
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      def initialize(value_provider, base = nil, source_value = nil, target_value = nil, **options)
+        options.assert_valid_keys(:changed, :default)
+
+        @value_provider, @base, @source_value, @target_value, @options = value_provider, base, source_value, target_value, options.dup
+      end
+
+      # Sets the ':changed' option for this ActsAsTable wrapped value object to 'true'.
+      #
+      # @return [Boolean]
+      def changed!
+        @options[:changed] = true
+      end
+
+      # Returns 'true' if the value of this ActsAsTable wrapped value object has changed. Otherwise, returns 'false'.
+      #
+      # @return [Boolean]
+      def changed?
+        !!@options[:changed]
+      end
+      alias_method :changed, :changed?
+
+      # Returns 'true' if the value of this ActsAsTable wrapped value object is the default value for the value provider. Otherwise, returns 'false'.
+      #
+      # @return [Boolean]
+      def default?
+        !!@options[:default]
+      end
+      alias_method :default, :default?
+    end
+
+    # ActsAsTable value provider instance methods (concern).
+    #
+    # @note The design of this module is inspired by the the Haskell package, [lens](https://hackage.haskell.org/package/lens).
+    module InstanceMethods
+      extend ::ActiveSupport::Concern
+
+      # Reads the value for the given record using the given options.
+      #
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      def get_value(base = nil, **options)
+        options.assert_valid_keys(:default)
+
+        if base.nil?
+          return ActsAsTable.adapter.wrap_value_for(self, base, nil, nil)
+        end
+
+        # @return [Object, nil]
+        source_value = _get_value(base)
+
+        # @return [Object, nil]
+        target_value = _modify_get_value_before_default(source_value)
+
+        default = \
+          if options[:default].try { |boolean_or_proc| _should_default?(target_value, boolean_or_proc) } && self.respond_to?(:default_value)
+            target_value = self.default_value
+
+            true
+          else
+            false
+          end
+
+        ActsAsTable.adapter.wrap_value_for(self, base, source_value, target_value, default: default)
+      end
+
+      # Writes the new value for the given record using the given options.
+      #
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Object, nil] new_value
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      def set_value(base = nil, new_value = nil, **options)
+        options.assert_valid_keys(:default)
+
+        if base.nil?
+          return ActsAsTable.adapter.wrap_value_for(self, base, nil, nil)
+        end
+
+        # @return [Object, nil]
+        target_value = _modify_set_value_before_default(new_value)
+
+        changed = false
+
+        default = \
+          if options[:default].try { |boolean_or_proc| _should_default?(target_value, boolean_or_proc) } && self.respond_to?(:default_value)
+            target_value = self.default_value
+
+            true
+          else
+            false
+          end
+
+        target_value, changed = *_set_value(base, target_value)
+
+        ActsAsTable.adapter.wrap_value_for(self, base, new_value, target_value, changed: changed, default: default)
+      end
+
+      protected
+
+      # @param [ActiveRecord::Base, nil] base
+      # @return [Object, nil]
+      def _get_value(base = nil)
+        nil
+      end
+
+      # @param [Object, nil] new_value
+      # @return [Object, nil]
+      def _modify_get_value_before_default(new_value = nil)
+        new_value
+      end
+
+      # @param [Object, nil] new_value
+      # @return [Object, nil]
+      def _modify_set_value_before_default(new_value = nil)
+        new_value
+      end
+
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Object, nil] new_value
+      # @return [Array<Object>]
+      def _set_value(base = nil, new_value = nil)
+        # @return [Object, nil]
+        orig_value = _get_value(base)
+
+        [
+          orig_value,
+          false,
+        ]
+      end
+
+      private
+
+      # @param [Object, nil] new_value
+      # @param [#call, nil] default
+      # @return [Boolean]
+      def _should_default?(new_value = nil, default = nil)
+        if default.respond_to?(:call)
+          if default.respond_to?(:arity)
+            case default.arity
+              when 1 then default.call(new_value)
+              else new_value.instance_exec(&default)
+            end
+          else
+            default.call(new_value)
+          end
+        else
+          new_value.nil?
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/acts_as_table/value_provider_association_methods.rb

@@ -0,0 +1,57 @@
+module ActsAsTable
+  # ActsAsTable value provider association methods (concern).
+  module ValueProviderAssociationMethods
+    extend ::ActiveSupport::Concern
+
+    class_methods do
+      # Returns an array of {ActiveRecord::Reflection::MacroReflection} objects for all ActsAsTable value provider associations in the class.
+      #
+      # @note If you only want to reflect on a certain association type, pass in the symbol (`:has_many`, `:has_one`, `:belongs_to`) as the first parameter.
+      #
+      # @param [Symbol, nil] macro
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Array<Symbol>, nil] :only
+      # @option options [Array<Symbol>, nil] :except
+      # @return [Array<ActiveRecord::Reflection::MacroReflection>]
+      def reflect_on_acts_as_table_value_provider_associations(macro = nil, **options)
+        options.assert_valid_keys(:except, :only)
+
+        self.reflect_on_all_associations(macro).select { |reflection|
+          reflection.klass.acts_as_table_value_provider?
+        }.select { |reflection|
+          (options[:except].nil? || !options[:except].collect(&:to_sym).include?(reflection.name)) && (options[:only].nil? || options[:only].collect(&:to_sym).include?(reflection.name))
+        }
+      end
+    end
+
+    # Enumerates all associated records for all ActsAsTable value provider associations in the class.
+    #
+    # @note If you only want to reflect on a certain association type, pass in the symbol (`:has_many`, `:has_one`, `:belongs_to`) as the first parameter.
+    #
+    # @param [Symbol, nil] macro
+    # @param [Hash<Symbol, Object>] options
+    # @option options [Array<Symbol>, nil] :only
+    # @option options [Array<Symbol>, nil] :except
+    # @return [Enumerable<ActsAsTable::ValueProvider::InstanceMethods>]
+    def each_acts_as_table_value_provider(macro = nil, **options, &block)
+      ::Enumerator.new { |enumerator|
+        {
+          belongs_to: [],
+          has_one: [],
+          has_many: [:each],
+          has_and_belongs_to_many: [:each],
+        }.each do |method_name, args|
+          if macro.nil? || (macro == method_name)
+            reflections = self.class.reflect_on_acts_as_table_value_provider_associations(method_name, **options)
+
+            reflections.each do |reflection|
+              self.send(reflection.name).try(*args) { |value_provider|
+                enumerator << value_provider
+              }
+            end
+          end
+        end
+      }.each(&block)
+    end
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  activerecord:
+    errors:
+      models:
+        acts_as_table/record_model:
+          attributes:
+            base:
+              unreachable: "is unreachable"

data/db/migrate/1_acts_as_table_migration.rb

@@ -0,0 +1,186 @@
+if ::ActiveRecord.gem_version >= ::Gem::Version.new('5.0')
+  class ActsAsTableMigration < ::ActiveRecord::Migration[4.2]; end
+else
+  class ActsAsTableMigration < ::ActiveRecord::Migration; end
+end
+
+ActsAsTableMigration.class_eval do
+  def self.up
+    create_table ActsAsTable.row_models_table do |t|
+      t.integer :root_record_model_id, index: true, null: false
+
+      t.string :name, null: false
+
+      t.timestamps null: false
+    end
+    add_foreign_key ActsAsTable.row_models_table, ActsAsTable.record_models_table, column: 'root_record_model_id'
+
+    create_table ActsAsTable.column_models_table do |t|
+      t.references :row_model, index: true, foreign_key: { to_table: ActsAsTable.row_models_table }, null: true
+      t.integer :position, index: true, null: false, default: 1
+
+      t.string :name, null: false
+      t.string :separator, null: false, default: ','
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.record_models_table do |t|
+      t.references :row_model, index: true, foreign_key: { to_table: ActsAsTable.row_models_table }, null: false
+
+      t.string :class_name, null: false
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.lenses_table do |t|
+      t.references :record_model, index: true, foreign_key: { to_table: ActsAsTable.record_models_table }, null: false
+
+      t.references :column_model, index: true, foreign_key: { to_table: ActsAsTable.column_models_table }
+
+      t.string :method_name, null: false
+      t.string :default_value
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.foreign_keys_table do |t|
+      t.references :record_model, index: true, foreign_key: { to_table: ActsAsTable.record_models_table }, null: false
+
+      t.references :column_model, index: true, foreign_key: { to_table: ActsAsTable.column_models_table }
+
+      t.string :method_name, null: false
+      t.string :primary_key, null: false, default: 'id'
+      t.string :default_value
+      t.boolean :polymorphic, null: false, default: false
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.foreign_key_maps_table do |t|
+      t.references :foreign_key, index: true, foreign_key: { to_table: ActsAsTable.foreign_keys_table }, null: false
+      t.integer :position, index: true, null: false, default: 1
+
+      t.string :source_value, null: false
+      t.string :target_value, null: false
+      t.boolean :regexp, null: false, default: false
+      t.boolean :ignore_case, null: false, default: false
+      t.boolean :multiline, null: false, default: false
+      t.boolean :extended, null: false, default: false
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.primary_keys_table do |t|
+      t.references :record_model, index: true, foreign_key: { to_table: ActsAsTable.record_models_table }, null: false
+
+      t.references :column_model, index: true, foreign_key: { to_table: ActsAsTable.column_models_table }
+
+      t.string :method_name, null: false, default: 'id'
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.belongs_tos_table do |t|
+      t.references :row_model, index: true, foreign_key: { to_table: ActsAsTable.row_models_table }, null: false
+
+      t.integer :source_record_model_id, index: true, null: false
+      t.integer :target_record_model_id, index: true, null: false
+
+      t.string :macro, null: false, default: 'belongs_to'
+      t.string :method_name, null: false
+
+      t.timestamps null: false
+    end
+    add_foreign_key ActsAsTable.belongs_tos_table, ActsAsTable.record_models_table, column: 'source_record_model_id'
+    add_foreign_key ActsAsTable.belongs_tos_table, ActsAsTable.record_models_table, column: 'target_record_model_id'
+
+    create_table ActsAsTable.has_manies_table do |t|
+      t.references :row_model, index: true, foreign_key: { to_table: ActsAsTable.row_models_table }, null: false
+
+      t.integer :source_record_model_id, index: true, null: false
+
+      t.string :macro, null: false, default: 'has_many'
+      t.string :method_name, null: false
+
+      t.timestamps null: false
+    end
+    add_foreign_key ActsAsTable.has_manies_table, ActsAsTable.record_models_table, column: 'source_record_model_id'
+
+    create_table ActsAsTable.has_many_targets_table do |t|
+      t.references :has_many, index: true, foreign_key: { to_table: ActsAsTable.has_manies_table }, null: false
+      t.integer :position, index: true, null: false, default: 1
+
+      t.references :record_model, index: true, foreign_key: { to_table: ActsAsTable.record_models_table }, null: false
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.tables_table do |t|
+      t.references :row_model, index: true, foreign_key: { to_table: ActsAsTable.row_models_table }, null: false
+
+      t.timestamps null: false
+
+      t.integer :records_count, null: false, default: 0
+    end
+
+    create_table ActsAsTable.records_table do |t|
+      t.references :table, index: true, foreign_key: { to_table: ActsAsTable.tables_table }, null: false
+      t.references :record_model, index: true, foreign_key: { to_table: ActsAsTable.record_models_table }, null: false
+      t.integer :position, index: true, null: false, default: 1
+
+      t.references :base, polymorphic: true, index: true
+
+      t.boolean :record_model_changed, null: false, default: false
+
+      t.timestamps null: false
+
+      t.integer :record_errors_count, null: false, default: 0
+      t.integer :values_count, null: false, default: 0
+    end
+
+    create_table ActsAsTable.record_errors_table do |t|
+      t.references :record, index: true, foreign_key: { to_table: ActsAsTable.records_table }, null: false
+
+      t.references :value, index: true, foreign_key: { to_table: ActsAsTable.values_table }
+
+      t.string :attribute_name, null: false
+      t.string :message, null: false
+
+      t.timestamps null: false
+    end
+
+    create_table ActsAsTable.values_table do |t|
+      t.references :record, index: true, foreign_key: { to_table: ActsAsTable.records_table }, null: false
+      t.references :value_provider, polymorphic: true, index: true, null: false
+
+      t.references :column_model, index: true, foreign_key: { to_table: ActsAsTable.column_models_table }
+      t.integer :position, index: true
+
+      t.text :source_value
+      t.text :target_value
+      t.boolean :value_provider_changed, null: false, default: false
+
+      t.timestamps null: false
+
+      t.integer :record_errors_count, null: false, default: 0
+    end
+  end
+
+  def self.down
+    drop_table ActsAsTable.belongs_tos_table
+    drop_table ActsAsTable.column_models_table
+    drop_table ActsAsTable.foreign_key_maps_table
+    drop_table ActsAsTable.foreign_keys_table
+    drop_table ActsAsTable.has_manies_table
+    drop_table ActsAsTable.has_many_targets_table
+    drop_table ActsAsTable.lenses_table
+    drop_table ActsAsTable.primary_keys_table
+    drop_table ActsAsTable.record_errors_table
+    drop_table ActsAsTable.record_models_table
+    drop_table ActsAsTable.records_table
+    drop_table ActsAsTable.row_models_table
+    drop_table ActsAsTable.tables_table
+    drop_table ActsAsTable.values_table
+  end
+end