simple_master 1.0.0

data/lib/simple_master/master/validatable.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Errors
+      def initialize
+        @errors = []
+      end
+
+      def add(attribute, type = :invalid, **options)
+        @errors << [attribute, type, options]
+      end
+
+      delegate :empty?, :map, :each, :size, to: :@errors
+    end
+
+    # Validator works similar to ActiveRecord::Validations::UniquenessValidator.
+    class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
+      def initialize(options)
+        if options[:conditions] && !options[:conditions].respond_to?(:call)
+          fail ArgumentError, "#{options[:conditions]} was passed as :conditions but is not callable. " \
+                              "Pass a callable instead: `conditions: -> { where(approved: true) }`"
+        end
+        unless Array(options[:scope]).all? { |scope| scope.respond_to?(:to_sym) }
+          fail ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
+                              "Pass a symbol or an array of symbols instead: `scope: :user_id`"
+        end
+        super
+        @klass = options[:class]
+      end
+
+      def validate_each(record, attribute, value)
+        unless @klass.select { _1.send(attribute) == value }.one?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+
+          record.errors.add(attribute, :taken, **error_options)
+        end
+      end
+    end
+
+    module Validatable
+      extend ActiveSupport::Concern
+
+      #: () -> bool
+      def valid?
+        _run_validate_callbacks
+        # Refer directly instead of errors.empty? to avoid creating many errors objects
+        !Thread.current[:errors]&.[](self).present?
+      end
+
+      # @rbs skip
+      def validate
+        _run_validate_callbacks
+      end
+
+      def _run_validate_callbacks
+        self.class._validate_callbacks.each do |validation_proc|
+          instance_exec(&validation_proc)
+        rescue => e
+          errors.add(:base, "Error occurred while validation: #{e}")
+        end
+      end
+
+      def errors
+        Thread.current[:errors] ||= {}
+        Thread.current[:errors][self] ||= Errors.new
+      end
+
+      def run_proc_or_call(symbol_or_proc)
+        return send(symbol_or_proc) if symbol_or_proc.is_a? Symbol
+        return instance_eval(&symbol_or_proc) if symbol_or_proc.arity == 1
+        instance_exec(&symbol_or_proc)
+      end
+
+      def read_attribute_for_validation(attribute)
+        send(attribute)
+      end
+
+      class_methods do
+        # Validation procs to be called by current class on each record
+        def _validate_procs
+          @_validate_procs ||= []
+        end
+
+        # Validation procs to be called by current and parent classes on each record
+        # (Similar to ActiveModel interface, but returns procs.)
+        def _validate_callbacks
+          if superclass < SimpleMaster::Master
+            superclass._validate_callbacks + _validate_procs
+          else
+            _validate_procs
+          end
+        end
+
+        # ref: https://github.com/ruby/gem_rbs_collection/blob/54fe53bbe56e5ff4e9bc2cb2c95426f13abe77ca/gems/activemodel/6.0/activemodel.rbs#L48-L50
+        # @rbs!
+        #   type condition[T] = Symbol | ^(T) [self: T] -> boolish
+        #   type conditions[T] = condition[T] | Array[condition[T]]
+
+        # (ActiveModel interface compliant.)
+        # @rbs *validations: untyped
+        # @rbs **options: { on?: Symbol | Array[Symbol], if?: conditions[instance], unless?: conditions[instance] }
+        # @rbs &: ?{ (instance) [self: instance] -> void }
+        # @rbs return: void
+        def validate(*validations, **options, &)
+          conditions = options.slice(:if, :unless)
+
+          condition_procs = validation_condition_procs(conditions)
+
+          validations.each do |validation|
+            _validate_procs << proc {
+              run_proc_or_call(validation) if condition_procs.all? { run_proc_or_call(_1) }
+            }
+          end
+          _validate_procs << -> { instance_exec(&) if condition_procs.all? { run_proc_or_call(_1) } } if block_given?
+        end
+
+        # (ActiveModel interface compliant.)
+        # @rbs skip
+        def validates(*attributes)
+          defaults = attributes.extract_options!.dup
+          validations = defaults.slice!(:if, :unless, :on, :allow_blank, :allow_nil, :strict)
+
+          fail ArgumentError, "You need to supply at least one attribute" if attributes.empty?
+          fail ArgumentError, "You need to supply at least one validation" if validations.empty?
+          warn "Option :on is not supported" if defaults[:on]
+          warn "Option :strict is not supported" if defaults[:strict]
+
+          defaults[:attributes] = attributes
+
+          validations.each do |key, options|
+            key = "#{key.to_s.camelize}Validator"
+
+            validator = find_validator(key) || find_validator("ActiveModel::Validations::#{key}")
+
+            fail ArgumentError, "Unknown validator: '#{key}'" unless validator
+
+            next unless options
+
+            validates_with(validator, defaults.merge(_parse_validates_options(options)))
+          end
+        end
+
+        # (ActiveModel interface compliant.)
+        # block args: (record, attribute, value)
+        def validates_each(*attributes, **options)
+          conditions = options.slice(:if, :unless)
+          condition_procs = validation_condition_procs(conditions)
+          attributes.each do |attribute|
+            _validate_procs << proc {
+              value = send(attribute)
+              next if options[:allow_nil] && value.nil?
+              next if options[:allow_blank] && value.blank?
+              yield(self, attribute, value) if condition_procs.all? { run_proc_or_call(_1) }
+            }
+          end
+        end
+
+        # (ActiveModel interface compliant.)
+        def validates_with(*args, &)
+          options = args.extract_options!
+          options[:class] = self
+
+          conditions = options.slice(:if, :unless)
+
+          condition_procs = validation_condition_procs(conditions)
+
+          args.each do |klass|
+            validator = klass.new(options.dup, &)
+
+            _validate_procs << proc {
+              validator.validate(self) if condition_procs.all? { run_proc_or_call(_1) }
+            }
+          end
+        end
+
+        private
+
+        def _parse_validates_options(options)
+          case options
+          when TrueClass
+            EMPTY_HASH
+          when Hash
+            options
+          when Range, Array
+            { in: options }
+          else
+            { with: options }
+          end
+        end
+
+        def find_validator(key)
+          const_get(key)
+        rescue NameError
+          false
+        end
+
+        # processing :if, :unless conditions
+        def validation_condition_procs(conditions)
+          conditions.flat_map do |key, value|
+            if key == :if
+              Array.wrap(value)
+            elsif key == :unless
+              Array.wrap(value).map { |v|
+                -> { !run_proc_or_call(v) }
+              }
+            else
+              EMPTY_ARRAY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master.rb

@@ -0,0 +1,417 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    autoload :Column, "simple_master/master/column"
+    autoload :Association, "simple_master/master/association"
+    autoload :Editable, "simple_master/master/editable"
+    autoload :Dsl, "simple_master/master/dsl"
+    autoload :Filterable, "simple_master/master/filterable"
+    autoload :Storable, "simple_master/master/storable"
+    autoload :Queryable, "simple_master/master/queryable"
+    autoload :Validatable, "simple_master/master/validatable"
+
+    extend Dsl
+    extend Filterable
+    extend Storable
+    extend Queryable
+    include Validatable
+
+    class << self
+      attr_accessor :abstract_class
+
+      #: () -> bool
+      def abstract_class?
+        !!abstract_class
+      end
+
+      #: () -> bool
+      def table_exists?
+        table_available?
+      end
+
+      # Auto-generated methods live in a module so they can be overridden.
+      def simple_master_module
+        @simple_master_module ||= Module.new
+      end
+
+      # def simple_master_class_methods
+      #   @simple_master_class_methods ||= Module.new
+      # end
+
+      #: () -> Array[Integer]
+      def ids
+        id_hash.keys
+      end
+
+      #: () -> Array[SimpleMaster::Master::Column]
+      def columns
+        @columns ||= []
+      end
+
+      #: () -> Array[SimpleMaster::Master::Column]
+      def all_columns
+        if superclass < SimpleMaster::Master
+          (superclass.all_columns + columns).reverse.uniq(&:name).reverse
+        else
+          columns
+        end
+      end
+
+      def update_column_info(name)
+        if (column_index = columns.find_index { _1.name == name })
+          columns[column_index] = yield(columns[column_index])
+          return
+        end
+
+        if (column_from_parent = superclass.all_columns.find { _1.name == name })
+          new_column = yield(column_from_parent)
+          columns << new_column
+          return
+        end
+
+        fail "Column #{name} not found on #{self}!"
+      end
+
+      #: () -> Array[String]
+      def column_names
+        all_columns.map(&:name)
+      end
+
+      # Unlike ActiveRecord, we ensure column existence can be checked.
+      #: () -> Hash[String, SimpleMaster::Master::Column]
+      def columns_hash
+        all_columns.index_by(&:name).with_indifferent_access
+      end
+
+      def has_one_associations
+        @has_one_associations ||= []
+      end
+
+      def all_has_one_associations
+        if superclass < SimpleMaster::Master
+          superclass.all_has_one_associations + has_one_associations
+        else
+          has_one_associations
+        end
+      end
+
+      def has_many_associations
+        @has_many_associations ||= []
+      end
+
+      def all_has_many_associations
+        if superclass < SimpleMaster::Master
+          superclass.all_has_many_associations + has_many_associations
+        else
+          has_many_associations
+        end
+      end
+
+      def belongs_to_associations
+        @belongs_to_associations ||= []
+      end
+
+      def all_belongs_to_associations
+        if superclass < SimpleMaster::Master
+          superclass.all_belongs_to_associations + belongs_to_associations
+        else
+          belongs_to_associations
+        end
+      end
+
+      def group_keys
+        @group_keys || all_columns.select(&:group_key).map(&:name)
+      end
+
+      def sti_base_class
+        nil
+      end
+
+      def sti_column
+        nil
+      end
+
+      # @rbs skip
+      alias inheritance_column sti_column
+
+      def primary_key
+        :id
+      end
+
+      # @rbs skip
+      alias polymorphic_name name
+
+      def has_query_constraints?
+        false
+      end
+
+      def composite_primary_key?
+        false
+      end
+
+      def table_name
+        ActiveSupport::Inflector.tableize(base_class.to_s).tr("/", "_")
+      end
+
+      def current_scope
+        fail
+        # pp caller
+        # raise
+        # @current_scope ||= Scope.new
+      end
+
+      #: () -> void
+      def init(database_available = true, for_test: false)
+        @object_cache = Hash.new { |k, v| k[v] = {} }
+
+        _build_dsl
+        _build_columns(for_test)
+        _build_associations(database_available, for_test)
+        _build_sti_methods
+
+        # Override on test env.
+        define_method(:cache_object) { |_column, input, &block| block.call(input) } if for_test
+      end
+
+      #: () -> void
+      def dsl_initializers
+        @dsl_initializers ||= []
+      end
+
+      #: () -> void
+      def _build_dsl
+        dsl_initializers.each(&:call)
+      end
+
+      #: () -> void
+      def _build_columns(for_test)
+        columns.each do |column|
+          column.init(self, for_test)
+        end
+
+        @group_keys = group_keys
+
+        simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def attributes
+            {
+              #{
+                all_columns.map { |column| "#{column.name}: #{column.name}" }.join(",\n")
+              }
+            }
+          end
+
+          def db_attributes
+            {
+              #{
+                all_columns.map { |column| "#{column.db_column_name}: #{column.name}_value_for_csv" }.join(",\n")
+              }
+            }
+          end
+
+          def globalized_db_attributes
+            {
+              #{
+                all_columns.map { |column| "#{column.db_column_name}: #{column.name}_value_for_csv" }.join(",\n")
+              },
+              #{
+                all_columns.select { |column| column.options[:globalize] }.map { |column|
+                  "_globalized_#{column.name}: _globalized_#{column.name}"
+                }.join(",\n")
+              }
+            }
+          end
+
+          def create_copy
+            r = self.class.default_object.dup
+            #{
+              all_columns.map { |column| "r.#{column.name} = #{column.name}" }.join("\n")
+            }
+            r
+          end
+        RUBY
+
+        build_default_object
+      end
+
+      #: () -> void
+      def _build_associations(is_database_available, for_test)
+        associations = has_one_associations + has_many_associations + belongs_to_associations
+
+        associations.each do |association|
+          next if !is_database_available && association.is_active_record?
+          association.init(self)
+          association.init_for_test(self) if for_test
+        end
+      end
+
+      def _build_sti_methods
+        extend SubClassStorable if sti_sub_class?
+      end
+
+      def inherited(subclass)
+        super
+        subclass.include(subclass.simple_master_module)
+      end
+
+      attr_reader :class_method_cache_info #: Array[[Symbol, Proc]]
+      attr_reader :instance_methods_need_tap #: Array[Symbol]
+      attr_reader :default_object #: self
+      attr_reader :object_cache #: Hash[Symbol, untyped]
+
+      # @rbs return: Array[[Symbol, Proc]]
+      def all_class_method_cache_info
+        if superclass < SimpleMaster::Master
+          superclass.all_class_method_cache_info + (class_method_cache_info || EMPTY_ARRAY)
+        else
+          class_method_cache_info || EMPTY_ARRAY
+        end
+      end
+
+      def scope(*_option)
+      end
+
+      def sti_class?
+        !!sti_base_class
+      end
+
+      def sti_base_class?
+        sti_base_class == self
+      end
+
+      def sti_sub_class?
+        !!sti_base_class && sti_base_class != self
+      end
+
+      def base_class
+        sti_base_class || self
+      end
+
+      def base_class?
+        !sti_base_class || sti_base_class?
+      end
+
+      def globalized?
+        all_columns.any? { |column| column.options[:globalize] }
+      end
+
+      #: () -> void
+      def reset_object_cache
+        @object_cache.clear
+      end
+
+      #: () -> void
+      def build_default_object
+        default_object = allocate
+
+        all_columns.each do |column|
+          # Assign nil even when undefined to keep this fast
+          default_object.send :"#{column.name}=", column.options[:default].freeze
+          default_object.send :"_globalized_#{column.name}=", nil if column.options[:globalize]
+        end
+        default_object.type = name if sti_class?
+
+        @default_object = default_object
+      end
+    end
+
+    #: (Symbol, untyped) { (untyped) -> untyped } -> untyped
+    def cache_object(column, input)
+      cache = self.class.base_class.object_cache[column]
+      cache.fetch(input) { cache[input] = yield(input) }
+    end
+
+    def instance_store
+      store = RequestStore.store
+      instance_store = store.fetch(:instance_store) { store[:instance_store] = Hash.new { |hash, key| hash[key] = {} }.compare_by_identity }
+      instance_store[self]
+    end
+
+    def has_many_store
+      RequestStore.store[:has_many_store] ||= {}.compare_by_identity
+      RequestStore.store[:has_many_store][self] ||= {}
+    end
+
+    def belongs_to_store
+      RequestStore.store[:belongs_to_store] ||= {}.compare_by_identity
+      RequestStore.store[:belongs_to_store][self] ||= {}
+    end
+
+    def dirty!
+    end
+
+    alias [] send
+
+    def _read_attribute(key)
+      instance_variable_get("@#{key}")
+    end
+
+    alias read_attribute _read_attribute
+
+    def slice(*attrs)
+      attrs.index_with { send(_1) }
+    end
+
+    def as_json(_option = nil)
+      attributes
+    end
+
+    # for comparing in test.
+    def json_slice(*attrs)
+      JSON.parse(slice(*attrs).to_json)
+    end
+
+    #: () -> bool
+    def destroyed?
+      false
+    end
+
+    #: () -> bool
+    def new_record?
+      false
+    end
+
+    #: () -> bool
+    def has_changes_to_save?
+      false
+    end
+
+    #: () -> bool
+    def marked_for_destruction?
+      false
+    end
+
+    def save(*_)
+    end
+
+    def save!(*_)
+    end
+
+    def update(*_)
+    end
+
+    def update!(*_)
+    end
+
+    def destroy
+    end
+
+    def destroy!
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)} #{attributes.inspect}>"
+    end
+
+    def initialize(attributes = nil)
+      attributes&.each do |key, value|
+        send :"#{key}=", value
+      end
+      yield self if block_given?
+    end
+
+    def self.new(attributes = nil, &)
+      default_object.dup.tap { _1.send(:initialize, attributes, &) }
+    end
+  end
+end

data/lib/simple_master/schema.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Schema
+    class << self
+      TYPE = {
+        integer: :integer,
+        float: :float,
+        string: :string,
+        text: :string,
+        json: :json,
+        boolean: :boolean,
+        datetime: :time,
+        time: :time,
+      }.freeze
+
+      def generate(table_name)
+        ar_columns = ::ActiveRecord::Base.connection.columns(table_name)
+        ar_columns.each do |ar_column|
+          info = []
+
+          info << "  def_column :#{ar_column.name}"
+
+          if ar_column.name == "type"
+            info << "sti: true"
+          elsif ar_column.name.end_with?("type") && ar_columns.any? { _1.name == "#{ar_column.name.delete_suffix('_type')}_id" }
+            info << "polymorphic_type: true"
+          elsif ar_column.name != "id" && TYPE[ar_column.type]
+            info << "type: :#{TYPE[ar_column.type]}"
+          end
+
+          unless ar_column.default.nil?
+            db_default_value = db_default_value(ar_column)
+
+            info << "default: #{db_default_value.inspect}"
+          end
+
+          if ar_column.type == :time
+            info << "db_type: :time"
+          end
+
+          puts info.join(", ")
+        end
+
+        nil
+      end
+    end
+  end
+end