rails_admin 2.2.1 → 3.0.0.beta

data/lib/rails_admin/abstract_model.rb

@@ -19,7 +19,7 @@ module RailsAdmin
       def new(m)
         m = m.constantize unless m.is_a?(Class)
         (am = old_new(m)).model && am.adapter ? am : nil
-      rescue LoadError, NameError
+      rescue *([LoadError, NameError] + (defined?(ActiveRecord) ? ['ActiveRecord::NoDatabaseError'.constantize] : []))
         puts "[RailsAdmin] Could not load model #{m}, assuming model is non existing. (#{$ERROR_INFO})" unless Rails.env.test?
         nil
       end
@@ -124,6 +124,7 @@ module RailsAdmin
 
       def to_statement
         return if [@operator, @value].any? { |v| v == '_discard' }
+
         unary_operators[@operator] || unary_operators[@value] ||
           build_statement_for_type_generic
       end
@@ -139,21 +140,22 @@ module RailsAdmin
           case @type
           when :date
             build_statement_for_date
-          when :datetime, :timestamp
+          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')
+        raise 'You must override build_statement_for_type in your StatementBuilder'
       end
 
       def build_statement_for_integer_decimal_or_float
         case @value
-        when Array then
+        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
@@ -171,24 +173,36 @@ module RailsAdmin
 
       def build_statement_for_date
         start_date, end_date = get_filtering_duration
-        start_date = (start_date.to_date rescue nil) if start_date
-        end_date = (end_date.to_date rescue nil) if end_date
+        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.try(:beginning_of_day) if start_date
-        end_date = end_date.try(:end_of_day) if end_date
+        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')
+        raise 'You must override unary_operators in your StatementBuilder'
       end
 
       def range_filter(_min, _max)
-        raise('You must override range_filter in your StatementBuilder')
+        raise 'You must override range_filter in your StatementBuilder'
       end
 
       class FilteringDuration

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

@@ -30,7 +30,14 @@ module RailsAdmin
         end
 
         def primary_key
-          (options[:primary_key] || association.klass.primary_key).try(:to_sym) unless polymorphic?
+          return nil if polymorphic?
+
+          case type
+          when :has_one
+            association.klass.primary_key
+          else
+            association.association_primary_key
+          end.try(:to_sym)
         end
 
         def foreign_key
@@ -39,6 +46,7 @@ module RailsAdmin
 
         def foreign_key_nullable?
           return true if foreign_key.nil? || type != :has_many
+
           (column = klass.columns_hash[foreign_key.to_s]).nil? || column.null
         end
 
@@ -50,6 +58,17 @@ module RailsAdmin
           nil
         end
 
+        def key_accessor
+          case type
+          when :has_many, :has_and_belongs_to_many
+            "#{name.to_s.singularize}_ids".to_sym
+          when :has_one
+            "#{name}_id".to_sym
+          else
+            foreign_key
+          end
+        end
+
         def as
           options[:as].try :to_sym
         end

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

@@ -0,0 +1,29 @@
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      module ObjectExtension
+        def self.extended(object)
+          object.class.reflect_on_all_associations.each do |association|
+            association = Association.new(association, object.class)
+            case association.type
+            when :has_one
+              object.instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{association.name}_id
+                  self.#{association.name}&.id
+                end
+
+                def #{association.name}_id=(item_id)
+                  self.#{association.name} = #{association.klass}.find_by_id(item_id)
+                end
+              RUBY
+            end
+          end
+        end
+
+        def assign_attributes(attributes)
+          super if attributes
+        end
+      end
+    end
+  end
+end

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

@@ -48,7 +48,7 @@ module RailsAdmin
       private
 
         def serialized?
-          model.type_for_attribute(property.name).class == ::ActiveRecord::Type::Serialized
+          model.type_for_attribute(property.name).instance_of?(::ActiveRecord::Type::Serialized)
         end
       end
     end

data/lib/rails_admin/adapters/active_record.rb

@@ -1,20 +1,21 @@
 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
+
+        object.extend(ObjectExtension)
       end
 
       def scoped
@@ -32,9 +33,7 @@ module RailsAdmin
         scope = scope.where(primary_key => options[:bulk_ids]) 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.send(Kaminari.config.page_method_name, options[:page]).per(options[:per]) if options[:page] && options[:per]
         scope = scope.reorder("#{options[:sort]} #{options[:sort_reverse] ? 'asc' : 'desc'}") if options[:sort]
         scope
       end
@@ -83,7 +82,7 @@ module RailsAdmin
         when 'mysql2'
           ::ActiveRecord::Base.connection.raw_connection.encoding
         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
@@ -205,7 +204,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]
@@ -218,7 +219,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
@@ -226,8 +227,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)
@@ -236,6 +237,7 @@ 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
 
@@ -244,13 +246,11 @@ module RailsAdmin
 
           return ["(#{@column} = ?)", @value] if ['is', '='].include?(@operator)
 
-          unless ['postgresql', 'postgis'].include? ar_adapter
-            @value = @value.mb_chars.downcase
-          end
+          @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}%"
@@ -259,10 +259,15 @@ module RailsAdmin
             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
@@ -270,13 +275,12 @@ 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

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

@@ -4,6 +4,8 @@ module RailsAdmin
       class Association
         attr_reader :association, :model
 
+        delegate :autosave?, to: :association
+
         def initialize(association, model)
           @association = association
           @model = model
@@ -28,12 +30,12 @@ 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 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 +43,61 @@ module RailsAdmin
         end
 
         def primary_key
-          association.primary_key.to_sym rescue :_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 +110,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?
+          if !nested && %i[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.
             MSG
           end
+
           nested
         end
 
@@ -101,7 +130,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

@@ -4,23 +4,22 @@ 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

@@ -9,7 +9,9 @@ module RailsAdmin
           self.nested_attributes_options = {}
           class << self
             def rails_admin(&block)
-              RailsAdmin.config(self, &block)
+              RailsAdmin.config do |config|
+                config.model(self, &block)
+              end
             end
 
             alias_method :accepts_nested_attributes_for_without_rails_admin, :accepts_nested_attributes_for

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

@@ -0,0 +1,32 @@
+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

@@ -2,7 +2,7 @@ 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)
@@ -71,7 +71,7 @@ module RailsAdmin
 
         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

data/lib/rails_admin/adapters/mongoid.rb

@@ -1,32 +1,35 @@
 require 'mongoid'
 require 'rails_admin/config/sections/list'
-require 'rails_admin/adapters/mongoid/abstract_object'
 require 'rails_admin/adapters/mongoid/association'
+require 'rails_admin/adapters/mongoid/object_extension'
 require 'rails_admin/adapters/mongoid/property'
 require 'rails_admin/adapters/mongoid/bson'
 
 module RailsAdmin
   module Adapters
     module Mongoid
-      DISABLED_COLUMN_TYPES = %w(Range Moped::BSON::Binary BSON::Binary Mongoid::Geospatial::Point).freeze
+      DISABLED_COLUMN_TYPES = %w[Range Moped::BSON::Binary BSON::Binary Mongoid::Geospatial::Point].freeze
 
       def parse_object_id(value)
         Bson.parse_object_id(value)
       end
 
       def new(params = {})
-        AbstractObject.new(model.new(params))
+        model.new(params).extend(ObjectExtension)
       end
 
       def get(id)
-        AbstractObject.new(model.find(id))
-      rescue => e
-        raise e if %w(
+        object = model.find(id)
+        return nil unless object
+
+        object.extend(ObjectExtension)
+      rescue StandardError => e
+        raise e if %w[
           Mongoid::Errors::DocumentNotFound
           Mongoid::Errors::InvalidFind
           Moped::Errors::InvalidObjectId
           BSON::InvalidObjectId
-        ).exclude?(e.class.to_s)
+        ].exclude?(e.class.to_s)
       end
 
       def scoped
@@ -44,13 +47,11 @@ module RailsAdmin
         scope = scope.any_in(_id: options[:bulk_ids]) 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.send(Kaminari.config.page_method_name, options[:page]).per(options[:per]) if options[:page] && options[:per]
         scope = sort_by(options, scope) if options[:sort]
         scope
       rescue NoMethodError => e
-        if e.message =~ /page/
+        if /page/.match?(e.message)
           e = e.exception <<-EOM.gsub(/^\s{12}/, '')
             #{e.message}
             If you don't have kaminari-mongoid installed, add `gem 'kaminari-mongoid'` to your Gemfile.
@@ -120,6 +121,7 @@ module RailsAdmin
           collection_name, column_name = parse_collection_name(column_infos[:column])
           statement = build_statement(column_name, column_infos[:type], value, operator)
           next unless statement
+
           conditions_per_collection[collection_name] ||= []
           conditions_per_collection[collection_name] << statement
         end
@@ -151,6 +153,7 @@ module RailsAdmin
           filters_dump.each do |_, filter_dump|
             field = fields.detect { |f| f.name.to_s == field_name }
             next unless field
+
             value = parse_field_value(field, filter_dump[:v])
             conditions_per_collection = make_field_conditions(field, value, (filter_dump[:o] || 'default'))
             field_statements = make_condition_for_current_collection(field, conditions_per_collection)
@@ -191,6 +194,7 @@ module RailsAdmin
       def perform_search_on_associated_collection(field_name, conditions)
         target_association = associations.detect { |a| a.name == field_name }
         return [] unless target_association
+
         model = target_association.klass
         case target_association.type
         when :belongs_to, :has_and_belongs_to_many
@@ -206,9 +210,7 @@ module RailsAdmin
         case options[:sort]
         when String
           field_name, collection_name = options[:sort].split('.').reverse
-          if collection_name && collection_name != table_name
-            raise('sorting by associated model column is not supported in Non-Relational databases')
-          end
+          raise 'sorting by associated model column is not supported in Non-Relational databases' if collection_name && collection_name != table_name
         when Symbol
           field_name = options[:sort].to_s
         end
@@ -246,8 +248,8 @@ module RailsAdmin
         end
 
         def build_statement_for_boolean
-          return {@column => false} if %w(false f 0).include?(@value)
-          return {@column => true} if %w(true t 1).include?(@value)
+          return {@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)
@@ -256,8 +258,11 @@ module RailsAdmin
 
         def build_statement_for_string_or_text
           return if @value.blank?
-          @value = begin
+
+          @value =
             case @operator
+            when 'not_like'
+              Regexp.compile("^((?!#{Regexp.escape(@value)}).)*$", Regexp::IGNORECASE)
             when 'default', 'like'
               Regexp.compile(Regexp.escape(@value), Regexp::IGNORECASE)
             when 'starts_with'
@@ -269,12 +274,13 @@ module RailsAdmin
             else
               return
             end
-          end
+
           {@column => @value}
         end
 
         def build_statement_for_enum
           return if @value.blank?
+
           {@column => {'$in' => Array.wrap(@value)}}
         end
 
@@ -283,7 +289,9 @@ module RailsAdmin
         end
 
         def range_filter(min, max)
-          if min && max
+          if min && max && min == max
+            {@column => min}
+          elsif min && max
             {@column => {'$gte' => min, '$lte' => max}}
           elsif min
             {@column => {'$gte' => min}}

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

@@ -36,7 +36,7 @@ module RailsAdmin
 
         # http://getbootstrap.com/2.3.2/base-css.html#icons
         register_instance_option :link_icon do
-          'icon-question-sign'
+          'fas fa-question'
         end
 
         # Should the action be visible
@@ -75,7 +75,12 @@ module RailsAdmin
 
         # Render via pjax?
         register_instance_option :pjax? do
-          true
+          link_target.blank?
+        end
+
+        # Target window [_self, _blank]
+        register_instance_option :link_target do
+          nil
         end
 
         # This block is evaluated in the context of the controller when action is called