rails_admin 2.0.0.beta → 2.0.0.rc

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

@@ -1,25 +0,0 @@
-require 'rails_admin/config/fields'
-require 'rails_admin/config/fields/types'
-require 'rails_admin/config/fields/types/file_upload'
-
-RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  extensions = [:id, :filename, :size, :content_type]
-  model = parent.abstract_model.model
-  if (properties.name.to_s =~ /^(.+)_id$/) && defined?(::Refile) && model.ancestors.map(&:to_s).include?("Refile::Attachment(#{attachment_name = Regexp.last_match[1].to_sym})")
-    field = RailsAdmin::Config::Fields::Types.load(:refile).new(parent, attachment_name, properties)
-    children_fields = []
-    extensions.each do |ext|
-      children_column_name = "#{attachment_name}_#{ext}".to_sym
-      next unless 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)
-      children_fields << children_field.name
-    end
-    field.children_fields(children_fields)
-    fields << field
-    true
-  else
-    false
-  end
-end

data/lib/rails_admin/config/fields/types/refile.rb

@@ -1,27 +0,0 @@
-require 'rails_admin/config/fields/base'
-require 'rails_admin/config/fields/types/file_upload'
-
-module RailsAdmin
-  module Config
-    module Fields
-      module Types
-        class Refile < RailsAdmin::Config::Fields::Types::FileUpload
-          RailsAdmin::Config::Fields::Types.register(self)
-
-          register_instance_option :thumb_method do
-            [:limit, 100, 100]
-          end
-
-          register_instance_option :delete_method do
-            "remove_#{name}"
-          end
-
-          def resource_url(thumb = [])
-            return nil unless value
-            Object.const_get(:Refile).attachment_url(bindings[:object], name, *thumb)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails_admin/extensions/cancan.rb

@@ -1,3 +0,0 @@
-require 'rails_admin/extensions/cancan/authorization_adapter'
-
-RailsAdmin.add_extension(:cancan, RailsAdmin::Extensions::CanCan, authorization: true)

data/lib/rails_admin/extensions/cancan/authorization_adapter.rb

@@ -1,57 +0,0 @@
-module RailsAdmin
-  module Extensions
-    module CanCan
-      # This adapter is for the CanCan[https://github.com/ryanb/cancan] authorization library.
-      # You can create another adapter for different authorization behavior, just be certain it
-      # responds to each of the public methods here.
-      class AuthorizationAdapter
-        # See the +authorize_with+ config method for where the initialization happens.
-        def initialize(controller, ability = ::Ability)
-          @controller = controller
-          @controller.instance_variable_set '@ability', ability
-          @controller.extend ControllerExtension
-          @controller.current_ability.authorize! :access, :rails_admin
-        end
-
-        # This method is called in every controller action and should raise an exception
-        # when the authorization fails. The first argument is the name of the controller
-        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
-        # AbstractModel instance that applies. The third argument is the actual model
-        # instance if it is available.
-        def authorize(action, abstract_model = nil, model_object = nil)
-          @controller.current_ability.authorize!(action, model_object || abstract_model && abstract_model.model) if action
-        end
-
-        # This method is called primarily from the view to determine whether the given user
-        # has access to perform the action on a given model. It should return true when authorized.
-        # This takes the same arguments as +authorize+. The difference is that this will
-        # return a boolean whereas +authorize+ will raise an exception when not authorized.
-        def authorized?(action, abstract_model = nil, model_object = nil)
-          @controller.current_ability.can?(action, model_object || abstract_model && abstract_model.model) if action
-        end
-
-        # This is called when needing to scope a database query. It is called within the list
-        # and bulk_delete/destroy actions and should return a scope which limits the records
-        # to those which the user can perform the given action on.
-        def query(action, abstract_model)
-          abstract_model.model.accessible_by(@controller.current_ability, action)
-        end
-
-        # This is called in the new/create actions to determine the initial attributes for new
-        # records. It should return a hash of attributes which match what the user
-        # is authorized to create.
-        def attributes_for(action, abstract_model)
-          @controller.current_ability.attributes_for(action, abstract_model && abstract_model.model)
-        end
-
-        module ControllerExtension
-          def current_ability
-            # use _current_user instead of default current_user so it works with
-            # whatever current user method is defined with RailsAdmin
-            @current_ability ||= @ability.new(_current_user)
-          end
-        end
-      end
-    end
-  end
-end