upstream-rails_admin 1.0.2

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

@@ -0,0 +1,85 @@
+module RailsAdmin
+  module Config
+    module Actions
+      class Index < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+
+        register_instance_option :collection do
+          true
+        end
+
+        register_instance_option :http_methods do
+          [:get, :post]
+        end
+
+        register_instance_option :route_fragment do
+          ''
+        end
+
+        register_instance_option :breadcrumb_parent do
+          parent_model = bindings[:abstract_model].try(:config).try(:parent)
+          if am = parent_model && RailsAdmin.config(parent_model).try(:abstract_model)
+            [:index, am]
+          else
+            [:dashboard]
+          end
+        end
+
+        register_instance_option :controller do
+          Proc.new do
+            @objects ||= list_entries
+
+            respond_to do |format|
+
+              format.html do
+                render @action.template_name, :status => (flash[:error].present? ? :not_found : 200)
+              end
+
+              format.json do
+                output = if params[:compact]
+                  primary_key_method = @association ? @association.associated_primary_key : @model_config.abstract_model.primary_key
+                  label_method = @model_config.object_label_method
+                  @objects.map{ |o| { :id => o.send(primary_key_method), :label => o.send(label_method) } }
+                else
+                  @objects.to_json(@schema)
+                end
+                if params[:send_data]
+                  send_data output, :filename => "#{params[:model_name]}_#{DateTime.now.strftime("%Y-%m-%d_%Hh%Mm%S")}.json"
+                else
+                  render :json => output
+                end
+              end
+
+              format.xml do
+                output = @objects.to_xml(@schema)
+                if params[:send_data]
+                  send_data output, :filename => "#{params[:model_name]}_#{DateTime.now.strftime("%Y-%m-%d_%Hh%Mm%S")}.xml"
+                else
+                  render :xml => output
+                end
+              end
+
+              format.csv do
+                header, encoding, output = CSVConverter.new(@objects, @schema).to_csv(params[:csv_options])
+                if params[:send_data]
+                  send_data output,
+                    :type => "text/csv; charset=#{encoding}; #{"header=present" if header}",
+                    :disposition => "attachment; filename=#{params[:model_name]}_#{DateTime.now.strftime("%Y-%m-%d_%Hh%Mm%S")}.csv"
+                else
+                  render :text => output
+                end
+              end
+
+            end
+
+          end
+        end
+
+
+        register_instance_option :link_icon do
+          'icon-th-list'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module RailsAdmin
+  module Config
+    module Actions
+      class New < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+
+        register_instance_option :collection do
+          true
+        end
+
+        register_instance_option :http_methods do
+          [:get, :post] # NEW / CREATE
+        end
+
+        register_instance_option :controller do
+
+          Proc.new do
+
+            if request.get? # NEW
+
+              @object = @abstract_model.new
+              @authorization_adapter && @authorization_adapter.attributes_for(:new, @abstract_model).each do |name, value|
+                @object.send("#{name}=", value)
+              end
+              if object_params = params[@abstract_model.to_param]
+                @object.set_attributes(@object.attributes.merge(object_params), _attr_accessible_role)
+              end
+              respond_to do |format|
+                format.html { render @action.template_name }
+                format.js   { render @action.template_name, :layout => false }
+              end
+
+            elsif request.post? # CREATE
+
+              @modified_assoc = []
+              @object = @abstract_model.new
+              sanitize_params_for! :create
+              
+              @object.set_attributes(params[@abstract_model.param_key], _attr_accessible_role)
+              @authorization_adapter && @authorization_adapter.attributes_for(:create, @abstract_model).each do |name, value|
+                @object.send("#{name}=", value)
+              end
+              
+              if @object.save
+                @auditing_adapter && @auditing_adapter.create_object("Created #{@model_config.with(:object => @object).object_label}", @object, @abstract_model, _current_user)
+                respond_to do |format|
+                  format.html { redirect_to_on_success }
+                  format.js   { render :json => { :id => @object.id, :label => @model_config.with(:object => @object).object_label } }
+                end
+              else
+                handle_save_error
+              end
+
+            end
+          end
+        end
+
+        register_instance_option :link_icon do
+          'icon-plus'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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, bindings[:abstract_model]]
+        end
+
+        register_instance_option :controller do
+          Proc.new do
+            render @action.template_name
+          end
+        end
+
+
+        register_instance_option :link_icon do
+          'icon-info-sign'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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
+          authorized? && (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
+
+
+        register_instance_option :link_icon do
+          'icon-eye-open'
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/configurable.rb

@@ -0,0 +1,92 @@
+module RailsAdmin
+  module Config
+    # A module for all configurables.
+
+    module Configurable
+      def self.included(base)
+        base.send :extend, ClassMethods
+      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
+
+      module ClassMethods
+        # 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 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 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 register_class_option(option_name, &default)
+          scope = class << self; self; end;
+          self.register_instance_option(option_name, scope, &default)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/fields.rb

@@ -0,0 +1,88 @@
+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?(:model_proc)
+          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)
+        else
+          field = RailsAdmin::Config::Fields::Types.load(properties[:type]).new(parent, properties[:name], properties)
+        end
+        fields << field
+        field
+      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 = []
+        # 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.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.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'
+require 'rails_admin/config/fields/factories/association'
+require 'rails_admin/config/fields/factories/serialized'

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

@@ -0,0 +1,108 @@
+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) && !am.embedded?
+            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), :class => 'pjax') : wording
+          end.to_sentence.html_safe
+        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[:model_proc].call)
+        end
+
+        # Reader for the association's child model object's label method
+        def associated_object_label_method
+          @associated_object_label_method ||= associated_model_config.object_label_method
+        end
+        
+        # Reader for associated primary key
+        def associated_primary_key
+          @associated_primary_key ||= association[:primary_key_proc].call
+        end
+        
+        # Reader for the association's key
+        def foreign_key
+          association[:foreign_key]
+        end
+
+        # Reader for the inverse relationship
+        def inverse_of
+          association[:inverse_of]
+        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
+        
+        # has many?
+        def multiple?
+          true
+        end
+        
+        def virtual?
+          true
+        end
+      end
+    end
+  end
+end