rails_admin 0.6.1 → 0.6.2

data/lib/rails_admin/bootstrap-sass/compass_functions.rb

@@ -1,25 +1,28 @@
-# This contains functions for use with a project *only* using Compass.
-module Sass::Script::Functions
-  def image_path(source, options = {})
-    if defined?(::Sprockets)
-      ::Sass::Script::String.new sprockets_context.image_path(source.value).to_s, :string
-    elsif defined?(::Compass)
-      image_url(source, Sass::Script::Bool.new(true))
-    else
-      # Revert to the old compass-agnostic path determination
-      asset_sans_quotes = source.value.gsub('"', '')
-      Sass::Script::String.new("/images/#{asset_sans_quotes}", :string)
-    end
-  end
+module Sass
+  module Script
+    module Functions
+      def image_path(source, options = {})
+        if defined?(::Sprockets)
+          ::Sass::Script::String.new sprockets_context.image_path(source.value).to_s, :string
+        elsif defined?(::Compass)
+          image_url(source, Sass::Script::Bool.new(true))
+        else
+          # Revert to the old compass-agnostic path determination
+          asset_sans_quotes = source.value.gsub('"', '')
+          Sass::Script::String.new("/images/#{asset_sans_quotes}", :string)
+        end
+      end
 
-protected
+    protected
 
-  def sprockets_context # :nodoc:
-    if options.key?(:sprockets)
-      options[:sprockets][:context]
-    else
-      # Compatibility with sprockets pre 2.10.0
-      options[:importer].context
+      def sprockets_context # :nodoc:
+        if options.key?(:sprockets)
+          options[:sprockets][:context]
+        else
+          # Compatibility with sprockets pre 2.10.0
+          options[:importer].context
+        end
+      end
     end
   end
 end

data/lib/rails_admin/bootstrap-sass/sass_functions.rb

@@ -1,14 +1,18 @@
 require 'sass'
 
-module Sass::Script::Functions
-  # LARS: Snatched from compass - 2011-11-29 - used for gradients in IE6-9
-  # returns an IE hex string for a color with an alpha channel
-  # suitable for passing to IE filters.
-  def ie_hex_str(color)
-    assert_type color, :Color
-    alpha = (color.alpha * 255).round
-    alphastr = alpha.to_s(16).rjust(2, '0')
-    Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
+module Sass
+  module Script
+    module Functions
+      # LARS: Snatched from compass - 2011-11-29 - used for gradients in IE6-9
+      # returns an IE hex string for a color with an alpha channel
+      # suitable for passing to IE filters.
+      def ie_hex_str(color)
+        assert_type color, :Color
+        alpha = (color.alpha * 255).round
+        alphastr = alpha.to_s(16).rjust(2, '0')
+        Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
+      end
+      declare :ie_hex_str, [:color]
+    end
   end
-  declare :ie_hex_str, [:color]
 end

data/lib/rails_admin/config.rb

@@ -84,7 +84,7 @@ module RailsAdmin
       # @example Custom Warden
       #   RailsAdmin.config do |config|
       #     config.authenticate_with do
-      #       warden.authenticate! :scope => :paranoid
+      #       warden.authenticate! scope: :paranoid
       #     end
       #   end
       #
@@ -178,7 +178,7 @@ module RailsAdmin
       end
 
       def default_search_operator=(operator)
-        if %w{ default like starts_with ends_with is = }.include? operator
+        if %w[default like starts_with ends_with is =].include? operator
           @default_search_operator = operator
         else
           fail(ArgumentError.new("Search operator '#{operator}' not supported"))
@@ -305,7 +305,7 @@ module RailsAdmin
       def viable_models
         included_models.collect(&:to_s).presence || (
           @@system_models ||= # memoization for tests
-            ([Rails.application] + Rails::Engine.subclasses.collect(&:instance)).collect do |app|
+            ([Rails.application] + Rails::Engine.subclasses.collect(&:instance)).flat_map do |app|
               (app.paths['app/models'].to_a + app.config.autoload_paths).collect do |load_path|
                 Dir.glob(app.root.join(load_path)).collect do |load_dir|
                   Dir.glob(load_dir + '/**/*.rb').collect do |filename|

data/lib/rails_admin/config/actions.rb

@@ -45,12 +45,12 @@ module RailsAdmin
 
         def add_action(key, parent_class, parent, &block)
           a = "RailsAdmin::Config::Actions::#{parent_class.to_s.camelize}".constantize.new
-          a.instance_eval(%{
+          a.instance_eval(%(
             #{parent} true
             def key
               :#{key}
             end
-          })
+          ))
           add_action_custom_key(a, &block)
         end
 

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

@@ -26,7 +26,7 @@ module RailsAdmin
                 current_count = t.count({}, scope)
                 @max = current_count > @max ? current_count : @max
                 @count[t.pretty_name] = current_count
-                if t.properties.detect { |c| c[:name] == :updated_at }
+                if t.properties.detect { |c| c.name == :updated_at }
                   @most_recent_changes[t.pretty_name] = t.first(sort: "#{t.table_name}.updated_at").try(:updated_at)
                 end
               end

data/lib/rails_admin/config/configurable.rb

@@ -43,7 +43,7 @@ module RailsAdmin
 
           # Define getter/setter by the option name
           scope.send(:define_method, option_name) do |*args, &block|
-            if !args[0].nil? || block
+            if !args[0].nil? || block # rubocop:disable NonNilCheck
               # Invocation with args --> This is the declaration of the option, i.e. setter
               instance_variable_set("@#{option_name}_registered", args[0].nil? ? block : args[0])
             else

data/lib/rails_admin/config/fields.rb

@@ -8,11 +8,11 @@ module RailsAdmin
       mattr_reader :default_factory
       @@default_factory = lambda do |parent, properties, fields|
         # If it's an association
-        if properties.key?(:model_proc)
-          association = parent.abstract_model.associations.detect { |a| a[:name].to_s == properties[:name].to_s }
-          field = RailsAdmin::Config::Fields::Types.load("#{association[:polymorphic] ? :polymorphic : properties[:type]}_association").new(parent, properties[:name], association)
+        if properties.association?
+          association = parent.abstract_model.associations.detect { |a| a.name.to_s == properties.name.to_s }
+          field = RailsAdmin::Config::Fields::Types.load("#{association.polymorphic? ? :polymorphic : properties.type}_association").new(parent, properties.name, association)
         else
-          field = RailsAdmin::Config::Fields::Types.load(properties[:type]).new(parent, properties[:name], properties)
+          field = RailsAdmin::Config::Fields::Types.load(properties.type).new(parent, properties.name, properties)
         end
         fields << field
         field
@@ -49,15 +49,15 @@ module RailsAdmin
 
         parent.abstract_model.properties.each do |properties|
           # Unless a previous factory has already loaded current field as well
-          unless fields.detect { |f| f.name == properties[:name] }
+          unless fields.detect { |f| f.name == properties.name }
             # Loop through factories until one returns true
             @@registry.detect { |factory| factory.call(parent, properties, fields) }
           end
         end
         # Load fields for all associations (relations)
-        parent.abstract_model.associations.select { |a| a[:type] != :belongs_to }.each do |association| # :belongs_to are created by factory for belongs_to fields
+        parent.abstract_model.associations.select { |a| a.type != :belongs_to }.each do |association| # :belongs_to are created by factory for belongs_to fields
           # Unless a previous factory has already loaded current field as well
-          unless fields.detect { |f| f.name == association[:name] }
+          unless fields.detect { |f| f.name == association.name }
             # Loop through factories until one returns true
             @@registry.detect { |factory| factory.call(parent, association, fields) }
           end

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

@@ -34,7 +34,7 @@ module RailsAdmin
 
         # use the association name as a key, not the association key anymore!
         register_instance_option :label do
-          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name association[:name]
+          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name association.name
         end
 
         # scope for possible associable records
@@ -48,7 +48,7 @@ module RailsAdmin
 
         # inverse relationship
         register_instance_option :inverse_of do
-          association[:inverse_of]
+          association.inverse_of
         end
 
         # preload entire associated collection (per associated_collection_scope) on load
@@ -59,7 +59,7 @@ module RailsAdmin
 
         # Reader for the association's child model's configuration
         def associated_model_config
-          @associated_model_config ||= RailsAdmin.config(association[:model_proc].call)
+          @associated_model_config ||= RailsAdmin.config(association.klass)
         end
 
         # Reader for the association's child model object's label method
@@ -69,27 +69,27 @@ module RailsAdmin
 
         # Reader for associated primary key
         def associated_primary_key
-          @associated_primary_key ||= association[:primary_key_proc].call
+          @associated_primary_key ||= association.primary_key
         end
 
         # Reader for the association's key
         def foreign_key
-          association[:foreign_key]
+          association.foreign_key
         end
 
         # Reader whether this is a polymorphic association
         def polymorphic?
-          association[:polymorphic]
+          association.polymorphic?
         end
 
         # Reader for nested attributes
         register_instance_option :nested_form do
-          association[:nested_form]
+          association.nested_options
         end
 
         # Reader for the association's value unformatted
         def value
-          bindings[:object].send(association[:name])
+          bindings[:object].send(association.name)
         end
 
         # has many?

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

@@ -57,7 +57,7 @@ module RailsAdmin
         end
 
         register_instance_option :filterable? do
-          !!searchable
+          !!searchable # rubocop:disable DoubleNegation
         end
 
         register_instance_option :search_operator do
@@ -69,7 +69,7 @@ module RailsAdmin
           false
         end
 
-        # list of columns I should search for that field [{ :column => 'table_name.column', :type => field.type }, {..}]
+        # list of columns I should search for that field [{ column: 'table_name.column', type: field.type }, {..}]
         register_instance_option :searchable_columns do
           @searchable_columns ||= case searchable
           when true
@@ -88,14 +88,14 @@ module RailsAdmin
                 am = f.keys.first.is_a?(Class) && AbstractModel.new(f.keys.first)
                 table_name = am && am.table_name || f.keys.first
                 column = f.values.first
-                property = am && am.properties.detect { |p| p[:name] == f.values.first.to_sym }
-                type = property && property[:type]
+                property = am && am.properties.detect { |p| p.name == f.values.first.to_sym }
+                type = property && property.type
               else                                                             #  <attribute|column>
                 am = (self.association? ? associated_model_config.abstract_model : abstract_model)
                 table_name = am.table_name
                 column = f
-                property = am.properties.detect { |p| p[:name] == f.to_sym }
-                type = property && property[:type]
+                property = am.properties.detect { |p| p.name == f.to_sym }
+                type = property && property.type
               end
 
               {column: "#{table_name}.#{column}", type: (type || :string)}
@@ -145,7 +145,7 @@ module RailsAdmin
         #
         # @see RailsAdmin::AbstractModel.properties
         register_instance_option :length do
-          @length ||= properties && properties[:length]
+          @length ||= properties && properties.length
         end
 
         # Accessor for field's length restrictions per validations
@@ -167,8 +167,8 @@ module RailsAdmin
           else
             :nil
           end
-          (@required ||= {})[context] ||= !!([name] + children_fields).uniq.detect do |column_name|
-            !!abstract_model.model.validators_on(column_name).detect do |v|
+          (@required ||= {})[context] ||= !!([name] + children_fields).uniq.detect do |column_name| # rubocop:disable DoubleNegation
+            abstract_model.model.validators_on(column_name).detect do |v|
               !v.options[:allow_nil] &&
               [:presence, :numericality, :attachment_presence].include?(v.kind) &&
               (v.options[:on] == context || v.options[:on].blank?)
@@ -180,7 +180,7 @@ module RailsAdmin
         #
         # @see RailsAdmin::AbstractModel.properties
         register_instance_option :serial? do
-          properties && properties[:serial?]
+          properties && properties.serial?
         end
 
         register_instance_option :view_helper do
@@ -216,7 +216,7 @@ module RailsAdmin
         end
 
         def editable?
-          !(@properties && @properties[:read_only])
+          !(@properties && @properties.read_only?)
         end
 
         # Is this an association
@@ -242,7 +242,7 @@ module RailsAdmin
         #
         # @see RailsAdmin::Config::Fields::Base.register_instance_option :required?
         def optional(state = nil, &block)
-          if !state.nil? || block
+          if !state.nil? || block # rubocop:disable NonNilCheck
             required state.nil? ? proc { false == (instance_eval(&block)) } : false == state
           else
             optional?
@@ -300,7 +300,7 @@ module RailsAdmin
         end
 
         def form_default_value
-          (default_value if bindings[:object].new_record? && value.nil? && !default_value.nil?)
+          (default_value if bindings[:object].new_record? && value.nil?)
         end
 
         def form_value

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

@@ -3,19 +3,19 @@ require 'rails_admin/config/fields/types'
 require 'rails_admin/config/fields/types/belongs_to_association'
 
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  if association = parent.abstract_model.associations.detect { |a| a[:foreign_key] == properties[:name] && [:belongs_to, :has_and_belongs_to_many].include?(a[:type]) }
-    field = RailsAdmin::Config::Fields::Types.load("#{association[:polymorphic] ? :polymorphic : association[:type]}_association").new(parent, association[:name], association)
+  if association = parent.abstract_model.associations.detect { |a| a.foreign_key == properties.name && [:belongs_to, :has_and_belongs_to_many].include?(a.type) }
+    field = RailsAdmin::Config::Fields::Types.load("#{association.polymorphic? ? :polymorphic : association.type}_association").new(parent, association.name, association)
     fields << field
 
     child_columns = []
-    possible_field_names = if association[:polymorphic]
+    possible_field_names = if association.polymorphic?
       [:foreign_key, :foreign_type, :foreign_inverse_of]
     else
       [:foreign_key]
-    end.collect { |k| association[k] }.compact
+    end.collect { |k| association.send(k) }.compact
 
-    parent.abstract_model.properties.select { |p| possible_field_names.include? p[:name] }.each do |column|
-      unless child_field = fields.detect { |f| f.name.to_s == column[:name].to_s }
+    parent.abstract_model.properties.select { |p| possible_field_names.include? p.name }.each do |column|
+      unless child_field = fields.detect { |f| f.name.to_s == column.name.to_s }
         child_field = RailsAdmin::Config::Fields.default_factory.call(parent, column, fields)
       end
       child_columns << child_field

data/lib/rails_admin/config/fields/factories/carrierwave.rb

@@ -4,13 +4,13 @@ require 'rails_admin/config/fields/types/file_upload'
 
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
   model = parent.abstract_model.model
-  if defined?(::CarrierWave) && (model).kind_of?(CarrierWave::Mount) && model.uploaders.include?(attachment_name = properties[:name].to_s.chomp('_file_name').to_sym)
+  if defined?(::CarrierWave) && (model).kind_of?(CarrierWave::Mount) && model.uploaders.include?(attachment_name = properties.name.to_s.chomp('_file_name').to_sym)
     columns = [model.uploader_options[attachment_name][:mount_on] || attachment_name, "#{attachment_name}_content_type".to_sym, "#{attachment_name}_file_size".to_sym]
     field = RailsAdmin::Config::Fields::Types.load(:carrierwave).new(parent, attachment_name, properties)
     fields << field
     children_fields = []
     columns.each do |children_column_name|
-      if child_properties = parent.abstract_model.properties.detect { |p| p[:name].to_s == children_column_name.to_s }
+      if child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
         children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
         children_field.hide unless field == children_field
         children_field.filterable(false) unless field == children_field

data/lib/rails_admin/config/fields/factories/devise.rb

@@ -4,12 +4,12 @@ require 'rails_admin/config/fields/types/password'
 
 # Register a custom field factory for devise model
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  if properties[:name] == :encrypted_password
+  if properties.name == :encrypted_password
     extensions = [:password_salt, :reset_password_token, :remember_token]
     fields << RailsAdmin::Config::Fields::Types.load(:password).new(parent, :password, properties)
     fields << RailsAdmin::Config::Fields::Types.load(:password).new(parent, :password_confirmation, properties)
     extensions.each do |ext|
-      properties = parent.abstract_model.properties.detect { |p| ext == p[:name] }
+      properties = parent.abstract_model.properties.detect { |p| ext == p.name }
       if properties
         unless field = fields.detect { |f| f.name == ext }
           RailsAdmin::Config::Fields.default_factory.call(parent, properties, fields)

data/lib/rails_admin/config/fields/factories/dragonfly.rb

@@ -4,12 +4,12 @@ require 'rails_admin/config/fields/types/file_upload'
 
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
   extensions = [:name, :uid]
-  if (properties[:name].to_s =~ /^(.+)_uid$/) && defined?(::Dragonfly) && parent.abstract_model.model.dragonfly_attachment_classes.collect(&:attribute).include?(attachment_name = Regexp.last_match[1].to_sym)
+  if (properties.name.to_s =~ /^(.+)_uid$/) && defined?(::Dragonfly) && parent.abstract_model.model.dragonfly_attachment_classes.collect(&:attribute).include?(attachment_name = Regexp.last_match[1].to_sym)
     field = RailsAdmin::Config::Fields::Types.load(:dragonfly).new(parent, attachment_name, properties)
     children_fields = []
     extensions.each do |ext|
       children_column_name = "#{attachment_name}_#{ext}".to_sym
-      if child_properties = parent.abstract_model.properties.detect { |p| p[:name].to_s == children_column_name.to_s }
+      if child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
         children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
         children_field.hide
         children_field.filterable(false)

data/lib/rails_admin/config/fields/factories/enum.rb

@@ -4,13 +4,13 @@ require 'rails_admin/config/fields/types/enum'
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
 
   _model = parent.abstract_model.model
-  _method_name = "#{properties[:name]}_enum"
+  _method_name = "#{properties.name}_enum"
 
   # NOTICE: _method_name could be `to_enum` and this method defined in Object.
   if !Object.respond_to?(_method_name) && \
       (_model.respond_to?(_method_name) || \
           _model.method_defined?(_method_name))
-    fields << RailsAdmin::Config::Fields::Types::Enum.new(parent, properties[:name], properties)
+    fields << RailsAdmin::Config::Fields::Types::Enum.new(parent, properties.name, properties)
     true
   else
     false

data/lib/rails_admin/config/fields/factories/paperclip.rb

@@ -5,12 +5,12 @@ require 'rails_admin/config/fields/types/file_upload'
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
   extensions = [:file_name, :content_type, :file_size, :updated_at, :fingerprint]
   model = parent.abstract_model.model
-  if (properties[:name].to_s =~ /^(.+)_file_name$/) && defined?(::Paperclip) && model.attachment_definitions && model.attachment_definitions.key?(attachment_name = Regexp.last_match[1].to_sym)
+  if (properties.name.to_s =~ /^(.+)_file_name$/) && defined?(::Paperclip) && model.attachment_definitions && model.attachment_definitions.key?(attachment_name = Regexp.last_match[1].to_sym)
     field = RailsAdmin::Config::Fields::Types.load(:paperclip).new(parent, attachment_name, properties)
     children_fields = []
     extensions.each do |ext|
       children_column_name = "#{attachment_name}_#{ext}".to_sym
-      if child_properties = parent.abstract_model.properties.detect { |p| p[:name].to_s == children_column_name.to_s }
+      if child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
         children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
         children_field.hide
         children_field.filterable(false)

data/lib/rails_admin/config/fields/factories/password.rb

@@ -8,8 +8,8 @@ require 'rails_admin/config/fields/types/password'
 # @see RailsAdmin::Config::Fields::Types::Password.column_names
 # @see RailsAdmin::Config::Fields.register_factory
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  if [:password].include?(properties[:name])
-    fields << RailsAdmin::Config::Fields::Types::Password.new(parent, properties[:name], properties)
+  if [:password].include?(properties.name)
+    fields << RailsAdmin::Config::Fields::Types::Password.new(parent, properties.name, properties)
     true
   else
     false