obitum-rails_admin 0.0.1

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

@@ -0,0 +1,27 @@
+module RailsAdmin
+  module Config
+    module Actions
+      class Show < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+        
+        register_instance_option :member do
+          true
+        end
+        
+        register_instance_option :route_fragment do
+          ''
+        end
+        
+        register_instance_option :breadcrumb_parent do
+          :index
+        end
+        
+        register_instance_option :controller do
+          Proc.new do
+            render @action.template_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module RailsAdmin
+  module Config
+    module Actions
+      class ShowInApp < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+        
+        register_instance_option :member do
+          true
+        end
+        
+        register_instance_option :visible? do
+          bindings[:controller].main_app.url_for(bindings[:object]) rescue false
+        end
+        
+        register_instance_option :controller do
+          Proc.new do
+            redirect_to main_app.url_for(@object)
+          end
+        end
+      end
+    end
+  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 = nil)
+        @abstract_model = parent && parent.abstract_model
+        @bindings = {}
+        @parent = parent
+        @root = parent && 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,97 @@
+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)
+          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'

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

@@ -0,0 +1,115 @@
+require 'rails_admin/config'
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      class Association < RailsAdmin::Config::Fields::Base
+
+        def self.inherited(klass)
+          super(klass)
+        end
+
+        # Reader for the association information hash
+        def association
+          @properties
+        end
+
+        register_instance_option(:pretty_value) do
+          v = bindings[:view]
+          [value].flatten.select(&:present?).map do |associated|
+            amc = polymorphic? ? RailsAdmin::Config.model(associated) : associated_model_config # perf optimization for non-polymorphic associations
+            am = amc.abstract_model
+            wording = associated.send(amc.object_label_method)
+            can_see = v.authorized?(:show, am, associated)
+            can_see = can_see && (show_action = RailsAdmin::Config::Actions.find(:show, { :controller => v.controller, :abstract_model => am, :object => associated }))
+            can_see ? v.link_to(wording, v.url_for(:action => show_action.action_name, :model_name => am.to_param, :id => associated.id)) : wording
+          end.to_sentence.html_safe
+        end
+
+        register_instance_option(:sortable) do
+          false
+        end
+
+        register_instance_option(:searchable) do
+          false
+        end
+
+        # Accessor whether association is visible or not. By default
+        # association checks whether the child model is excluded in
+        # configuration or not.
+        register_instance_option(:visible?) do
+          @visible ||= !self.associated_model_config.excluded?
+        end
+
+        # 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]
+        end
+
+        # scope for possible associable records
+        register_instance_option :associated_collection_scope do
+          # bindings[:object] & bindings[:controller] available
+          associated_collection_scope_limit = (self.associated_collection_cache_all ? nil : 30)
+          Proc.new do |scope|
+            scope.limit(associated_collection_scope_limit)
+          end
+        end
+
+        # preload entire associated collection (per associated_collection_scope) on load
+        # Be sure to set limit in associated_collection_scope if set is large
+        register_instance_option :associated_collection_cache_all do
+          @associated_collection_cache_all ||= (associated_model_config.abstract_model.count < 100)
+        end
+
+        # Reader for the association's child model's configuration
+        def associated_model_config
+          @associated_model_config ||= RailsAdmin.config(association[:child_model])
+        end
+
+        # Reader for the association's child model object's label method
+        def associated_label_method
+          @associated_label_method ||= associated_model_config.object_label_method
+        end
+
+        # Reader for the association's child key
+        def child_key
+          association[:child_key]
+        end
+
+        # Reader for the inverse relationship
+        def inverse_of
+          association[:inverse_of]
+        end
+
+        # we need to check for validation on method and on association
+        register_instance_option :required? do
+          @required ||= !!(abstract_model.model.validators_on(name) + abstract_model.model.validators_on(method_name)).find do |v|
+            v.is_a?(ActiveModel::Validations::PresenceValidator) && !v.options[:allow_nil] ||
+            v.is_a?(ActiveModel::Validations::NumericalityValidator) && !v.options[:allow_nil]
+          end
+        end
+
+        # Reader for validation errors of the bound object
+        def errors
+          bindings[:object].errors[association[:name]] + bindings[:object].errors[child_key]
+        end
+
+        # Reader whether this is a polymorphic association
+        def polymorphic?
+          association[:polymorphic]
+        end
+        
+        # Reader for nested attributes
+        register_instance_option :nested_form do
+          association[:nested_form]
+        end
+
+        # Reader for the association's value unformatted
+        def value
+          bindings[:object].send(association[:name])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,274 @@
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/config/base'
+require 'rails_admin/config/hideable'
+require 'rails_admin/config/fields'
+require 'rails_admin/config/fields/association'
+require 'rails_admin/config/fields/groupable'
+
+
+module RailsAdmin
+  module Config
+    module Fields
+      class Base < RailsAdmin::Config::Base
+        attr_reader :name, :properties
+        attr_accessor :defined, :order, :section
+
+        def self.inherited(klass)
+          klass.instance_variable_set("@view_helper", :text_field)
+        end
+
+        include RailsAdmin::Config::Hideable
+
+        def initialize(parent, name, properties)
+          super(parent)
+          
+          @defined = false
+          @name = name
+          @order = 0
+          @properties = properties
+          @section = parent
+          
+          extend RailsAdmin::Config::Fields::Groupable
+        end
+
+        register_instance_option(:css_class) do
+          "#{self.name}_field"
+        end
+        
+        def type_css_class
+          "#{type}_type"
+        end
+        
+        def virtual?
+          properties.blank?
+        end
+
+        register_instance_option(:column_width) do
+          nil
+        end
+        
+        register_instance_option(:sortable) do
+          !virtual?
+        end
+
+        register_instance_option(:searchable) do
+          !virtual?
+        end
+
+        register_instance_option(:queryable?) do
+          !!searchable
+        end
+
+        register_instance_option(:filterable?) do
+          !!searchable
+        end
+
+        register_instance_option(:search_operator) do
+          @search_operator ||= RailsAdmin::Config.default_search_operator
+        end
+
+        # serials and dates are reversed in list, which is more natural (last modified items first).
+        register_instance_option(:sort_reverse?) do
+          false
+        end
+
+        # 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 self.searchable
+          when true
+            [{ :column => "#{self.abstract_model.model.table_name}.#{self.name}", :type => self.type }]
+          when false
+            []
+          when :all # valid only for associations
+            table_name = self.associated_model_config.abstract_model.model.table_name
+            self.associated_model_config.list.fields.map { |f| { :column => "#{table_name}.#{f.name}", :type => f.type } }
+          else
+            [self.searchable].flatten.map do |f|
+              if f.is_a?(String) && f.include?('.')                            #  table_name.column
+                table_name, column = f.split '.'
+                type = nil
+              elsif f.is_a?(Hash)                                              #  <Model|table_name> => <attribute|column>
+                am = AbstractModel.new(f.keys.first.to_s.classify)
+                table_name = am && am.model.table_name || f.keys.first
+                column = f.values.first
+                property = am && am.properties.find{ |p| p[:name] == f.values.first.to_sym }
+                type = property && property[:type]
+              else                                                             #  <attribute|column>
+                am = (self.association? ? self.associated_model_config.abstract_model : self.abstract_model)
+                table_name = am.model.table_name
+                column = f
+                property = am.properties.find{ |p| p[:name] == f.to_sym }
+                type = property && property[:type]
+              end
+
+              { :column => "#{table_name}.#{column}", :type => (type || :string) }
+            end
+          end
+        end
+
+        register_instance_option(:formatted_value) do
+          value.to_s
+        end
+
+        # output for pretty printing (show, list)
+        register_instance_option(:pretty_value) do
+          formatted_value.presence || ' - '
+        end
+
+        # output for printing in export view (developers beware: no bindings[:view] and no data!)
+        register_instance_option(:export_value) do
+          pretty_value
+        end
+
+
+        # Accessor for field's help text displayed below input field.
+        register_instance_option(:help) do
+          (@help ||= {})[::I18n.locale] ||= (required? ? I18n.translate("admin.form.required") : I18n.translate("admin.form.optional")) + '. '
+        end
+
+        register_instance_option(:html_attributes) do
+          {}
+        end
+        
+        register_instance_option :default_value do
+          nil
+        end
+
+        # Accessor for field's label.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option(:label) do
+          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name name
+        end
+
+        # Accessor for field's maximum length per database.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option(:length) do
+          @length ||= properties && properties[:length]
+        end
+
+        # Accessor for field's length restrictions per validations
+        #
+        register_instance_option(:valid_length) do
+          @valid_length ||= abstract_model.model.validators_on(name).find{|v|
+            v.is_a?(ActiveModel::Validations::LengthValidator)}.try{|v| v.options} || {}
+        end
+
+        register_instance_option(:partial) do
+          :form_field
+        end
+
+        # Accessor for whether this is field is mandatory.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option(:required?) do
+          @required ||= !!abstract_model.model.validators_on(name).find do |v|
+            v.is_a?(ActiveModel::Validations::PresenceValidator) && !v.options[:allow_nil] ||
+            v.is_a?(ActiveModel::Validations::NumericalityValidator) && !v.options[:allow_nil]
+          end
+        end
+
+        # Accessor for whether this is a serial field (aka. primary key, identifier).
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option(:serial?) do
+          properties && properties[:serial?]
+        end
+
+        register_instance_option(:view_helper) do
+          @view_helper ||= self.class.instance_variable_get("@view_helper")
+        end
+        
+        register_instance_option :read_only do
+          not editable
+        end
+        
+        register_instance_option :visible? do
+          returned = true
+          (RailsAdmin.config.default_hidden_fields || {}).each do |section, fields|
+            if self.section.is_a?("RailsAdmin::Config::Sections::#{section.to_s.camelize}".constantize)
+              returned = false if fields.include?(self.name)
+            end
+          end
+          returned
+        end
+        
+        def editable
+          return false if @properties && @properties[:read_only]
+          role = bindings[:view].controller.send(:_attr_accessible_role)
+          klass = bindings[:object].class
+          whitelist = klass.accessible_attributes(role).map(&:to_s)
+          blacklist = klass.protected_attributes(role).map(&:to_s)
+          !self.method_name.to_s.in?(blacklist) && (whitelist.any? ? self.method_name.to_s.in?(whitelist) : true)
+        end
+        
+        def render
+          bindings[:view].render :partial => partial.to_s, :locals => {:field => self, :form => bindings[:form] }
+        end
+
+        # Is this an association
+        def association?
+          kind_of?(RailsAdmin::Config::Fields::Association)
+        end
+
+        # Reader for validation errors of the bound object
+        def errors
+          bindings[:object].errors[name]
+        end
+
+        # Reader whether field is optional.
+        #
+        # @see RailsAdmin::Config::Fields::Base.register_instance_option(:required?)
+        def optional?
+          not required
+        end
+
+        # Inverse accessor whether this field is required.
+        #
+        # @see RailsAdmin::Config::Fields::Base.register_instance_option(:required?)
+        def optional(state = nil, &block)
+          if !state.nil? || block
+            required state.nil? ? proc { false == (instance_eval &block) } : false == state
+          else
+            optional?
+          end
+        end
+
+        # Writer to make field optional.
+        #
+        # @see RailsAdmin::Config::Fields::Base.optional
+        def optional=(state)
+          optional(state)
+        end
+
+        # Reader for field's type
+        def type
+          @type ||= self.class.name.to_s.demodulize.underscore.to_sym
+        end
+
+        # Reader for field's value
+        def value
+          bindings[:object].safe_send(name)
+        end
+        
+        # Reader for nested attributes
+        def nested_form
+          false
+        end
+        
+        def inverse_of
+          nil
+        end
+
+        def method_name
+          name
+        end
+        
+        def _html_attributes
+          html_attributes.merge(!default_value.nil? ? { :value => default_value } : {})
+        end
+      end
+    end
+  end
+end