rails_admin 1.4.2 → 3.1.2

data/lib/rails_admin/adapters/active_record.rb

@@ -1,20 +1,24 @@
+# frozen_string_literal: true
+
 require 'active_record'
-require 'rails_admin/adapters/active_record/abstract_object'
 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 = [:tsvector, :blob, :binary, :spatial, :hstore, :geometry].freeze
+      DISABLED_COLUMN_TYPES = %i[tsvector blob binary spatial hstore geometry].freeze
 
       def new(params = {})
-        AbstractObject.new(model.new(params))
+        model.new(params).extend(ObjectExtension)
       end
 
-      def get(id)
-        return unless object = model.where(primary_key => id).first
-        AbstractObject.new object
+      def get(id, scope = scoped)
+        object = scope.where(primary_key => id).first
+        return unless object
+
+        object.extend(ObjectExtension)
       end
 
       def scoped
@@ -29,13 +33,11 @@ module RailsAdmin
         scope ||= scoped
         scope = scope.includes(options[:include]) if options[:include]
         scope = scope.limit(options[:limit]) if options[:limit]
-        scope = scope.where(primary_key => options[:bulk_ids]) if options[:bulk_ids]
+        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]
-        if options[:page] && options[:per]
-          scope = scope.send(Kaminari.config.page_method_name, options[:page]).per(options[:per])
-        end
-        scope = scope.reorder("#{options[:sort]} #{options[:sort_reverse] ? 'asc' : 'desc'}") if options[:sort]
+        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
 
@@ -64,16 +66,30 @@ module RailsAdmin
         end
       end
 
+      def base_class
+        model.base_class
+      end
+
       delegate :primary_key, :table_name, to: :model, prefix: false
 
       def encoding
-        case ::ActiveRecord::Base.connection_config[:adapter]
+        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'
-          ::ActiveRecord::Base.connection.instance_variable_get(:@connection).encoding
+          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
+          ::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
@@ -91,6 +107,27 @@ module RailsAdmin
         true
       end
 
+    private
+
+      def bulk_scope(scope, options)
+        scope.where(primary_key => options[:bulk_ids])
+      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 = []
@@ -101,7 +138,7 @@ module RailsAdmin
 
         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).to_statement
+            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?
@@ -118,13 +155,17 @@ module RailsAdmin
       end
 
       def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
-        wb = WhereBuilder.new(scope)
-        fields.each do |field|
-          value = parse_field_value(field, query)
-          wb.add(field, value, field.search_operator)
+        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
-        # OR all query statements
-        wb.build
       end
 
       # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
@@ -136,7 +177,7 @@ module RailsAdmin
             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] || 'default'))
+            wb.add(field, value, (filter_dump[:o] || RailsAdmin::Config.default_search_operator))
             # AND current filter statements to other filter statements
             scope = wb.build
           end
@@ -145,10 +186,15 @@ module RailsAdmin
       end
 
       def build_statement(column, type, value, operator)
-        StatementBuilder.new(column, type, value, operator).to_statement
+        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
@@ -186,7 +232,9 @@ module RailsAdmin
         alias_method :numeric_unary_operators, :boolean_unary_operators
 
         def range_filter(min, max)
-          if min && max
+          if min && max && min == max
+            ["(#{@column} = ?)", min]
+          elsif min && max
             ["(#{@column} BETWEEN ? AND ?)", min, max]
           elsif min
             ["(#{@column} >= ?)", min]
@@ -199,7 +247,7 @@ module RailsAdmin
           case @type
           when :boolean                   then build_statement_for_boolean
           when :integer, :decimal, :float then build_statement_for_integer_decimal_or_float
-          when :string, :text             then build_statement_for_string_or_text
+          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
@@ -207,8 +255,8 @@ module RailsAdmin
         end
 
         def build_statement_for_boolean
-          return ["(#{@column} IS NULL OR #{@column} = ?)", false] if %w(false f 0).include?(@value)
-          return ["(#{@column} = ?)", true] if %w(true t 1).include?(@value)
+          return ["(#{@column} IS NULL OR #{@column} = ?)", false] if %w[false f 0].include?(@value)
+          return ["(#{@column} = ?)", true] if %w[true t 1].include?(@value)
         end
 
         def column_for_value(value)
@@ -217,33 +265,37 @@ module RailsAdmin
 
         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?
 
-          unless ['postgresql', 'postgis'].include? ar_adapter
-            @value = @value.mb_chars.downcase
-          end
+          return ["(#{@column} = ?)", @value] if ['is', '='].include?(@operator)
+
+          @value = @value.mb_chars.downcase unless %w[postgresql postgis].include? ar_adapter
 
-          @value = begin
+          @value =
             case @operator
-            when 'default', 'like'
+            when 'default', 'like', 'not_like'
               "%#{@value}%"
             when 'starts_with'
               "#{@value}%"
             when 'ends_with'
               "%#{@value}"
-            when 'is', '='
-              @value
             else
               return
             end
-          end
 
-          if ['postgresql', 'postgis'].include? ar_adapter
-            ["(#{@column} ILIKE ?)", @value]
+          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
@@ -251,17 +303,16 @@ module RailsAdmin
 
         def build_statement_for_enum
           return if @value.blank?
+
           ["(#{@column} IN (?))", Array.wrap(@value)]
         end
 
         def build_statement_for_uuid
-          if @value.to_s =~ /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/
-            column_for_value(@value)
-          end
+          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
-          ::ActiveRecord::Base.connection.adapter_name.downcase
+          @adapter_name.downcase
         end
       end
     end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module CompositePrimaryKeys
+      class Association < RailsAdmin::Adapters::ActiveRecord::Association
+        def field_type
+          if type == :belongs_to && association.foreign_key.is_a?(Array)
+            :composite_keys_belongs_to_association
+          else
+            super
+          end
+        end
+
+        def primary_key
+          return nil if polymorphic?
+
+          value = association.association_primary_key
+
+          if value.is_a? Array
+            :id
+          else
+            value.to_sym
+          end
+        end
+
+        def foreign_key
+          if association.foreign_key.is_a? Array
+            association.foreign_key.map(&:to_sym)
+          else
+            super
+          end
+        end
+
+        def key_accessor
+          if type == :belongs_to && foreign_key.is_a?(Array)
+            :"#{name}_id"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/composite_primary_keys.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_admin/adapters/active_record'
+require 'rails_admin/adapters/composite_primary_keys/association'
+
+module RailsAdmin
+  module Adapters
+    module CompositePrimaryKeys
+      include RailsAdmin::Adapters::ActiveRecord
+
+      def get(id, scope = scoped)
+        begin
+          object = scope.find(id)
+        rescue ::ActiveRecord::RecordNotFound
+          return nil
+        end
+
+        object.extend(RailsAdmin::Adapters::ActiveRecord::ObjectExtension)
+      end
+
+      def associations
+        model.reflect_on_all_associations.collect do |association|
+          RailsAdmin::Adapters::CompositePrimaryKeys::Association.new(association, model)
+        end
+      end
+
+    private
+
+      def bulk_scope(scope, options)
+        if primary_key.is_a? Array
+          options[:bulk_ids].map do |id|
+            scope.where(primary_key.zip(::CompositePrimaryKeys::CompositeKeys.parse(id)).to_h)
+          end.reduce(&:or)
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module RailsAdmin
   module Adapters
     module Mongoid
       class Association
         attr_reader :association, :model
 
+        delegate :autosave?, to: :association
+
         def initialize(association, model)
           @association = association
           @model = model
@@ -28,12 +32,20 @@ module RailsAdmin
           when :has_and_belongs_to_many, :references_and_referenced_in_many
             :has_and_belongs_to_many
           else
-            raise("Unknown association type: #{macro.inspect}")
+            raise "Unknown association type: #{macro.inspect}"
+          end
+        end
+
+        def field_type
+          if polymorphic?
+            :polymorphic_association
+          else
+            :"#{type}_association"
           end
         end
 
         def klass
-          if polymorphic? && [:referenced_in, :belongs_to].include?(macro)
+          if polymorphic? && %i[referenced_in belongs_to].include?(macro)
             polymorphic_parents(:mongoid, model.name, name) || []
           else
             association.klass
@@ -41,35 +53,61 @@ module RailsAdmin
         end
 
         def primary_key
-          :_id
+          case type
+          when :belongs_to, :has_and_belongs_to_many
+            association.primary_key.to_sym
+          else
+            :_id
+          end
         end
 
         def foreign_key
           return if embeds?
-          association.foreign_key.to_sym rescue nil
+
+          begin
+            association.foreign_key.to_sym
+          rescue StandardError
+            nil
+          end
         end
 
         def foreign_key_nullable?
           return if foreign_key.nil?
+
           true
         end
 
         def foreign_type
-          return unless polymorphic? && [:referenced_in, :belongs_to].include?(macro)
+          return unless polymorphic? && %i[referenced_in belongs_to].include?(macro)
+
           association.inverse_type.try(:to_sym) || :"#{name}_type"
         end
 
         def foreign_inverse_of
-          return unless polymorphic? && [:referenced_in, :belongs_to].include?(macro)
+          return unless polymorphic? && %i[referenced_in belongs_to].include?(macro)
+
           inverse_of_field.try(:to_sym)
         end
 
+        def key_accessor
+          case macro.to_sym
+          when :has_many
+            "#{name.to_s.singularize}_ids".to_sym
+          when :has_one
+            "#{name}_id".to_sym
+          when :embedded_in, :embeds_one, :embeds_many
+            nil
+          else
+            foreign_key
+          end
+        end
+
         def as
           association.as.try :to_sym
         end
 
         def polymorphic?
-          association.polymorphic? && [:referenced_in, :belongs_to].include?(macro)
+          association.polymorphic? && %i[referenced_in belongs_to].include?(macro)
         end
 
         def inverse_of
@@ -82,13 +120,14 @@ module RailsAdmin
 
         def nested_options
           nested = nested_attributes_options.try { |o| o[name] }
-          if !nested && [:embeds_one, :embeds_many].include?(macro.to_sym) && !cyclic?
-            raise <<-MSG.gsub(/^\s+/, '')
-            Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,
-            because embedded model doesn't have top-level access.
-            Please add `accepts_nested_attributes_for :#{association.name}' line to `#{model}' model.
+          if !nested && %i[embeds_one embeds_many].include?(macro.to_sym) && !cyclic?
+            raise <<~MSG
+              Embedded association without accepts_nested_attributes_for can't be handled by RailsAdmin,
+              because embedded model doesn't have top-level access.
+              Please add `accepts_nested_attributes_for :#{association.name}' line to `#{model}' model.
             MSG
           end
+
           nested
         end
 
@@ -101,7 +140,7 @@ module RailsAdmin
         end
 
         def embeds?
-          [:embeds_one, :embeds_many].include?(macro)
+          %i[embeds_one embeds_many].include?(macro)
         end
 
       private

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

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 require 'mongoid'
 
 module RailsAdmin
   module Adapters
     module Mongoid
       class Bson
-        OBJECT_ID = begin
+        OBJECT_ID =
           if defined?(Moped::BSON)
             Moped::BSON::ObjectId
           elsif defined?(BSON::ObjectId)
             BSON::ObjectId
           end
-        end
 
         class << self
           def parse_object_id(value)
             OBJECT_ID.from_string(value)
-          rescue => e
-            raise e if %w(
+          rescue StandardError => e
+            raise e if %w[
               Moped::Errors::InvalidObjectId
               BSON::ObjectId::Invalid
               BSON::InvalidObjectId
-            ).exclude?(e.class.to_s)
+            ].exclude?(e.class.to_s)
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsAdmin
   module Adapters
     module Mongoid

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      module ObjectExtension
+        def self.extended(object)
+          object.associations.each do |name, association|
+            association = Association.new(association, object.class)
+            case association.macro
+            when :has_many
+              unless association.autosave?
+                object.singleton_class.after_create do
+                  send(name).each(&:save)
+                end
+              end
+            when :has_one
+              unless association.autosave?
+                object.singleton_class.after_create do
+                  send(name)&.save
+                end
+              end
+              object.instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}_id=(item_id)
+                  self.#{name} = (#{association.klass}.find(item_id) rescue nil)
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module RailsAdmin
   module Adapters
     module Mongoid
       class Property
-        STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject].freeze
+        STRING_TYPE_COLUMN_NAMES = %i[name title subject].freeze
         attr_reader :property, :model
 
         def initialize(property, model)
@@ -11,11 +13,11 @@ module RailsAdmin
         end
 
         def name
-          property.name.to_sym
+          (property.options[:as] || property.name).to_sym
         end
 
         def pretty_name
-          property.name.to_s.tr('_', ' ').capitalize
+          (property.options[:as] || property.name).to_s.tr('_', ' ').capitalize
         end
 
         def type
@@ -64,14 +66,14 @@ module RailsAdmin
         end
 
         def read_only?
-          false
+          model.readonly_attributes.include? property.name.to_s
         end
 
       private
 
         def object_field_type
           association = Association.new model.relations.values.detect { |r| r.try(:foreign_key).try(:to_sym) == name }, model
-          if [:belongs_to, :referenced_in, :embedded_in].include?(association.macro)
+          if %i[belongs_to referenced_in embedded_in].include?(association.macro)
             :bson_object_id
           else
             :string