rails_admin 3.3.0 → 4.0.0.beta

data/lib/rails_admin/adapters/reflection.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    # The half of an adapter that describes a model: what its attributes and
+    # associations are, what the store calls them, and what the model layer says
+    # about them.
+    #
+    # One instance per model, held by the AbstractModel that composes it. A
+    # reflection answers questions about the model and never reads or writes a
+    # record; the store it does reach for is the schema, not the data.
+    class Reflection
+      attr_reader :abstract_model
+
+      def initialize(abstract_model)
+        @abstract_model = abstract_model
+      end
+
+      delegate :model, to: :abstract_model
+
+      # The columns the primary key is made of, always as an array of symbols --
+      # a single-column key is an array of one.
+      #
+      # #primary_key answers in the store's own shape, a name or an array of
+      # them, and keeps doing so for callers outside the gem. Everything inside
+      # asks in the plural instead, so that a composite key is not a special case
+      # each caller has to remember to notice.
+      def primary_keys
+        Array(primary_key).collect(&:to_sym)
+      end
+
+      # Stores that neither qualify nor quote identifiers use the names as they
+      # are; ActiveRecord asks its connection instead.
+      def quoted_table_name
+        table_name
+      end
+
+      def quote_column_name(name)
+        name
+      end
+
+      def pretty_name
+        model.model_name.human
+      end
+
+      def human_attribute_name(name)
+        model.human_attribute_name(name)
+      end
+
+      # Whether the model makes the given attribute mandatory, either through a
+      # validation or through the options of a belongs_to association.
+      #
+      # +context+ is +:create+, +:update+ or +nil+ and is matched against the
+      # +:on+ option of a validation. Adapters may override this when their ORM
+      # expresses requiredness differently.
+      def attribute_required?(name, context)
+        !!(required_by_validation?(name, context) || required_by_association?(name))
+      end
+
+      # Options of the length validation defined on the given attribute, if any.
+      def attribute_length_options(name)
+        model.validators_on(name).detect { |validator| validator.kind == :length }.try(&:options) || {}
+      end
+
+      # The values of an enum defined on the given attribute, or nil.
+      #
+      # Only stores with a native enum concept answer this; the rest leave enums
+      # to the model, which is what Types::Enum asks about instead.
+      def attribute_enum_values(_name)
+        nil
+      end
+
+      # A throwaway record, for asking what an instance of this model responds to
+      # when no real one is at hand.
+      #
+      # Instantiating one is wasteful and runs the model's initialization, but
+      # method_defined? would miss anything served through method_missing, so the
+      # original behavior is kept until there is a reason to narrow it.
+      def dummy_record
+        model.new
+      end
+
+    private
+
+      def required_by_validation?(name, context)
+        model.validators_on(name).detect do |validator|
+          !(validator.options[:allow_nil] || validator.options[:allow_blank]) &&
+            %i[presence numericality attachment_presence].include?(validator.kind) &&
+            (validator.options[:on] == context || validator.options[:on].blank?) &&
+            (validator.options[:if].blank? && validator.options[:unless].blank?)
+        end
+      end
+
+      def required_by_association?(name)
+        model.reflect_on_all_associations(:belongs_to).detect do |association|
+          next unless association.name == name
+
+          required = association.options[:required] if association.options.key?(:required)
+          required = !association.options[:optional] if association.options.key?(:optional) && required.nil?
+          required.nil? ? belongs_to_required_by_default : required
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/repository.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    # The half of an adapter that reaches the store: reading records, writing
+    # them, and compiling what the configuration asked for into a query.
+    #
+    # One instance per model, held by the AbstractModel that composes it. Where a
+    # repository needs to know something about the model rather than do something
+    # with it, it asks through that facade, so that the two halves of an adapter
+    # never have to reach for each other directly.
+    class Repository
+      attr_reader :abstract_model
+
+      def initialize(abstract_model)
+        @abstract_model = abstract_model
+      end
+
+      delegate :model, :config, :associations, :primary_key, :primary_keys, :table_name,
+               :quoted_table_name, :quote_column_name, to: :abstract_model
+
+      # Yield the records of a scope one at a time, in the order it is sorted in,
+      # without holding all of them at once. What an export walks.
+      #
+      # Anything that is not a scope, such as an array of records, is taken as it
+      # comes. A store whose query already streams in order needs nothing more
+      # than #each, which is all this does.
+      def each_record(scope, &block)
+        return to_enum(:each_record, scope) unless block
+
+        scope.each(&block)
+      end
+
+      # Read one attribute from a record: the value the store holds, rather than
+      # what a reader of the same name would return.
+      #
+      # It began as a way around a column named +format+, which on Rails 3
+      # reached Kernel#format when it was sent, because attribute methods were
+      # not defined until method_missing had been hit (955cca09, 2011). Rails
+      # defines them earlier now and that particular collision is gone, but the
+      # rule it left behind is what a model redefining a reader still meets.
+      #
+      # Adapters say how their store tells an attribute from a method.
+      def read(record, name)
+        record.send(name)
+      end
+
+      # Persist a record, and whatever else the store needs doing to call it
+      # saved. Answers the way the record's own #save does.
+      def save(record)
+        record.save
+      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
+
+      # How a record's id travels through a URL, and back.
+      #
+      # Only composite keys need more than the id itself, so the default is to
+      # hand it over unchanged.
+      def format_id(id)
+        id
+      end
+
+      def parse_id(id)
+        id
+      end
+
+      # Convert a Ruby value into the representation the store holds for the
+      # given attribute, and back.
+      #
+      # Both default to passing the value through. Adapters override them when
+      # their ORM has a type system able to do better; the Mongoid adapter does
+      # not, so values reach it unconverted.
+      def serialize_attribute(_name, value)
+        value
+      end
+
+      def deserialize_attribute(_name, value)
+        value
+      end
+
+      # Render a sort target as an expression the store understands. Adapters
+      # that need qualification or quoting override this; anything already
+      # expressed in the store's own terms is handed through.
+      def sort_expression(order)
+        order.to_s
+      end
+
+      # Render a search target as the column reference the store understands.
+      # Overridden where reaching an associated attribute takes more than the
+      # dotted path itself.
+      def search_column(target)
+        target.to_s
+      end
+
+    private
+
+      def parse_field_value(field, value)
+        value.is_a?(Array) ? value.map { |v| parse_one_value(field, v) } : parse_one_value(field, value)
+      end
+
+      # What reaches here came from the query string, so a field is regularly
+      # handed something it cannot make sense of -- a date out of range, YAML
+      # which does not parse. A field which cannot read the term takes no part in
+      # the condition, rather than taking the whole page down with it.
+      def parse_one_value(field, value)
+        field.parse_value(value)
+      rescue StandardError
+        nil
+      end
+
+      # The search box asks every queryable field about the same term. Yields
+      # [field, parsed value, operator] so that each adapter is left with turning
+      # a condition into a scope and combining them, rather than reimplementing
+      # which fields take part and how their values are parsed.
+      def each_query_condition(query, fields)
+        return to_enum(:each_query_condition, query, fields) unless block_given?
+
+        fields.each do |field|
+          yield field, parse_field_value(field, query), field.search_operator
+        end
+      end
+
+      # Each filter as [field, parsed value, operator].
+      #
+      # Filters naming a field that does not exist are skipped, and a filter
+      # arriving without an operator falls back to the configured default -- the
+      # field types that offer no operator in the filter UI submit none.
+      #
+      # filters looks like {"string_field" => {"0055" => {"o" => "like", "v" => "x"}}}
+      # where "0055" is the filter index and has no meaning here.
+      #
+      # Nothing guarantees that shape: the filters are read straight off the
+      # query string, which anyone can write by hand. Anything which is not the
+      # nesting the filter UI submits is ignored, so that a hand-written URL
+      # leaves the list unfiltered rather than raising.
+      def each_filter_condition(filters, fields)
+        return to_enum(:each_filter_condition, filters, fields) unless block_given?
+        return unless filters.respond_to?(:each_pair)
+
+        filters.each_pair do |field_name, filters_dump|
+          field = fields.detect { |f| f.name.to_s == field_name }
+          next unless field && filters_dump.respond_to?(:each_value)
+
+          filters_dump.each_value do |filter_dump|
+            next unless filter_dump.respond_to?(:each_pair)
+
+            yield field, parse_field_value(field, filter_dump[:v]), (filter_dump[:o] || RailsAdmin::Config.default_search_operator)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/statement_builder.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'rails_admin/criteria/period'
+
+module RailsAdmin
+  module Adapters
+    # Turns one search or filter condition into whatever the store's query
+    # language calls a condition.
+    #
+    # The parts that are the same everywhere -- discarding a condition, unary
+    # operators, numeric parsing, resolving a relative date into a range -- live
+    # here; each adapter subclasses this and supplies the rest.
+    class StatementBuilder
+      def initialize(column, type, value, operator)
+        @column = column
+        @type = type
+        @value = value
+        @operator = operator
+      end
+
+      def to_statement
+        if @value.is_a?(Array) && @value.include?('_discard')
+          @value = @value.reject { |v| v == '_discard' }
+          return if @value.empty?
+        end
+        return if [@operator, @value].any? { |v| v == '_discard' }
+
+        unary_operators[@operator] || unary_operators[@value] ||
+          build_statement_for_type_generic
+      end
+
+    protected
+
+      def filtering_duration
+        RailsAdmin::Criteria::Period.new(@operator, @value).bounds
+      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 = 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 = 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
+    end
+  end
+end

data/lib/rails_admin/adapters.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  # Which adapters exist, and how a model is matched to one of them.
+  #
+  # An adapter is a name, a way of telling whether a model belongs to it, and
+  # the two classes that implement it -- a Reflection and a Repository. Adding
+  # one from outside the gem is a call to +register+:
+  #
+  #   RailsAdmin::Adapters.register(
+  #     :sequel,
+  #     reflection: RailsAdmin::Adapters::Sequel::Reflection,
+  #     repository: RailsAdmin::Adapters::Sequel::Repository,
+  #   ) { |model| model < ::Sequel::Model }
+  #
+  # The most recently registered adapter is asked first, so a registration can
+  # take over from a built-in one.
+  module Adapters
+    class Registration
+      attr_reader :name
+
+      # +reflection+ and +repository+ may be classes, or the names of classes as
+      # strings together with +require_path+. The built-in adapters name theirs,
+      # because loading an adapter loads its ORM and an application must not have
+      # the ORM it does not use required on its behalf.
+      def initialize(name, reflection:, repository:, require_path: nil, &detector)
+        @name = name
+        @reflection = reflection
+        @repository = repository
+        @require_path = require_path
+        @detector = detector
+      end
+
+      # Whether this adapter handles the given model. Called for every model in
+      # the pool, before anything is loaded, so it must not load the ORM either
+      # -- which is why the built-in detectors match on ancestor names rather
+      # than on the ancestors themselves.
+      def matches?(model)
+        @detector.call(model)
+      end
+
+      def reflection
+        @reflection = resolve(@reflection)
+      end
+
+      def repository
+        @repository = resolve(@repository)
+      end
+
+    private
+
+      def resolve(klass)
+        return klass unless klass.is_a?(::String)
+
+        require @require_path if @require_path
+        klass.constantize
+      end
+    end
+
+    class << self
+      def register(name, **options, &detector)
+        registrations.unshift(Registration.new(name, **options, &detector))
+        name
+      end
+
+      def registrations
+        @registrations ||= []
+      end
+
+      def detect(model)
+        registrations.detect { |registration| registration.matches?(model) }
+      end
+    end
+
+    register(
+      :active_record,
+      require_path: 'rails_admin/adapters/active_record',
+      reflection: 'RailsAdmin::Adapters::ActiveRecord::Reflection',
+      repository: 'RailsAdmin::Adapters::ActiveRecord::Repository',
+    ) do |model|
+      model.ancestors.collect(&:to_s).include?('ActiveRecord::Base') &&
+        !model.abstract_class? && model.table_exists?
+    end
+
+    register(
+      :mongoid,
+      require_path: 'rails_admin/adapters/mongoid',
+      reflection: 'RailsAdmin::Adapters::Mongoid::Reflection',
+      repository: 'RailsAdmin::Adapters::Mongoid::Repository',
+    ) do |model|
+      model.ancestors.collect(&:to_s).include?('Mongoid::Document')
+    end
+  end
+end

data/lib/rails_admin/config/actions/base.rb

@@ -149,6 +149,14 @@ module RailsAdmin
 
         # Off API.
 
+        # Whether the action can be rendered as a plain <a> link, i.e. visiting
+        # its URL performs it. Actions that require a non-GET verb need a
+        # button/form instead, so callers render them as text or a disabled
+        # link. Tolerates verbs written as `:GET` or `"get"`.
+        def linkable?
+          http_methods.include?(:get) || http_methods.any? { |verb| verb.to_s.casecmp?('get') }
+        end
+
         def key
           self.class.key
         end

data/lib/rails_admin/config/actions/bulk_delete.rb

@@ -20,7 +20,7 @@ module RailsAdmin
               @objects = list_entries(@model_config, :destroy)
 
               if @objects.blank?
-                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
+                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label, @model_config.label_plural), action: t('admin.actions.delete.done'))
                 redirect_to index_path
               else
                 render @action.template_name
@@ -44,10 +44,10 @@ module RailsAdmin
               end
 
               if destroyed.nil?
-                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
+                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label, @model_config.label_plural), action: t('admin.actions.delete.done'))
               else
-                flash[:success] = t('admin.flash.successful', name: pluralize(destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless destroyed.empty?
-                flash[:error] = t('admin.flash.error', name: pluralize(not_destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless not_destroyed.empty?
+                flash[:success] = t('admin.flash.successful', name: pluralize(destroyed.count, @model_config.label, @model_config.label_plural), action: t('admin.actions.delete.done')) unless destroyed.empty?
+                flash[:error] = t('admin.flash.error', name: pluralize(not_destroyed.count, @model_config.label, @model_config.label_plural), action: t('admin.actions.delete.done')) unless not_destroyed.empty?
               end
               redirect_to back_or_index
             end

data/lib/rails_admin/config/actions/dashboard.rb

@@ -32,7 +32,7 @@ module RailsAdmin
                 scope = @authorization_adapter&.query(:index, config.abstract_model)
                 current_count = config.abstract_model.count({}, scope)
                 @max = current_count > @max ? current_count : @max
-                name = config.abstract_model.model.name
+                name = config.abstract_model.model_name
                 @count[name] = current_count
                 @most_recent_created[name] = config.last_created_at
               end

data/lib/rails_admin/config/actions/edit.rb

@@ -26,10 +26,11 @@ module RailsAdmin
             elsif request.put? # UPDATE
               sanitize_params_for!(request.xhr? ? :modal : :update)
 
-              @object.assign_attributes(params[@abstract_model.param_key])
+              # A form that posted nothing for the model leaves nothing to assign.
+              @object.assign_attributes(params[@abstract_model.param_key] || {})
               @authorization_adapter&.authorize(:update, @abstract_model, @object)
               changes = @object.changes
-              if @object.save
+              if @abstract_model.save(@object)
                 @auditing_adapter&.update_object(@object, @abstract_model, _current_user, changes)
                 respond_to do |format|
                   format.html { redirect_to_on_success }

data/lib/rails_admin/config/actions/index.rb

@@ -53,7 +53,7 @@ module RailsAdmin
                     if @association
                       @association.collection(@objects).collect { |(label, id)| {id: id, label: label} }
                     else
-                      @objects.collect { |object| {id: object.id.to_s, label: object.send(@model_config.object_label_method).to_s} }
+                      @objects.collect { |object| {id: object.id.to_s, label: @model_config.object_label(object).to_s} }
                     end
                   else
                     @objects.to_json(@schema)

data/lib/rails_admin/config/actions/new.rb

@@ -39,10 +39,11 @@ module RailsAdmin
               @object = @abstract_model.new
               sanitize_params_for!(request.xhr? ? :modal : :create)
 
-              @object.assign_attributes(params[@abstract_model.param_key])
+              # A form that posted nothing for the model leaves nothing to assign.
+              @object.assign_attributes(params[@abstract_model.param_key] || {})
               @authorization_adapter&.authorize(:create, @abstract_model, @object)
 
-              if @object.save
+              if @abstract_model.save(@object)
                 @auditing_adapter&.create_object(@object, @abstract_model, _current_user)
                 respond_to do |format|
                   format.html { redirect_to_on_success }

data/lib/rails_admin/config/actions/show.rb

@@ -21,8 +21,8 @@ module RailsAdmin
         register_instance_option :controller do
           proc do
             respond_to do |format|
-              format.json { render json: @object }
               format.html { render @action.template_name }
+              format.json { render json: @object }
             end
           end
         end

data/lib/rails_admin/config/configurable.rb

@@ -9,7 +9,7 @@ module RailsAdmin
         base.send :extend, ClassMethods
       end
 
-      def has_option?(name) # rubocop:disable Naming/PredicateName
+      def has_option?(name) # rubocop:disable Naming/PredicatePrefix
         options = self.class.instance_variable_get('@config_options')
         options&.key?(name)
       end
@@ -57,7 +57,8 @@ module RailsAdmin
 
           # If it's a boolean create an alias for it and remove question mark
           if option_name.end_with?('?')
-            scope.send(:define_method, "#{option_name.chop!}?") do
+            option_name = option_name.chop
+            scope.send(:define_method, "#{option_name}?") do
               send(option_name)
             end
           end
@@ -84,7 +85,7 @@ module RailsAdmin
         def register_deprecated_instance_option(option_name, replacement_option_name = nil, scope = self)
           scope.send(:define_method, option_name) do |*args, &block|
             if replacement_option_name
-              ActiveSupport::Deprecation.warn("The #{option_name} configuration option is deprecated, please use #{replacement_option_name}.")
+              RailsAdmin.deprecator.warn("The #{option_name} configuration option is deprecated, please use #{replacement_option_name}.")
               send(replacement_option_name, *args, &block)
             elsif block_given?
               yield

data/lib/rails_admin/config/fields/association.rb

@@ -21,7 +21,7 @@ module RailsAdmin
           [value].flatten.select(&:present?).collect do |associated|
             amc = polymorphic? ? RailsAdmin.config(associated) : associated_model_config # perf optimization for non-polymorphic associations
             am = amc.abstract_model
-            wording = associated.send(amc.object_label_method)
+            wording = amc.object_label(associated)
             can_see = !am.embedded? && (show_action = v.action(:show, am, associated))
             can_see ? v.link_to(wording, v.url_for(action: show_action.action_name, model_name: am.to_param, id: associated.id)) : ERB::Util.html_escape(wording)
           end.to_sentence.html_safe.presence || '-'
@@ -36,7 +36,7 @@ module RailsAdmin
 
         # use the association name as a key, not the association key anymore!
         register_instance_option :label do
-          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name association.name
+          (@label ||= {})[::I18n.locale] ||= abstract_model.human_attribute_name association.name
         end
 
         # scope for possible associable records
@@ -137,7 +137,7 @@ module RailsAdmin
         # Returns collection of all selectable records
         def collection(scope = nil)
           (scope || bindings[:controller].list_entries(associated_model_config, :index, associated_collection_scope, false)).
-            map { |o| [o.send(associated_object_label_method), format_key(o.send(associated_primary_key)).to_s] }
+            map { |o| [associated_model_config.object_label(o), format_key(o.send(associated_primary_key)).to_s] }
         end
 
         # has many?
@@ -155,12 +155,13 @@ module RailsAdmin
 
       private
 
+        # A key travels through the DOM and comes back as a URL or form
+        # parameter, so it is the associated model's repository that decides how
+        # it is written down.
         def format_key(key)
-          if key.is_a?(Array)
-            RailsAdmin.config.composite_keys_serializer.serialize(key)
-          else
-            key
-          end
+          return if key.nil? # the association is not set
+
+          associated_model_config.abstract_model.format_id(key)
         end
       end
     end