elucid-rails_admin 0.0.1

data/lib/rails_admin/config.rb

@@ -0,0 +1,287 @@
+require 'rails_admin/config/model'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/config/sections/navigation'
+require 'active_support/core_ext/class/attribute_accessors'
+
+module RailsAdmin
+  module Config
+    # RailsAdmin is setup to try and authenticate with warden
+    # If warden is found, then it will try to authenticate
+    #
+    # This is valid for custom warden setups, and also devise
+    # If you're using the admin setup for devise, you should set RailsAdmin to use the admin
+    #
+    # By default, this will raise in any of the following environments
+    #   * production
+    #   * beta
+    #   * uat
+    #   * staging
+    #
+    # @see RailsAdmin::Config.authenticate_with
+    # @see RailsAdmin::Config.authorize_with
+    DEFAULT_AUTHENTICATION = Proc.new do
+      request.env['warden'].try(:authenticate!)
+    end
+
+    DEFAULT_ATTR_ACCESSIBLE_ROLE = Proc.new { :default }
+
+    DEFAULT_AUTHORIZE = Proc.new {}
+
+    DEFAULT_CURRENT_USER = Proc.new do
+      request.env["warden"].try(:user) || respond_to?(:current_user) && current_user
+    end
+
+
+    class << self
+      # Application title, can be an array of two elements
+      attr_accessor :main_app_name
+
+      # Configuration option to specify which models you want to exclude.
+      attr_accessor :excluded_models
+
+      # Configuration option to specify a whitelist of models you want to RailsAdmin to work with.
+      # The excluded_models list applies against the whitelist as well and further reduces the models
+      # RailsAdmin will use.
+      # If included_models is left empty ([]), then RailsAdmin will automatically use all the models
+      # in your application (less any excluded_models you may have specified).
+      attr_accessor :included_models
+
+      # Fields to be hidden in show, create and update views
+      attr_accessor :default_hidden_fields
+
+      # Default items per page value used if a model level option has not
+      # been configured
+      attr_accessor :default_items_per_page
+
+      attr_reader :default_search_operator
+
+      # Configuration option to specify which method names will be searched for
+      # to be used as a label for object records. This defaults to [:name, :title]
+      attr_accessor :label_methods
+
+      # hide blank fields in show view if true
+      attr_accessor :compact_show_view
+
+      # Set the max width of columns in list view before a new set is created
+      attr_accessor :total_columns_width
+
+      # Stores model configuration objects in a hash identified by model's class
+      # name.
+      #
+      # @see RailsAdmin::Config.model
+      attr_reader :registry
+
+      # Setup authentication to be run as a before filter
+      # This is run inside the controller instance so you can setup any authentication you need to
+      #
+      # By default, the authentication will run via warden if available
+      # and will run the default.
+      #
+      # If you use devise, this will authenticate the same as _authenticate_user!_
+      #
+      # @example Devise admin
+      #   RailsAdmin.config do |config|
+      #     config.authenticate_with do
+      #       authenticate_admin!
+      #     end
+      #   end
+      #
+      # @example Custom Warden
+      #   RailsAdmin.config do |config|
+      #     config.authenticate_with do
+      #       warden.authenticate! :scope => :paranoid
+      #     end
+      #   end
+      #
+      # @see RailsAdmin::Config::DEFAULT_AUTHENTICATION
+      def authenticate_with(&blk)
+        @authenticate = blk if blk
+        @authenticate || DEFAULT_AUTHENTICATION
+      end
+
+
+      def attr_accessible_role(&blk)
+        @attr_accessible_role = blk if blk
+        @attr_accessible_role || DEFAULT_ATTR_ACCESSIBLE_ROLE
+      end
+
+      # Setup authorization to be run as a before filter
+      # This is run inside the controller instance so you can setup any authorization you need to.
+      #
+      # By default, there is no authorization.
+      #
+      # @example Custom
+      #   RailsAdmin.config do |config|
+      #     config.authorize_with do
+      #       redirect_to root_path unless warden.user.is_admin?
+      #     end
+      #   end
+      #
+      # To use an authorization adapter, pass the name of the adapter. For example,
+      # to use with CanCan[https://github.com/ryanb/cancan], pass it like this.
+      #
+      # @example CanCan
+      #   RailsAdmin.config do |config|
+      #     config.authorize_with :cancan
+      #   end
+      #
+      # See the wiki[https://github.com/sferik/rails_admin/wiki] for more on authorization.
+      #
+      # @see RailsAdmin::Config::DEFAULT_AUTHORIZE
+      def authorize_with(*args, &block)
+        extension = args.shift
+        if(extension)
+          @authorize = Proc.new {
+            @authorization_adapter = RailsAdmin::AUTHORIZATION_ADAPTERS[extension].new(*([self] + args).compact)
+          }
+        else
+          @authorize = block if block
+        end
+        @authorize || DEFAULT_AUTHORIZE
+      end
+
+      # Setup configuration using an extension-provided ConfigurationAdapter
+      #
+      # @example Custom configuration for role-based setup.
+      #   RailsAdmin.config do |config|
+      #     config.configure_with(:custom) do |config|
+      #       config.models = ['User', 'Comment']
+      #       config.roles  = {
+      #         'Admin' => :all,
+      #         'User'  => ['User']
+      #       }
+      #     end
+      #   end
+      def configure_with(extension)
+        configuration = RailsAdmin::CONFIGURATION_ADAPTERS[extension].new
+        yield(configuration) if block_given?
+      end
+
+      # Setup a different method to determine the current user or admin logged in.
+      # This is run inside the controller instance and made available as a helper.
+      #
+      # By default, _request.env["warden"].user_ or _current_user_ will be used.
+      #
+      # @example Custom
+      #   RailsAdmin.config do |config|
+      #     config.current_user_method do
+      #       current_admin
+      #     end
+      #   end
+      #
+      # @see RailsAdmin::Config::DEFAULT_CURRENT_USER
+      def current_user_method(&block)
+        @current_user = block if block
+        @current_user || DEFAULT_CURRENT_USER
+      end
+
+      def default_search_operator=(operator)
+        if %w{ default like starts_with ends_with is = }.include? operator
+          @default_search_operator = operator
+        else
+          raise ArgumentError, "Search operator '#{operator}' not supported"
+        end
+      end
+
+      def reload_between_requests=(thingy)
+        ActiveSupport::Deprecation.warn("'#{self.name}.reload_between_requests=' is not in use any longer, please remove it from initialization files", caller)
+      end
+
+      # Shortcut to access the list section's class configuration
+      # within a config DSL block
+      #
+      # @see RailsAdmin::Config::Sections::List
+      def list
+        ActiveSupport::Deprecation.warn("RailsAdmin::Config.list is deprecated", caller)
+        RailsAdmin::Config::Sections::List
+      end
+
+      # Loads a model configuration instance from the registry or registers
+      # a new one if one is yet to be added.
+      #
+      # First argument can be an instance of requested model, its class object,
+      # its class name as a string or symbol or a RailsAdmin::AbstractModel
+      # instance.
+      #
+      # If a block is given it is evaluated in the context of configuration instance.
+      #
+      # Returns given model's configuration
+      #
+      # @see RailsAdmin::Config.registry
+      def model(entity, &block)
+        key = begin
+          if entity.kind_of?(RailsAdmin::AbstractModel)
+            entity.model.name.to_sym
+          elsif entity.kind_of?(Class)
+            entity.name.to_sym
+          elsif entity.kind_of?(String) || entity.kind_of?(Symbol)
+            entity.to_sym
+          else
+            entity.class.name.to_sym
+          end
+        end
+        config = @registry[key] ||= RailsAdmin::Config::Model.new(entity)
+        config.instance_eval(&block) if block
+        config
+      end
+
+      # Returns all model configurations
+      #
+      # If a block is given it is evaluated in the context of configuration
+      # instances.
+      #
+      # @see RailsAdmin::Config.registry
+      def models(&block)
+        RailsAdmin::AbstractModel.all.map{|m| model(m, &block)}
+      end
+
+      # Shortcut to access the navigation section's class configuration
+      # within a config DSL block
+      #
+      # @see RailsAdmin::Config::Sections::Navigation
+      def navigation
+        ActiveSupport::Deprecation.warn("RailsAdmin::Config.navigation is deprecated", caller)
+        RailsAdmin::Config::Sections::Navigation
+      end
+
+      # Reset all configurations to defaults.
+      #
+      # @see RailsAdmin::Config.registry
+      def reset
+        @compact_show_view = true
+        @authenticate = nil
+        @authorize = nil
+        @current_user = nil
+        @default_hidden_fields = [:id, :created_at, :created_on, :deleted_at, :updated_at, :updated_on, :deleted_on]
+        @default_items_per_page = 20
+        @default_search_operator = 'default'
+        @excluded_models = []
+        @included_models = []
+        @total_columns_width = 697
+        @label_methods = [:name, :title]
+        @main_app_name = Proc.new { [Rails.application.engine_name.titleize.chomp(' Application'), 'Admin'] }
+        @registry = {}
+      end
+
+      # Reset a provided model's configuration.
+      #
+      # @see RailsAdmin::Config.registry
+      def reset_model(model)
+        key = model.kind_of?(Class) ? model.name.to_sym : model.to_sym
+        @registry.delete(key)
+      end
+
+      # Get all models that are configured as visible sorted by their weight and label.
+      #
+      # @see RailsAdmin::Config::Hideable
+      def visible_models
+        self.models.select {|m| m.visible? }.sort do |a, b|
+          (weight_order = a.weight <=> b.weight) == 0 ? a.label.downcase <=> b.label.downcase : weight_order
+        end
+      end
+    end
+
+    # Set default values for configuration options on load
+    self.reset
+  end
+end

data/lib/rails_admin/config/base.rb

@@ -0,0 +1,111 @@
+require 'rails_admin/config/proxy'
+
+module RailsAdmin
+  module Config
+    # A base class for all configurables.
+    #
+    # Each configurable has a parent object. This parent object must provide
+    # the configurable with abstract_model and bindings.
+    #
+    # Bindings is a hash of variables bound by the querying context. For
+    # example the list view's template will bind an object to key
+    # :object for each row it outputs. This object is the actual row object
+    # which is then used as the receiver of queries for property values.
+    #
+    # @see RailsAdmin::AbstractModel
+    # @see RailsAdmin::Config::Model#abstract_model
+    class Base
+      attr_reader :abstract_model, :bindings, :parent, :root
+
+      def initialize(parent)
+        @abstract_model = parent.abstract_model
+        @bindings = {}
+        @parent = parent
+        @root = parent.root
+      end
+
+      def has_option?(name)
+        options = self.class.instance_variable_get("@config_options")
+        options && options.has_key?(name)
+      end
+
+      # Register an instance option for this object only
+      def register_instance_option(option_name, &default)
+        scope = class << self; self; end;
+        self.class.register_instance_option(option_name, scope, &default)
+      end
+
+      def register_deprecated_instance_option(option_name, replacement_option_name)
+        scope = class << self; self; end;
+        self.class.register_deprecated_instance_option(option_name, replacement_option_name, scope)
+      end
+
+      def with(bindings = {})
+        RailsAdmin::Config::Proxy.new(self, bindings)
+      end
+
+      # Register an instance option. Instance option is a configuration
+      # option that stores its value within an instance variable and is
+      # accessed by an instance method. Both go by the name of the option.
+      def self.register_instance_option(option_name, scope = self, &default)
+        unless options = scope.instance_variable_get("@config_options")
+          options = scope.instance_variable_set("@config_options", {})
+        end
+
+        option_name = option_name.to_s
+
+        options[option_name] = nil
+
+        # If it's a boolean create an alias for it and remove question mark
+        if "?" == option_name[-1, 1]
+          scope.send(:define_method, "#{option_name.chop!}?") do
+            send(option_name)
+          end
+        end
+
+        # Define getter/setter by the option name
+        scope.send(:define_method, option_name) do |*args, &block|
+          if !args[0].nil? || block
+            # 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
+            # Invocation without args nor block --> It's the use of the option, i.e. getter
+            value = instance_variable_get("@#{option_name}_registered")
+            case value
+              when Proc
+                # Track recursive invocation with an instance variable. This prevents run-away recursion
+                # and allows configurations such as
+                # label { "#{label}".upcase }
+                # This will use the default definition when called recursively.
+                if instance_variable_get("@#{option_name}_recurring")
+                  value = instance_eval &default
+                else
+                  instance_variable_set("@#{option_name}_recurring", true)
+                  value = instance_eval &value
+                  instance_variable_set("@#{option_name}_recurring", false)
+                end
+              when nil
+                value = instance_eval &default
+            end
+            value
+          end
+        end
+      end
+
+      def self.register_deprecated_instance_option(option_name, replacement_option_name, scope = self)
+        scope.send(:define_method, option_name) do |*args, &block|
+          ActiveSupport::Deprecation.warn("The #{option_name} configuration option is deprecated, please use #{replacement_option_name}.")
+          send(replacement_option_name, *args, &block)
+        end
+      end
+
+      # Register a class option. Class option is a configuration
+      # option that stores it's value within a class object's instance variable
+      # and is accessed by a class method. Both go by the name of the option.
+      def self.register_class_option(option_name, &default)
+        scope = class << self; self; end;
+        self.register_instance_option(option_name, scope, &default)
+      end
+    end
+  end
+end

data/lib/rails_admin/config/fields.rb

@@ -0,0 +1,99 @@
+module RailsAdmin
+  module Config
+    module Fields
+      # Default field factory loads fields based on their property type or
+      # association type.
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      mattr_reader :default_factory
+      @@default_factory = lambda do |parent, properties, fields|
+        # If it's an association
+        if properties.has_key?(:parent_model)
+          association = parent.abstract_model.associations.find {|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)
+
+          field.read_only(true) if association[:read_only]
+          fields << field
+
+        # If it's a column
+        elsif !properties.has_key?(:parent_model)
+          fields << (field = RailsAdmin::Config::Fields::Types.load(properties[:type]).new(parent, properties[:name], properties))
+          # hide _type columns (handled as associations)
+          if parent.abstract_model.belongs_to_associations.find {|a| a[:foreign_type] == properties[:name] }
+            field.hide
+          end
+          # hide _id column
+          if parent.abstract_model.belongs_to_associations.find {|a| a[:child_key] == properties[:name] }
+            field.hide
+            field.filterable(false) # filtering is handled on the association itself
+          end
+        end
+      end
+
+      # Registry of field factories.
+      #
+      # Field factory is an anonymous function that recieves the parent object,
+      # an array of field properties and an array of fields already instantiated.
+      #
+      # If the factory returns true then that property will not be run through
+      # the rest of the registered factories. If it returns false then the
+      # arguments will be passed to the next factory.
+      #
+      # By default a basic factory is registered which loads fields by their
+      # database column type. Also a password factory is registered which
+      # loads fields if their name is password. Third default factory is a
+      # devise specific factory which loads fields for devise user models.
+      #
+      # @see RailsAdmin::Config::Fields.register_factory
+      # @see rails_admin/config/fields/factories/password.rb
+      # @see rails_admin/config/fields/factories/devise.rb
+      @@registry = [@@default_factory]
+
+      # Build an array of fields by the provided parent object's abstract_model's
+      # property and association information. Each property and association is
+      # passed to the registered field factories which will populate the fields
+      # array that will be returned.
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      def self.factory(parent)
+        fields = []
+        return fields unless parent.abstract_model.model_store_exists?
+        # Load fields for all properties (columns)
+
+        parent.abstract_model.properties.each do |properties|
+          # Unless a previous factory has already loaded current field as well
+          unless fields.find {|f| f.name == properties[:name] }
+            # Loop through factories until one returns true
+            @@registry.find {|factory| factory.call(parent, properties, fields) }
+          end
+        end
+        # Load fields for all associations (relations)
+        parent.abstract_model.associations.each do |association|
+          # Unless a previous factory has already loaded current field as well
+          unless fields.find {|f| f.name == association[:name] }
+            # Loop through factories until one returns true
+            @@registry.find {|factory| factory.call(parent, association, fields) }
+          end
+        end
+        fields
+      end
+
+      # Register a field factory to be included in the factory stack.
+      #
+      # Factories are invoked lifo (last in first out).
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      def self.register_factory(&block)
+        @@registry.unshift(block)
+      end
+    end
+  end
+end
+
+require 'rails_admin/config/fields/types'
+require 'rails_admin/config/fields/factories/password'
+require 'rails_admin/config/fields/factories/enum'
+require 'rails_admin/config/fields/factories/devise'
+require 'rails_admin/config/fields/factories/paperclip'
+require 'rails_admin/config/fields/factories/dragonfly'
+require 'rails_admin/config/fields/factories/carrierwave'