rails_admin 0.6.0 → 0.6.1

data/lib/rails_admin/adapters/active_record.rb

@@ -26,7 +26,7 @@ module RailsAdmin
       end
 
       def all(options = {}, scope = nil)
-        scope ||= self.scoped
+        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]
@@ -40,15 +40,15 @@ module RailsAdmin
       end
 
       def count(options = {}, scope = nil)
-        all(options.merge({:limit => false, :page => false}), scope).count
+        all(options.merge(limit: false, page: false), scope).count
       end
 
       def destroy(objects)
-        Array.wrap(objects).each &:destroy
+        Array.wrap(objects).each(&:destroy)
       end
 
       def associations
-        model.reflect_on_all_associations.map do |association|
+        model.reflect_on_all_associations.collect do |association|
           Association.new(association, model).to_options_hash
         end
       end
@@ -57,9 +57,9 @@ module RailsAdmin
         columns = model.columns.reject do |c|
           c.type.blank? ||
             DISABLED_COLUMN_TYPES.include?(c.type.to_sym) ||
-            DISABLED_COLUMN_MATCHERS.any? {|matcher| matcher.match(c.type.to_s)}
+            DISABLED_COLUMN_MATCHERS.any? { |matcher| matcher.match(c.type.to_s) }
         end
-        columns.map do |property|
+        columns.collect do |property|
           {
             :name => property.name.to_sym,
             :pretty_name => property.name.to_s.tr('_', ' ').capitalize,
@@ -70,7 +70,7 @@ module RailsAdmin
         end
       end
 
-      delegate :primary_key, :table_name, :to => :model, :prefix => false
+      delegate :primary_key, :table_name, to: :model, prefix: false
 
       def encoding
         Rails.configuration.database_configuration[Rails.env]['encoding']
@@ -88,10 +88,9 @@ module RailsAdmin
         true
       end
 
-      private
+    private
 
       class WhereBuilder
-
         def initialize(scope)
           @statements = []
           @values = []
@@ -130,7 +129,7 @@ module RailsAdmin
         filters.each_pair do |field_name, filters_dump|
           filters_dump.each do |_, filter_dump|
             wb = WhereBuilder.new(scope)
-            wb.add(fields.find{|f| f.name.to_s == field_name}, filter_dump[:v], (filter_dump[:o] || 'default'))
+            wb.add(fields.detect { |f| f.name.to_s == field_name }, filter_dump[:v], (filter_dump[:o] || 'default'))
             # AND current filter statements to other filter statements
             scope = wb.build
           end
@@ -144,9 +143,9 @@ module RailsAdmin
 
       def type_lookup(property)
         if model.serialized_attributes[property.name.to_s]
-          {:type => :serialized}
+          {type: :serialized}
         else
-          {:type => property.type}
+          {type: property.type}
         end
       end
 
@@ -160,22 +159,23 @@ module RailsAdmin
 
         def to_options_hash
           {
-            :name => name.to_sym,
-            :pretty_name => display_name,
-            :type => macro,
-            :model_proc => Proc.new { model_lookup },
-            :primary_key_proc => Proc.new { primary_key_lookup },
-            :foreign_key => foreign_key.to_sym,
-            :foreign_type => foreign_type_lookup,
-            :as => as_lookup,
-            :polymorphic => polymorphic_lookup,
-            :inverse_of => inverse_of_lookup,
-            :read_only => read_only_lookup,
-            :nested_form => nested_attributes_options_lookup
+            name: name.to_sym,
+            pretty_name: display_name,
+            type: macro,
+            model_proc: proc { model_lookup },
+            primary_key_proc: proc { primary_key_lookup },
+            foreign_key: foreign_key.to_sym,
+            foreign_type: foreign_type_lookup,
+            as: as_lookup,
+            polymorphic: polymorphic_lookup,
+            inverse_of: inverse_of_lookup,
+            read_only: read_only_lookup,
+            nested_form: nested_attributes_options_lookup
           }
         end
 
-        private
+      private
+
         def model_lookup
           if options[:polymorphic]
             polymorphic_parents(:active_record, model_name.to_s, name) || []
@@ -217,13 +217,13 @@ module RailsAdmin
         end
 
         delegate :klass, :macro, :name, :options, :scope, :foreign_key,
-                 :to => :association, :prefix => false
-        delegate :name, :to => :model, :prefix => true
-        delegate :polymorphic_parents, :to => RailsAdmin::AbstractModel
+                 to: :association, prefix: false
+        delegate :name, to: :model, prefix: true
+        delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
       end
 
       class StatementBuilder < RailsAdmin::AbstractModel::StatementBuilder
-        protected
+      protected
 
         def unary_operators
           {
@@ -236,7 +236,7 @@ module RailsAdmin
           }
         end
 
-        private
+      private
 
         def range_filter(min, max)
           if min && max
@@ -250,11 +250,11 @@ module RailsAdmin
 
         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             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 :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 :enum                      then build_statement_for_enum
+          when :belongs_to_association    then build_statement_for_belongs_to_association
           end
         end
 
@@ -299,7 +299,7 @@ module RailsAdmin
         end
 
         def like_operator
-          ar_adapter == "postgresql" ? 'ILIKE' : 'LIKE'
+          ar_adapter == 'postgresql' ? 'ILIKE' : 'LIKE'
         end
       end
     end

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

@@ -19,12 +19,12 @@ module RailsAdmin
           object.assign_attributes(attributes)
         end
 
-        def save(options = { :validate => true })
+        def save(options = {validate: true})
           object.save(options)
         end
 
         def method_missing(name, *args, &block)
-          self.object.send(name, *args, &block)
+          object.send(name, *args, &block)
         end
       end
     end

data/lib/rails_admin/adapters/mongoid.rb

@@ -6,40 +6,37 @@ module RailsAdmin
   module Adapters
     module Mongoid
       STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject]
-      DISABLED_COLUMN_TYPES = ['Range', 'Moped::BSON::Binary', "BSON::Binary"]
-      ObjectId = defined?(Moped::BSON) ? Moped::BSON::ObjectId : BSON::ObjectId
-
+      DISABLED_COLUMN_TYPES = ['Range', 'Moped::BSON::Binary', 'BSON::Binary', 'Mongoid::Geospatial::Point']
+      ObjectId = defined?(Moped::BSON) ? Moped::BSON::ObjectId : BSON::ObjectId # rubocop:disable ConstantName
 
       def new(params = {})
         AbstractObject.new(model.new)
       end
 
       def get(id)
-        begin
-          AbstractObject.new(model.find(id))
-        rescue => e
-          raise e if %w[
-            BSON::InvalidObjectId
-            Mongoid::Errors::DocumentNotFound
-            Mongoid::Errors::InvalidFind
-            Moped::Errors::InvalidObjectId
-          ].exclude?(e.class.to_s)
-        end
+        AbstractObject.new(model.find(id))
+      rescue => e
+        raise e if %w[
+          BSON::InvalidObjectId
+          Mongoid::Errors::DocumentNotFound
+          Mongoid::Errors::InvalidFind
+          Moped::Errors::InvalidObjectId
+        ].exclude?(e.class.to_s)
       end
 
       def scoped
         model.scoped
       end
 
-      def first(options = {},scope=nil)
+      def first(options = {}, scope = nil)
         all(options, scope).first
       end
 
-      def all(options = {},scope=nil)
-        scope ||= self.scoped
+      def all(options = {}, scope = nil)
+        scope ||= scoped
         scope = scope.includes(*options[:include]) if options[:include]
         scope = scope.limit(options[:limit]) if options[:limit]
-        scope = scope.any_in(:_id => options[:bulk_ids]) if options[:bulk_ids]
+        scope = scope.any_in(_id: options[:bulk_ids]) if options[:bulk_ids]
         scope = scope.where(query_conditions(options[:query])) if options[:query]
         scope = scope.where(filter_conditions(options[:filters])) if options[:filters]
         if options[:page] && options[:per]
@@ -49,12 +46,12 @@ module RailsAdmin
         scope
       end
 
-      def count(options = {},scope=nil)
-        all(options.merge({:limit => false, :page => false}), scope).count
+      def count(options = {}, scope = nil)
+        all(options.merge(limit: false, page: false), scope).count
       end
 
       def destroy(objects)
-        Array.wrap(objects).each &:destroy
+        Array.wrap(objects).each(&:destroy)
       end
 
       def primary_key
@@ -62,14 +59,14 @@ module RailsAdmin
       end
 
       def associations
-        model.associations.values.map do |association|
+        model.relations.values.collect do |association|
           Association.new(association, model).to_options_hash
         end
       end
 
       def properties
-        fields = model.fields.reject{|name, field| DISABLED_COLUMN_TYPES.include?(field.type.to_s) }
-        fields.map do |name,field|
+        fields = model.fields.reject { |name, field| DISABLED_COLUMN_TYPES.include?(field.type.to_s) }
+        fields.collect do |name, field|
           {
             :name => field.name.to_sym,
             :length => nil,
@@ -89,7 +86,7 @@ module RailsAdmin
       end
 
       def embedded?
-        @embedded ||= !!model.associations.values.find{|a| a.macro.to_sym == :embedded_in }
+        @embedded ||= !!model.relations.values.detect { |a| a.macro.to_sym == :embedded_in }
       end
 
       def cyclic?
@@ -100,7 +97,7 @@ module RailsAdmin
         false
       end
 
-      private
+    private
 
       def build_statement(column, type, value, operator)
         StatementBuilder.new(column, type, value, operator).to_statement
@@ -128,7 +125,7 @@ module RailsAdmin
         end
 
         if statements.any?
-          { '$or' => statements }
+          {'$or' => statements}
         else
           {}
         end
@@ -141,12 +138,12 @@ module RailsAdmin
 
         filters.each_pair do |field_name, filters_dump|
           filters_dump.each do |_, filter_dump|
-            field = fields.find{|f| f.name.to_s == field_name}
+            field = fields.detect { |f| f.name.to_s == field_name }
             next unless field
             conditions_per_collection = make_field_conditions(field, filter_dump[:v], (filter_dump[:o] || 'default'))
             field_statements = make_condition_for_current_collection(field, conditions_per_collection)
             if field_statements.many?
-              statements << { '$or' => field_statements }
+              statements << {'$or' => field_statements}
             elsif field_statements.any?
               statements << field_statements.first
             end
@@ -154,7 +151,7 @@ module RailsAdmin
         end
 
         if statements.any?
-          { '$and' => statements }
+          {'$and' => statements}
         else
           {}
         end
@@ -162,54 +159,51 @@ module RailsAdmin
 
       def type_lookup(name, field)
         {
-          "Array"          => { :type => :serialized },
-          "BigDecimal"     => { :type => :decimal },
-          "Mongoid::Boolean"        => { :type => :boolean },
-          "Boolean"        => { :type => :boolean },
-          "BSON::ObjectId" => { :type => :bson_object_id, :serial? => (name == primary_key) },
-          "Moped::BSON::ObjectId" => { :type => :bson_object_id, :serial? => (name == primary_key) },
-          "Date"           => { :type => :date },
-          "DateTime"       => { :type => :datetime },
-          "ActiveSupport::TimeWithZone" => { :type => :datetime },
-          "Float"          => { :type => :float },
-          "Hash"           => { :type => :serialized },
-          "Money"          => { :type => :serialized },
-          "Integer"        => { :type => :integer },
-          "Object"         => (
-            if associations.find{|a| a[:type] == :belongs_to && a[:foreign_key] == name.to_sym}
-              { :type => :bson_object_id }
+          'Array'          => {type: :serialized},
+          'BigDecimal'     => {type: :decimal},
+          'Mongoid::Boolean'        => {type: :boolean},
+          'Boolean'        => {type: :boolean},
+          'BSON::ObjectId' => {:type => :bson_object_id, :serial? => (name == primary_key)},
+          'Moped::BSON::ObjectId' => {:type => :bson_object_id, :serial? => (name == primary_key)},
+          'Date'           => {type: :date},
+          'DateTime'       => {type: :datetime},
+          'ActiveSupport::TimeWithZone' => {type: :datetime},
+          'Float'          => {type: :float},
+          'Hash'           => {type: :serialized},
+          'Money'          => {type: :serialized},
+          'Integer'        => {type: :integer},
+          'Object'         => (
+            if associations.detect { |a| a[:type] == :belongs_to && a[:foreign_key] == name.to_sym }
+              {type: :bson_object_id}
             else
-              { :type => :string, :length => 255 }
+              {type: :string, length: 255}
             end
           ),
-            "String"         => (
+          'String'         => (
               if (length = length_validation_lookup(name)) && length < 256
-                { :type => :string, :length => length }
+                {type: :string, length: length}
               elsif STRING_TYPE_COLUMN_NAMES.include?(name.to_sym)
-                { :type => :string, :length => 255 }
+                {type: :string, length: 255}
               else
-                { :type => :text }
+                {type: :text}
               end
           ),
-            "Symbol"         => { :type => :string, :length => 255 },
-            "Time"           => { :type => :datetime },
-        }[field.type.to_s] or raise "Type #{field.type.to_s} for field :#{name} in #{model.inspect} not supported"
+          'Symbol'         => {type: :string, length: 255},
+          'Time'           => {type: :datetime},
+        }[field.type.to_s] || fail("Type #{field.type.to_s} for field :#{name} in #{model.inspect} not supported")
       end
 
       def length_validation_lookup(name)
-        shortest = model.validators.select do |validator|
-          validator.respond_to?(:attributes) &&
-            validator.attributes.include?(name.to_sym) &&
-            validator.kind == :length &&
-            validator.options[:maximum]
-        end.min{|a, b| a.options[:maximum] <=> b.options[:maximum] }
+        shortest = model.validators.select { |validator| validator.respond_to?(:attributes) && validator.attributes.include?(name.to_sym) && validator.kind == :length && validator.options[:maximum] }.min do |a, b|
+          a.options[:maximum] <=> b.options[:maximum]
+        end
 
         shortest && shortest.options[:maximum]
       end
 
       def parse_collection_name(column)
         collection_name, column_name = column.split('.')
-        if [:embeds_one, :embeds_many].include?(model.associations[collection_name].try(:macro).try(:to_sym))
+        if [:embeds_one, :embeds_many].include?(model.relations[collection_name].try(:macro).try(:to_sym))
           [table_name, column]
         else
           [collection_name, column_name]
@@ -217,7 +211,7 @@ module RailsAdmin
       end
 
       def make_condition_for_current_collection(target_field, conditions_per_collection)
-        result =[]
+        result = []
         conditions_per_collection.each do |collection_name, conditions|
           if collection_name == table_name
             # conditions referring current model column are passed directly
@@ -231,14 +225,14 @@ module RailsAdmin
       end
 
       def perform_search_on_associated_collection(field_name, conditions)
-        target_association = associations.find{|a| a[:name] == field_name }
+        target_association = associations.detect { |a| a[:name] == field_name }
         return [] unless target_association
         model = target_association[:model_proc].call
         case target_association[:type]
         when :belongs_to, :has_and_belongs_to_many
-          [{ target_association[:foreign_key].to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:primary_key_proc].call)} }}]
+          [{target_association[:foreign_key].to_s => {'$in' => model.where('$or' => conditions).all.collect { |r| r.send(target_association[:primary_key_proc].call) }}}]
         when :has_many
-          [{ target_association[:primary_key_proc].call.to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:foreign_key])} }}]
+          [{target_association[:primary_key_proc].call.to_s => {'$in' => model.where('$or' => conditions).all.collect { |r| r.send(target_association[:foreign_key]) }}}]
         end
       end
 
@@ -249,7 +243,7 @@ module RailsAdmin
         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"
+            fail('sorting by associated model column is not supported in Non-Relational databases')
           end
         when Symbol
           field_name = options[:sort].to_s
@@ -261,7 +255,8 @@ module RailsAdmin
         end
       end
 
-      private
+    private
+
       class Association
         attr_reader :association, :model
         def initialize(association, model)
@@ -272,23 +267,23 @@ module RailsAdmin
 
         def to_options_hash
           {
-            :name => name.to_sym,
-            :pretty_name => display_name,
-            :type => type_lookup,
-            :model_proc => Proc.new { model_proc_lookup },
-            :primary_key_proc => Proc.new { primary_key_lookup },
-            :foreign_key => foreign_key_lookup,
-            :foreign_type => foreign_type_lookup,
-            :foreign_inverse_of => foreign_inverse_of_lookup,
-            :as => as_lookup,
-            :polymorphic => polymorphic_lookup,
-            :inverse_of => inverse_of_lookup,
-            :read_only => nil,
-            :nested_form => nested_attributes_options_lookup
+            name: name.to_sym,
+            pretty_name: display_name,
+            type: type_lookup,
+            model_proc: proc { model_proc_lookup },
+            primary_key_proc: proc { primary_key_lookup },
+            foreign_key: foreign_key_lookup,
+            foreign_type: foreign_type_lookup,
+            foreign_inverse_of: foreign_inverse_of_lookup,
+            as: as_lookup,
+            polymorphic: polymorphic_lookup,
+            inverse_of: inverse_of_lookup,
+            read_only: nil,
+            nested_form: nested_attributes_options_lookup
           }
         end
 
-        private
+      private
 
         def display_name
           name.to_s.tr('_', ' ').capitalize
@@ -317,7 +312,7 @@ module RailsAdmin
         def nested_attributes_options_lookup
           nested = model_nested_attributes_options.try { |o| o[name.to_sym] }
           if !nested && [:embeds_one, :embeds_many].include?(macro.to_sym) && !association.cyclic
-            raise <<-MSG.gsub(/^\s+/, '')
+            fail <<-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.to_s}' model.
@@ -363,50 +358,50 @@ 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}"
+            fail("Unknown association type: #{macro.inspect}")
           end
         end
 
         delegate :foreign_key, :macro, :name, :options, :scope, :polymorphic?,
                  :klass, :inverse_of, :inverse_type, :as,
-                 :to => :association, :prefix => false
-        delegate :name, :nested_attributes_options, :to => :model, :prefix => true
-        delegate :polymorphic_parents, :to => RailsAdmin::AbstractModel
+                 to: :association, prefix: false
+        delegate :name, :nested_attributes_options, to: :model, prefix: true
+        delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
       end
 
       class StatementBuilder < RailsAdmin::AbstractModel::StatementBuilder
-        protected
+      protected
 
         def unary_operators
           {
-            '_blank' => { @column => {'$in' => [nil, '']} },
-            '_present' => { @column => {'$nin' => [nil, '']} },
-            '_null' => { @column => nil },
-            '_not_null' => { @column => {'$ne' => nil} },
-            '_empty' => { @column => '' },
-            '_not_empty' => { @column => {'$ne' => ''} }
+            '_blank' => {@column => {'$in' => [nil, '']}},
+            '_present' => {@column => {'$nin' => [nil, '']}},
+            '_null' => {@column => nil},
+            '_not_null' => {@column => {'$ne' => nil}},
+            '_empty' => {@column => ''},
+            '_not_empty' => {@column => {'$ne' => ''}}
           }
         end
 
-        private
+      private
 
         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             then build_statement_for_string_or_text
-            when :enum                      then build_statement_for_enum
-            when :belongs_to_association, :bson_object_id then build_statement_for_belongs_to_association_or_bson_object_id
+          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 :enum                      then build_statement_for_enum
+          when :belongs_to_association, :bson_object_id then build_statement_for_belongs_to_association_or_bson_object_id
           end
         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)
-          { @column => value }
+          {@column => value}
         end
 
         def build_statement_for_string_or_text
@@ -423,33 +418,32 @@ module RailsAdmin
           else
             return
           end
-          { @column => @value }
+          {@column => @value}
         end
 
         def build_statement_for_enum
           return if @value.blank?
-          { @column => { "$in" => Array.wrap(@value) } }
+          {@column => {'$in' => Array.wrap(@value)}}
         end
 
         def build_statement_for_belongs_to_association_or_bson_object_id
           object_id = (object_id_from_string(@value) rescue nil)
-          { @column => object_id } if object_id
+          {@column => object_id} if object_id
         end
 
         def range_filter(min, max)
           if min && max
-            { @column => { '$gte' => min, '$lte' => max } }
+            {@column => {'$gte' => min, '$lte' => max}}
           elsif min
-            { @column => { '$gte' => min } }
+            {@column => {'$gte' => min}}
           elsif max
-            { @column => { '$lte' => max } }
+            {@column => {'$lte' => max}}
           end
         end
 
         def object_id_from_string(str)
           ObjectId.from_string(str)
         end
-
       end
     end
   end