rails_admin 3.2.1 → 4.0.0.beta

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'rails_admin/adapters/statement_builder'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class StatementBuilder < RailsAdmin::Adapters::StatementBuilder
+        def initialize(column, type, value, operator, adapter_name)
+          super column, type, value, operator
+          @adapter_name = adapter_name
+        end
+
+      protected
+
+        def unary_operators
+          case @type
+          when :boolean
+            boolean_unary_operators
+          when :uuid
+            uuid_unary_operators
+          when :integer, :decimal, :float
+            numeric_unary_operators
+          when :enum
+            enum_unary_operators
+          else
+            generic_unary_operators
+          end
+        end
+
+      private
+
+        def generic_unary_operators
+          {
+            '_blank' => ["(#{@column} IS NULL OR #{@column} = '')"],
+            '_present' => ["(#{@column} IS NOT NULL AND #{@column} != '')"],
+            '_null' => ["(#{@column} IS NULL)"],
+            '_not_null' => ["(#{@column} IS NOT NULL)"],
+            '_empty' => ["(#{@column} = '')"],
+            '_not_empty' => ["(#{@column} != '')"],
+          }
+        end
+
+        def boolean_unary_operators
+          generic_unary_operators.merge(
+            '_blank' => ["(#{@column} IS NULL)"],
+            '_empty' => ["(#{@column} IS NULL)"],
+            '_present' => ["(#{@column} IS NOT NULL)"],
+            '_not_empty' => ["(#{@column} IS NOT NULL)"],
+          )
+        end
+        alias_method :numeric_unary_operators, :boolean_unary_operators
+        alias_method :uuid_unary_operators, :boolean_unary_operators
+        # An enum has no empty member, and comparing one against '' is a type
+        # error on stores which check.
+        alias_method :enum_unary_operators, :boolean_unary_operators
+
+        def range_filter(min, max)
+          if min && max && min == max
+            ["(#{@column} = ?)", min]
+          elsif min && max
+            ["(#{@column} BETWEEN ? AND ?)", min, max]
+          elsif min
+            ["(#{@column} >= ?)", min]
+          elsif max
+            ["(#{@column} <= ?)", max]
+          end
+        end
+
+        def build_statement_for_type
+          case @type
+          when :boolean                   then build_statement_for_boolean
+          when :integer, :decimal, :float then build_statement_for_integer_decimal_or_float
+          when :string, :text, :citext    then build_statement_for_string_or_text
+          when :enum                      then build_statement_for_enum
+          when :belongs_to_association    then build_statement_for_belongs_to_association
+          when :uuid                      then build_statement_for_uuid
+          end
+        end
+
+        def build_statement_for_boolean
+          case @value
+          when 'false', 'f', '0'
+            ["(#{@column} IS NULL OR #{@column} = ?)", false]
+          when 'true', 't', '1'
+            ["(#{@column} = ?)", true]
+          end
+        end
+
+        def column_for_value(value)
+          ["(#{@column} = ?)", value]
+        end
+
+        def build_statement_for_belongs_to_association
+          return if @value.blank?
+
+          ["(#{@column} = ?)", @value.to_i] if @value.to_i.to_s == @value
+        end
+
+        def build_statement_for_string_or_text
+          return if @value.blank?
+
+          return ["(#{@column} = ?)", @value] if ['is', '='].include?(@operator)
+
+          @value = @value.downcase unless %w[postgresql postgis].include? ar_adapter
+
+          @value =
+            case @operator
+            when 'default', 'like', 'not_like'
+              "%#{@value}%"
+            when 'starts_with'
+              "#{@value}%"
+            when 'ends_with'
+              "%#{@value}"
+            else
+              return
+            end
+
+          if %w[postgresql postgis].include? ar_adapter
+            if @operator == 'not_like'
+              ["(#{@column} NOT ILIKE ?)", @value]
+            else
+              ["(#{@column} ILIKE ?)", @value]
+            end
+          elsif @operator == 'not_like'
+            ["(LOWER(#{@column}) NOT LIKE ?)", @value]
+          else
+            ["(LOWER(#{@column}) LIKE ?)", @value]
+          end
+        end
+
+        def build_statement_for_enum
+          return if @value.blank?
+
+          ["(#{@column} IN (?))", Array.wrap(@value)]
+        end
+
+        def build_statement_for_uuid
+          column_for_value(@value) if /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/.match?(@value.to_s)
+        end
+
+        def ar_adapter
+          @adapter_name.downcase
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      # Collects the conditions a search or a filter produced into one relation.
+      #
+      # Statements are OR-ed together and the tables their columns belong to are
+      # collected, so that the relation can be told to reference them and the
+      # joins actually happen.
+      class WhereBuilder
+        def initialize(scope, repository)
+          @statements = []
+          @values = []
+          @tables = []
+          @scope = scope
+          @repository = repository
+        end
+
+        def add(field, value, operator)
+          field.searchable_columns.flatten.each do |column_infos|
+            column = @repository.search_column(column_infos[:column])
+            statement, value1, value2 = StatementBuilder.new(column, column_infos[:type], value, operator, @scope.connection.adapter_name).to_statement
+            @statements << statement if statement.present?
+            @values << value1 unless value1.nil?
+            @values << value2 unless value2.nil?
+            table, qualified = column.split('.')
+            @tables.push(table) if qualified
+          end
+        end
+
+        def build
+          scope = @scope.where(@statements.join(' OR '), *@values)
+          scope = scope.references(*@tables.uniq) if @tables.any?
+          scope
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -1,367 +1,18 @@
 # frozen_string_literal: true
 
 require 'active_record'
-require 'rails_admin/adapters/active_record/association'
-require 'rails_admin/adapters/active_record/object_extension'
-require 'rails_admin/adapters/active_record/property'
 
 module RailsAdmin
   module Adapters
     module ActiveRecord
       DISABLED_COLUMN_TYPES = %i[tsvector blob binary spatial hstore geometry].freeze
-
-      def new(params = {})
-        model.new(params).extend(ObjectExtension)
-      end
-
-      def get(id, scope = scoped)
-        object = primary_key_scope(scope, id).first
-        return unless object
-
-        object.extend(ObjectExtension)
-      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
-
-      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 format_id(id)
-        if primary_key.is_a? Array
-          RailsAdmin.config.composite_keys_serializer.serialize(id)
-        else
-          id
-        end
-      end
-
-      def parse_id(id)
-        if primary_key.is_a?(Array)
-          ids = RailsAdmin.config.composite_keys_serializer.deserialize(id)
-          primary_key.each_with_index do |key, i|
-            ids[i] = model.type_for_attribute(key).cast(ids[i])
-          end
-          ids
-        else
-          id
-        end
-      end
-
-    private
-
-      def primary_key_scope(scope, id)
-        if primary_key.is_a? Array
-          scope.where(primary_key.zip(parse_id(id)).to_h)
-        else
-          scope.where(primary_key => id)
-        end
-      end
-
-      def bulk_scope(scope, options)
-        if primary_key.is_a? Array
-          options[:bulk_ids].map { |id| primary_key_scope(scope, id) }.reduce(&:or)
-        else
-          scope.where(primary_key => options[:bulk_ids])
-        end
-      end
-
-      def sort_scope(scope, options)
-        direction = options[:sort_reverse] ? :asc : :desc
-        case options[:sort]
-        when String, Symbol
-          scope.reorder("#{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
-
-      class WhereBuilder
-        def initialize(scope)
-          @statements = []
-          @values = []
-          @tables = []
-          @scope = scope
-        end
-
-        def add(field, value, operator)
-          field.searchable_columns.flatten.each do |column_infos|
-            statement, value1, value2 = StatementBuilder.new(column_infos[:column], column_infos[:type], value, operator, @scope.connection.adapter_name).to_statement
-            @statements << statement if statement.present?
-            @values << value1 unless value1.nil?
-            @values << value2 unless value2.nil?
-            table, column = column_infos[:column].split('.')
-            @tables.push(table) if column
-          end
-        end
-
-        def build
-          scope = @scope.where(@statements.join(' OR '), *@values)
-          scope = scope.references(*@tables.uniq) if @tables.any?
-          scope
-        end
-      end
-
-      def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
-        if config.list.search_by
-          scope.send(config.list.search_by, query)
-        else
-          wb = WhereBuilder.new(scope)
-          fields.each do |field|
-            value = parse_field_value(field, query)
-            wb.add(field, value, field.search_operator)
-          end
-          # OR all query statements
-          wb.build
-        end
-      end
-
-      # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
-      # "0055" is the filter index, no use here. o is the operator, v the value
-      def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
-        filters.each_pair do |field_name, filters_dump|
-          filters_dump.each_value do |filter_dump|
-            wb = WhereBuilder.new(scope)
-            field = fields.detect { |f| f.name.to_s == field_name }
-            value = parse_field_value(field, filter_dump[:v])
-
-            wb.add(field, value, (filter_dump[:o] || RailsAdmin::Config.default_search_operator))
-            # AND current filter statements to other filter statements
-            scope = wb.build
-          end
-        end
-        scope
-      end
-
-      def build_statement(column, type, value, operator)
-        StatementBuilder.new(column, type, value, operator, model.connection.adapter_name).to_statement
-      end
-
-      class StatementBuilder < RailsAdmin::AbstractModel::StatementBuilder
-        def initialize(column, type, value, operator, adapter_name)
-          super column, type, value, operator
-          @adapter_name = adapter_name
-        end
-
-      protected
-
-        def unary_operators
-          case @type
-          when :boolean
-            boolean_unary_operators
-          when :uuid
-            uuid_unary_operators
-          when :integer, :decimal, :float
-            numeric_unary_operators
-          else
-            generic_unary_operators
-          end
-        end
-
-      private
-
-        def generic_unary_operators
-          {
-            '_blank' => ["(#{@column} IS NULL OR #{@column} = '')"],
-            '_present' => ["(#{@column} IS NOT NULL AND #{@column} != '')"],
-            '_null' => ["(#{@column} IS NULL)"],
-            '_not_null' => ["(#{@column} IS NOT NULL)"],
-            '_empty' => ["(#{@column} = '')"],
-            '_not_empty' => ["(#{@column} != '')"],
-          }
-        end
-
-        def boolean_unary_operators
-          generic_unary_operators.merge(
-            '_blank' => ["(#{@column} IS NULL)"],
-            '_empty' => ["(#{@column} IS NULL)"],
-            '_present' => ["(#{@column} IS NOT NULL)"],
-            '_not_empty' => ["(#{@column} IS NOT NULL)"],
-          )
-        end
-        alias_method :numeric_unary_operators, :boolean_unary_operators
-        alias_method :uuid_unary_operators, :boolean_unary_operators
-
-        def range_filter(min, max)
-          if min && max && min == max
-            ["(#{@column} = ?)", min]
-          elsif min && max
-            ["(#{@column} BETWEEN ? AND ?)", min, max]
-          elsif min
-            ["(#{@column} >= ?)", min]
-          elsif max
-            ["(#{@column} <= ?)", max]
-          end
-        end
-
-        def build_statement_for_type
-          case @type
-          when :boolean                   then build_statement_for_boolean
-          when :integer, :decimal, :float then build_statement_for_integer_decimal_or_float
-          when :string, :text, :citext    then build_statement_for_string_or_text
-          when :enum                      then build_statement_for_enum
-          when :belongs_to_association    then build_statement_for_belongs_to_association
-          when :uuid                      then build_statement_for_uuid
-          end
-        end
-
-        def build_statement_for_boolean
-          case @value
-          when 'false', 'f', '0'
-            ["(#{@column} IS NULL OR #{@column} = ?)", false]
-          when 'true', 't', '1'
-            ["(#{@column} = ?)", true]
-          end
-        end
-
-        def column_for_value(value)
-          ["(#{@column} = ?)", value]
-        end
-
-        def build_statement_for_belongs_to_association
-          return if @value.blank?
-
-          ["(#{@column} = ?)", @value.to_i] if @value.to_i.to_s == @value
-        end
-
-        def build_statement_for_string_or_text
-          return if @value.blank?
-
-          return ["(#{@column} = ?)", @value] if ['is', '='].include?(@operator)
-
-          @value = @value.mb_chars.downcase unless %w[postgresql postgis].include? ar_adapter
-
-          @value =
-            case @operator
-            when 'default', 'like', 'not_like'
-              "%#{@value}%"
-            when 'starts_with'
-              "#{@value}%"
-            when 'ends_with'
-              "%#{@value}"
-            else
-              return
-            end
-
-          if %w[postgresql postgis].include? ar_adapter
-            if @operator == 'not_like'
-              ["(#{@column} NOT ILIKE ?)", @value]
-            else
-              ["(#{@column} ILIKE ?)", @value]
-            end
-          elsif @operator == 'not_like'
-            ["(LOWER(#{@column}) NOT LIKE ?)", @value]
-          else
-            ["(LOWER(#{@column}) LIKE ?)", @value]
-          end
-        end
-
-        def build_statement_for_enum
-          return if @value.blank?
-
-          ["(#{@column} IN (?))", Array.wrap(@value)]
-        end
-
-        def build_statement_for_uuid
-          column_for_value(@value) if /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/.match?(@value.to_s)
-        end
-
-        def ar_adapter
-          @adapter_name.downcase
-        end
-      end
     end
   end
 end
+
+require 'rails_admin/adapters/active_record/association'
+require 'rails_admin/adapters/active_record/property'
+require 'rails_admin/adapters/active_record/reflection'
+require 'rails_admin/adapters/active_record/repository'
+require 'rails_admin/adapters/active_record/statement_builder'
+require 'rails_admin/adapters/active_record/where_builder'

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

@@ -111,7 +111,7 @@ module RailsAdmin
         end
 
         def inverse_of
-          association.inverse_of.try :to_sym
+          association.inverse_of.try(:to_sym) || as
         end
 
         def read_only?

data/lib/rails_admin/adapters/mongoid/extension.rb

@@ -19,11 +19,8 @@ module RailsAdmin
           end
         end
 
-        def rails_admin_default_object_label_method
-          new_record? ? "new #{self.class}" : "#{self.class} ##{id}"
-        end
-
         def safe_send(value)
+          RailsAdmin.deprecator.warn('#safe_send is deprecated, please use RailsAdmin::AbstractModel#read.')
           if attributes.detect { |k, _v| k.to_s == value.to_s }
             read_attribute(value)
           else
@@ -32,8 +29,21 @@ module RailsAdmin
         end
 
         module ClassMethods
-          # Mongoid accepts_nested_attributes_for does not store options in accessible scope,
-          # so we intercept the call and store it in instance variable which can be accessed from outside
+          # Keeps the options of accepts_nested_attributes_for, because Mongoid
+          # does not (checked against 9.1). It hands them to the block that
+          # defines the setter and keeps nothing: Model.nested_attributes only
+          # maps "xs_attributes" to its setter, and the association carries the
+          # autosave flag but nothing else.
+          #
+          # RailsAdmin needs allow_destroy to decide whether a nested form
+          # offers to remove an existing record. Guessing it wrong is not
+          # something anyone would notice: Mongoid takes _destroy out of the
+          # attributes before finding out it is not allowed to destroy, so the
+          # record is updated like any other and the row the user removed is
+          # simply still there after saving, with nothing raised.
+          #
+          # The defaults are ActiveRecord's own, so that nested_options has the
+          # same shape whichever adapter answered it.
           def accepts_nested_attributes_for_with_rails_admin(*args)
             options = args.extract_options!
             args.each do |arg|

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

@@ -65,6 +65,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/mongoid/reflection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails_admin/adapters/reflection'
+require 'rails_admin/adapters/mongoid/association'
+require 'rails_admin/adapters/mongoid/property'
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      class Reflection < RailsAdmin::Adapters::Reflection
+        def primary_key
+          '_id'
+        end
+
+        def associations
+          model.relations.values.collect do |association|
+            Association.new(association, model)
+          end
+        end
+
+        def properties
+          fields = model.fields.reject { |_name, field| DISABLED_COLUMN_TYPES.include?(field.type.to_s) }
+          fields.collect { |_name, field| Property.new(field, model) }
+        end
+
+        def base_class
+          klass = model
+          klass = klass.superclass while klass.hereditary?
+          klass
+        end
+
+        def table_name
+          model.collection_name.to_s
+        end
+
+        def encoding
+          Encoding::UTF_8
+        end
+
+        def embedded?
+          associations.detect { |a| a.macro == :embedded_in }
+        end
+
+        def cyclic?
+          model.cyclic?
+        end
+
+        def adapter_supports_joins?
+          false
+        end
+
+        def belongs_to_required_by_default
+          ::Mongoid.belongs_to_required_by_default
+        end
+      end
+    end
+  end
+end