rails_admin 3.3.0 → 4.0.0.beta

data/lib/rails_admin/abstract_model.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require 'rails_admin/adapters'
+require 'rails_admin/adapters/statement_builder'
+require 'rails_admin/criteria/path'
+require 'rails_admin/criteria/period'
 require 'rails_admin/support/datetime'
 
 module RailsAdmin
   class AbstractModel
+    # Moved to RailsAdmin::Adapters::StatementBuilder, which is where the
+    # adapters that subclass it now live. Kept so that out-of-tree adapters
+    # subclassing the old name keep working.
+    StatementBuilder = RailsAdmin::Adapters::StatementBuilder
+
     cattr_accessor :all
-    attr_reader :adapter, :model_name
+    attr_reader :adapter, :model_name, :reflection, :repository
 
     class << self
       def reset
@@ -43,16 +52,51 @@ module RailsAdmin
       def reset_polymorphic_parents
         @@polymorphic_parents = {}
       end
+
+      # A classifier answers "what is this attribute, in RailsAdmin's terms" for
+      # attributes whose meaning comes from the model layer rather than from the
+      # store: attachment libraries, enums and the like. Without it every field
+      # factory has to reach past the adapter and inspect the model class itself.
+      #
+      # The block receives the model class and a property, and returns a Role or
+      # nil to defer to the next classifier. Classifiers run last in, first out.
+      # A classifier must not ask the property for its role, or it recurses.
+      def register_classifier(&block)
+        classifiers.unshift(block)
+      end
+
+      def classifiers
+        @classifiers ||= []
+      end
+
+      def classify(model, property)
+        classifiers.each do |classifier|
+          role = classifier.call(model, property)
+          return role if role
+        end
+        nil
+      end
+    end
+
+    # What a property turned out to be, beyond its storage type.
+    #
+    # +kind+ names the thing (:shrine, :paperclip, :enum, ...), +name+ is the
+    # field name it should be surfaced under, and +children+ lists the columns
+    # that back it and therefore should not be shown on their own.
+    Role = Struct.new(:kind, :name, :children, keyword_init: true) do
+      def initialize(kind:, name:, children: [])
+        super
+      end
     end
 
     def initialize(model_or_model_name)
       @model_name = model_or_model_name.to_s
-      ancestors = model.ancestors.collect(&:to_s)
-      if ancestors.include?('ActiveRecord::Base') && !model.abstract_class? && model.table_exists?
-        initialize_active_record
-      elsif ancestors.include?('Mongoid::Document')
-        initialize_mongoid
-      end
+      registration = Adapters.detect(model)
+      return unless registration
+
+      @adapter = registration.name
+      @reflection = registration.reflection.new(self)
+      @repository = registration.repository.new(self)
     end
 
     # do not store a reference to the model, does not play well with ActiveReload/Rails3.2
@@ -60,13 +104,21 @@ module RailsAdmin
       @model_name.constantize
     end
 
-    def quoted_table_name
-      table_name
-    end
+    # What the model is, and what can be done with it, are the two halves of an
+    # adapter. AbstractModel is the one object callers talk to; it owns neither
+    # answer and forwards both.
+    delegate :properties, :associations, :base_class, :primary_key, :primary_keys, :table_name,
+             :quoted_table_name, :quote_column_name, :encoding, :embedded?, :cyclic?,
+             :adapter_supports_joins?, :belongs_to_required_by_default,
+             :pretty_name, :human_attribute_name, :attribute_required?,
+             :attribute_length_options, :attribute_enum_values, :dummy_record,
+             to: :reflection
 
-    def quote_column_name(name)
-      name
-    end
+    delegate :new, :get, :first, :all, :count, :destroy, :scoped, :where, :read, :save, :each_record,
+             :each_associated_children, :format_id, :parse_id,
+             :serialize_attribute, :deserialize_attribute,
+             :sort_expression, :search_column, :parse_object_id,
+             to: :repository
 
     def to_s
       model.to_s
@@ -84,192 +136,18 @@ module RailsAdmin
       @model_name.split('::').collect(&:underscore).join('_')
     end
 
-    def pretty_name
-      model.model_name.human
-    end
-
-    def where(conditions)
-      model.where(conditions)
-    end
-
-    def each_associated_children(object)
-      associations.each do |association|
-        case association.type
-        when :has_one
-          child = object.send(association.name)
-          yield(association, [child]) if child
-        when :has_many
-          children = object.send(association.name)
-          yield(association, Array.new(children))
-        end
-      end
-    end
-
-    def format_id(id)
-      id
-    end
-
-    def parse_id(id)
-      id
-    end
-
-  private
-
     def initialize_active_record
       @adapter = :active_record
       require 'rails_admin/adapters/active_record'
-      extend Adapters::ActiveRecord
+      @reflection = Adapters::ActiveRecord::Reflection.new(self)
+      @repository = Adapters::ActiveRecord::Repository.new(self)
     end
 
     def initialize_mongoid
       @adapter = :mongoid
       require 'rails_admin/adapters/mongoid'
-      extend Adapters::Mongoid
-    end
-
-    def parse_field_value(field, value)
-      value.is_a?(Array) ? value.map { |v| field.parse_value(v) } : field.parse_value(value)
-    end
-
-    class StatementBuilder
-      def initialize(column, type, value, operator)
-        @column = column
-        @type = type
-        @value = value
-        @operator = operator
-      end
-
-      def to_statement
-        return if [@operator, @value].any? { |v| v == '_discard' }
-
-        unary_operators[@operator] || unary_operators[@value] ||
-          build_statement_for_type_generic
-      end
-
-    protected
-
-      def get_filtering_duration
-        FilteringDuration.new(@operator, @value).get_duration
-      end
-
-      def build_statement_for_type_generic
-        build_statement_for_type || begin
-          case @type
-          when :date
-            build_statement_for_date
-          when :datetime, :timestamp, :time
-            build_statement_for_datetime_or_timestamp
-          end
-        end
-      end
-
-      def build_statement_for_type
-        raise 'You must override build_statement_for_type in your StatementBuilder'
-      end
-
-      def build_statement_for_integer_decimal_or_float
-        case @value
-        when Array
-          val, range_begin, range_end = *@value.collect do |v|
-            next unless v.to_i.to_s == v || v.to_f.to_s == v
-
-            @type == :integer ? v.to_i : v.to_f
-          end
-          case @operator
-          when 'between'
-            range_filter(range_begin, range_end)
-          else
-            column_for_value(val) if val
-          end
-        else
-          if @value.to_i.to_s == @value || @value.to_f.to_s == @value
-            @type == :integer ? column_for_value(@value.to_i) : column_for_value(@value.to_f)
-          end
-        end
-      end
-
-      def build_statement_for_date
-        start_date, end_date = get_filtering_duration
-        if start_date
-          start_date = begin
-            start_date.to_date
-          rescue StandardError
-            nil
-          end
-        end
-        if end_date
-          end_date = begin
-            end_date.to_date
-          rescue StandardError
-            nil
-          end
-        end
-        range_filter(start_date, end_date)
-      end
-
-      def build_statement_for_datetime_or_timestamp
-        start_date, end_date = get_filtering_duration
-        start_date = start_date.beginning_of_day if start_date.is_a?(Date)
-        end_date = end_date.end_of_day if end_date.is_a?(Date)
-        range_filter(start_date, end_date)
-      end
-
-      def unary_operators
-        raise 'You must override unary_operators in your StatementBuilder'
-      end
-
-      def range_filter(_min, _max)
-        raise 'You must override range_filter in your StatementBuilder'
-      end
-
-      class FilteringDuration
-        def initialize(operator, value)
-          @value = value
-          @operator = operator
-        end
-
-        def get_duration
-          case @operator
-          when 'between'   then between
-          when 'today'     then today
-          when 'yesterday' then yesterday
-          when 'this_week' then this_week
-          when 'last_week' then last_week
-          else default
-          end
-        end
-
-        def today
-          [Date.today, Date.today]
-        end
-
-        def yesterday
-          [Date.yesterday, Date.yesterday]
-        end
-
-        def this_week
-          [Date.today.beginning_of_week, Date.today.end_of_week]
-        end
-
-        def last_week
-          [1.week.ago.to_date.beginning_of_week,
-           1.week.ago.to_date.end_of_week]
-        end
-
-        def between
-          [@value[1], @value[2]]
-        end
-
-        def default
-          [default_date, default_date]
-        end
-
-      private
-
-        def default_date
-          Array.wrap(@value).first
-        end
-      end
+      @reflection = Adapters::Mongoid::Reflection.new(self)
+      @repository = Adapters::Mongoid::Repository.new(self)
     end
   end
 end

data/lib/rails_admin/adapters/active_record/association.rb

@@ -105,7 +105,7 @@ module RailsAdmin
         end
 
         def inverse_of
-          options[:inverse_of].try :to_sym
+          options[:inverse_of].try(:to_sym) || as
         end
 
         def read_only?

data/lib/rails_admin/adapters/active_record/property.rb

@@ -43,6 +43,13 @@ module RailsAdmin
           false
         end
 
+        # @see RailsAdmin::AbstractModel.register_classifier
+        def role
+          return @role if defined?(@role)
+
+          @role = RailsAdmin::AbstractModel.classify(model, self)
+        end
+
         def read_only?
           model.readonly_attributes.include? property.name.to_s
         end

data/lib/rails_admin/adapters/active_record/reflection.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'rails_admin/adapters/reflection'
+require 'rails_admin/adapters/active_record/association'
+require 'rails_admin/adapters/active_record/property'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class Reflection < RailsAdmin::Adapters::Reflection
+        def associations
+          model.reflect_on_all_associations.collect do |association|
+            Association.new(association, model)
+          end
+        end
+
+        def properties
+          columns = model.columns.reject do |c|
+            c.type.blank? ||
+              DISABLED_COLUMN_TYPES.include?(c.type.to_sym) ||
+              c.try(:array)
+          end
+          columns.collect do |property|
+            Property.new(property, model)
+          end
+        end
+
+        def base_class
+          model.base_class
+        end
+
+        delegate :primary_key, :table_name, to: :model, prefix: false
+
+        def quoted_table_name
+          model.quoted_table_name
+        end
+
+        def quote_column_name(name)
+          model.connection.quote_column_name(name)
+        end
+
+        def encoding
+          adapter =
+            if ::ActiveRecord::Base.respond_to?(:connection_db_config)
+              ::ActiveRecord::Base.connection_db_config.configuration_hash[:adapter]
+            else
+              ::ActiveRecord::Base.connection_config[:adapter]
+            end
+          case adapter
+          when 'postgresql'
+            ::ActiveRecord::Base.connection.select_one("SELECT ''::text AS str;").values.first.encoding
+          when 'mysql2'
+            if RUBY_ENGINE == 'jruby'
+              ::ActiveRecord::Base.connection.select_one("SELECT '' AS str;").values.first.encoding
+            else
+              ::ActiveRecord::Base.connection.raw_connection.encoding
+            end
+          when 'oracle_enhanced'
+            ::ActiveRecord::Base.connection.select_one('SELECT dummy FROM DUAL').values.first.encoding
+          else
+            ::ActiveRecord::Base.connection.select_one("SELECT '' AS str;").values.first.encoding
+          end
+        end
+
+        def embedded?
+          false
+        end
+
+        def cyclic?
+          false
+        end
+
+        def adapter_supports_joins?
+          true
+        end
+
+        def belongs_to_required_by_default
+          model.belongs_to_required_by_default
+        end
+
+        def attribute_enum_values(name)
+          model.defined_enums[name.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record/repository.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'rails_admin/adapters/repository'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class Repository < RailsAdmin::Adapters::Repository
+        BATCH_SIZE = 1000
+
+        def new(params = {})
+          model.new(params)
+        end
+
+        def get(id, scope = scoped)
+          primary_key_scope(scope, id).first
+        end
+
+        def scoped
+          model.all
+        end
+
+        def first(options = {}, scope = nil)
+          all(options, scope).first
+        end
+
+        def all(options = {}, scope = nil)
+          scope ||= scoped
+          scope = scope.includes(options[:include]) if options[:include]
+          scope = scope.limit(options[:limit]) if options[:limit]
+          scope = bulk_scope(scope, options) if options[:bulk_ids]
+          scope = query_scope(scope, options[:query]) if options[:query]
+          scope = filter_scope(scope, options[:filters]) if options[:filters]
+          scope = scope.send(Kaminari.config.page_method_name, options[:page]).per(options[:per]) if options[:page] && options[:per]
+          scope = sort_scope(scope, options) if options[:sort]
+          scope
+        end
+
+        def count(options = {}, scope = nil)
+          all(options.merge(limit: false, page: false), scope).count(:all)
+        end
+
+        def destroy(objects)
+          Array.wrap(objects).each(&:destroy)
+        end
+
+        # A relation loads whole when it is iterated, so the records are fetched
+        # in batches. find_each does that, but only in primary key order, which is
+        # why an export used to come out in a different order from the list.
+        #
+        # A sort by the primary key alone still goes to find_each, which walks the
+        # key and so stays fast however far in it gets. Any other sort is fetched
+        # a page at a time by offset, with the primary key added as a tie-break:
+        # rows that sort equal are otherwise free to come back in a different
+        # order for each page, and stitching the pages together could repeat one
+        # row and lose another.
+        def each_record(scope, &block)
+          return to_enum(:each_record, scope) unless block
+          return super unless scope.is_a?(::ActiveRecord::Relation)
+          # Already cut down to size, and batching would replace the limit.
+          return scope.each(&block) if scope.limit_value || scope.offset_value
+          return scope.find_each(batch_size: BATCH_SIZE, &block) if scope.order_values.empty?
+
+          # find_each in the composite_primary_keys gem does not keep a descending
+          # order across a composite key. Only reachable below Rails 7.1, so this
+          # goes with support for Rails 7.0, as the gem does.
+          direction = primary_key_order(scope) unless primary_keys.many? && defined?(::CompositePrimaryKeys)
+          if direction
+            scope.reorder(nil).find_each(batch_size: BATCH_SIZE, order: direction, &block)
+          else
+            each_record_by_offset(scope, &block)
+          end
+        end
+
+        def read(record, name)
+          record.has_attribute?(name) ? record.read_attribute(name) : record.send(name)
+        end
+
+        def format_id(id)
+          return id unless primary_keys.many?
+
+          RailsAdmin.config.composite_keys_serializer.serialize(id)
+        end
+
+        def parse_id(id)
+          return id unless primary_keys.many?
+
+          ids = RailsAdmin.config.composite_keys_serializer.deserialize(id)
+          primary_keys.each_with_index do |key, i|
+            ids[i] = model.type_for_attribute(key).cast(ids[i])
+          end
+          ids
+        end
+
+        def serialize_attribute(name, value)
+          model.type_for_attribute(name.to_s).serialize(value)
+        end
+
+        def deserialize_attribute(name, value)
+          model.type_for_attribute(name.to_s).deserialize(value)
+        end
+
+        def sort_expression(order)
+          return order.to_s unless order.is_a?(RailsAdmin::Criteria::Path)
+
+          "#{quoted_path_table_name(order)}.#{quote_column_name(order.attribute)}"
+        end
+
+        # Unlike sorting, search statements are assembled unquoted, and the table
+        # half is read back out to build the relation's references.
+        def search_column(target)
+          return target.to_s unless target.is_a?(RailsAdmin::Criteria::Path)
+
+          "#{path_table_name(target)}.#{target.attribute}"
+        end
+
+      private
+
+        # The model the path's attribute lives on. Only a single association hop
+        # is resolvable, which is all the field configuration can express.
+        def path_abstract_model(path)
+          return abstract_model if path.root?
+
+          association = associations.detect { |a| a.name == path.associations.first }
+          raise ArgumentError.new("Unknown association in path: #{path}") unless association
+
+          RailsAdmin::AbstractModel.new(association.klass)
+        end
+
+        def path_table_name(path)
+          path_abstract_model(path).table_name
+        end
+
+        def quoted_path_table_name(path)
+          path_abstract_model(path).quoted_table_name
+        end
+
+        def primary_key_scope(scope, id)
+          scope.where(primary_keys.zip(Array(parse_id(id))).to_h)
+        end
+
+        # The direction a scope is sorted in when it is sorted by the primary key
+        # and nothing else, or nil. Rather than reading the order back out of the
+        # SQL, each way #all could have sorted by the key is rebuilt through
+        # #sort_scope and compared, so what is recognised is exactly what #all
+        # produces.
+        def primary_key_order(scope)
+          sorts = [primary_key]
+          sorts << RailsAdmin::Criteria::Path[primary_keys.first] unless primary_keys.many?
+          %i[desc asc].detect do |direction|
+            sorts.any? do |sort|
+              sort_scope(scope, sort: sort, sort_reverse: direction == :asc).order_values == scope.order_values
+            end
+          end
+        end
+
+        def each_record_by_offset(scope, &block)
+          scope = scope.order(*primary_keys.collect { |key| Arel.sql("#{quoted_table_name}.#{quote_column_name(key)}") })
+          (0..).step(BATCH_SIZE) do |offset|
+            batch = scope.limit(BATCH_SIZE).offset(offset).to_a
+            batch.each(&block)
+            break if batch.size < BATCH_SIZE
+          end
+        end
+
+        # A composite key has to be matched one whole key at a time, which costs
+        # an OR per id; a single-column key gets the IN it deserves.
+        def bulk_scope(scope, options)
+          if primary_keys.many?
+            options[:bulk_ids].map { |id| primary_key_scope(scope, id) }.reduce(&:or)
+          else
+            scope.where(primary_keys.first => options[:bulk_ids])
+          end
+        end
+
+        def sort_scope(scope, options)
+          direction = options[:sort_reverse] ? :asc : :desc
+          case options[:sort]
+          when RailsAdmin::Criteria::Path, String, Symbol
+            scope.reorder("#{sort_expression(options[:sort])} #{direction}")
+          when Array
+            scope.reorder(options[:sort].zip(Array.new(options[:sort].size) { direction }).to_h)
+          when Hash
+            scope.reorder(options[:sort].map { |table_name, column| "#{table_name}.#{column}" }.
+              zip(Array.new(options[:sort].size) { direction }).to_h)
+          else
+            raise ArgumentError.new("Unsupported sort value: #{options[:sort]}")
+          end
+        end
+
+        def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
+          return scope.send(config.list.search_by, query) if config.list.search_by
+
+          wb = WhereBuilder.new(scope, self)
+          # OR all query statements
+          each_query_condition(query, fields) { |field, value, operator| wb.add(field, value, operator) }
+          wb.build
+        end
+
+        def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
+          each_filter_condition(filters, fields) do |field, value, operator|
+            wb = WhereBuilder.new(scope, self)
+            wb.add(field, value, operator)
+            # AND current filter statements to other filter statements
+            scope = wb.build
+          end
+          scope
+        end
+
+        def build_statement(column, type, value, operator)
+          StatementBuilder.new(column, type, value, operator, model.connection.adapter_name).to_statement
+        end
+      end
+    end
+  end
+end