upstream-rails_admin 1.0.2

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

@@ -0,0 +1,22 @@
+require 'rails_admin/config/fields/types/text'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Serialized < RailsAdmin::Config::Fields::Types::Text
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+          
+          register_instance_option :formatted_value do
+            YAML.dump value
+          end
+          
+          def parse_input(params)
+            params[name] = (params[name].blank? ? nil : YAML.load(params[name])) if params[name].is_a?(::String)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class String < RailsAdmin::Config::Fields::Base
+
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option(:html_attributes) do
+            {
+              :maxlength => length,
+              :size => [50, length.to_i].min
+            }
+           end
+
+          register_instance_option(:help) do
+            text = (required? ? I18n.translate("admin.form.required") : I18n.translate("admin.form.optional")) + '. '
+            if valid_length.present? && valid_length[:is].present?
+              text += "#{I18n.translate("admin.form.char_length_of").capitalize} #{valid_length[:is]}."
+            else
+              max_length = [length, valid_length[:maximum] || nil].compact.min
+              min_length = [0, valid_length[:minimum] || nil].compact.max
+              if min_length == 0
+                text += "#{I18n.translate("admin.form.char_length_up_to").capitalize} #{max_length}."
+              else
+                text += "#{I18n.translate("admin.form.char_length_of").capitalize} #{min_length}-#{max_length}."
+              end
+            end
+            text
+          end
+
+          register_instance_option(:partial) do
+            :form_field
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Text < RailsAdmin::Config::Fields::Base
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+          
+          # CKEditor is disabled by default
+          register_instance_option(:ckeditor) do
+            false
+          end
+
+          # If you want to have a different toolbar configuration for CKEditor
+          # create your own custom config.js and override this configuration
+          register_instance_option(:ckeditor_config_js) do
+            "/assets/ckeditor/config.js"
+          end
+
+          register_instance_option(:html_attributes) do
+            {
+              :cols => "48",
+              :rows => "3"
+            }
+          end
+
+          register_instance_option(:partial) do
+            :form_text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'rails_admin/config/fields/types/datetime'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Time < RailsAdmin::Config::Fields::Types::Datetime
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          @format = :short
+          @i18n_scope = [:time, :formats]
+          @js_plugin_options = {
+            "showDate" => false,
+          }
+
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          def parse_input(params)
+            params[name] = self.class.normalize(params[name], localized_time_format) if params[name].present?
+          end
+
+          # Parse normalized date (time) strings using UTC
+          def self.parse_date_string(date_string)
+            ::DateTime.parse(date_string)
+          end
+
+          register_instance_option(:strftime_format) do
+            (localized_format.include? "%p") ? "%I:%M %p" : "%H:%M"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'rails_admin/config/fields/types/datetime'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Timestamp < RailsAdmin::Config::Fields::Types::Datetime
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          @format = :long
+          @i18n_scope = [:time, :formats]
+          @js_plugin_options = {}
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/groupable.rb

@@ -0,0 +1,18 @@
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module Groupable
+      # Register a group instance variable and accessor methods for objects
+      # extending the has groups mixin. The extended objects must implement
+      # reader for a parent object which includes this module.
+      #
+      # @see RailsAdmin::Config::HasGroups.group
+      # @see RailsAdmin::Config::Fields::Group
+      def group(name = nil)
+        @group = parent.group(name) unless name.nil? # setter
+        @group ||= parent.group(:default) # getter
+      end
+    end
+  end
+end

data/lib/rails_admin/config/has_fields.rb

@@ -0,0 +1,135 @@
+module RailsAdmin
+  module Config
+    # Provides accessors and autoregistering of model's fields.
+    module HasFields
+      # Defines a configuration for a field.
+      def field(name, type = nil, add_to_section = true, &block)
+        field = _fields.find {|f| name == f.name }
+
+        # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
+        # unhide them if config specifically defines them
+        field.show if field.try(:hidden?)
+
+        # Specify field as virtual if type is not specifically set and field was not
+        # found in default stack
+        if field.nil? && type.nil?
+          field = (_fields << RailsAdmin::Config::Fields::Types.load(:string).new(self, name, {})).last
+
+        # Register a custom field type if one is provided and it is different from
+        # one found in default stack
+        elsif !type.nil? && type != (field.nil? ? nil : field.type)
+          _fields.delete(field) unless field.nil?
+          properties = abstract_model.properties.find {|p| name == p[:name] }
+          field = (_fields <<  RailsAdmin::Config::Fields::Types.load(type).new(self, name, properties)).last
+        end
+
+        # If field has not been yet defined add some default properties
+        if add_to_section && !field.defined
+          field.defined = true
+          field.order = _fields.select(&:defined).length
+        end
+
+        # If a block has been given evaluate it and sort fields after that
+        if block
+          field.instance_eval &block
+        end
+        field
+      end
+
+      # configure a field without adding it.
+      def configure(name, type = nil, &block)
+        field(name, type, false, &block)
+      end
+
+      # include fields by name and apply an optionnal block to each (through a call to fields),
+      # or include fields by conditions if no field names
+      def include_fields(*field_names, &block)
+        if field_names.empty?
+          _fields.select {|f| f.instance_eval &block }.each do |f|
+            unless f.defined
+              f.defined = true
+              f.order = _fields.select(&:defined).length
+            end
+          end
+        else
+          fields(*field_names, &block)
+        end
+      end
+
+      # exclude fields by name or by condition (block)
+      def exclude_fields(*field_names, &block)
+        block ||= lambda { |f| field_names.include?(f.name) }
+        _fields.each {|f| f.defined = true } if _fields.select(&:defined).empty?
+        _fields.select {|f| f.instance_eval &block }.each {|f| f.defined = false }
+      end
+
+      # API candy
+      alias :exclude_fields_if :exclude_fields
+      alias :include_fields_if :include_fields
+
+      def include_all_fields
+        include_fields_if() { true }
+      end
+
+
+      # Returns all field configurations for the model configuration instance. If no fields
+      # have been defined returns all fields. Defined fields are sorted to match their
+      # order property. If order was not specified it will match the order in which fields
+      # were defined.
+      #
+      # If a block is passed it will be evaluated in the context of each field
+      def fields(*field_names,&block)
+        return all_fields if field_names.empty? && !block
+
+        if field_names.empty?
+          defined = _fields.select {|f| f.defined }
+          defined = _fields if defined.empty?
+        else
+          defined = field_names.map{|field_name| _fields.find {|f| f.name == field_name } }
+        end
+        defined.map do |f|
+          unless f.defined
+            f.defined = true
+            f.order = _fields.select(&:defined).length
+          end
+          f.instance_eval(&block) if block
+          f
+        end
+      end
+
+      # Defines configuration for fields by their type.
+      def fields_of_type(type, &block)
+        _fields.select {|f| type == f.type }.map! {|f| f.instance_eval &block } if block
+      end
+
+      # Accessor for all fields
+      def all_fields
+        ((ro_fields = _fields(true)).select(&:defined).presence || ro_fields).map{|f| f.section = self; f }
+      end
+
+      # Get all fields defined as visible, in the correct order.
+      def visible_fields
+        i = 0
+        all_fields.map {|f| f.with(bindings) }.select(&:visible?).sort_by{|f| [f.order, i += 1] } # stable sort, damn
+      end
+
+      protected
+
+      # Raw fields.
+      # Recursively returns parent section's raw fields
+      # Duping it if accessed for modification.
+      def _fields(readonly = false)
+        return @_fields if @_fields
+        return @_ro_fields if readonly && @_ro_fields
+
+        unless self.class == RailsAdmin::Config::Sections::Base
+          # parent is RailsAdmin::Config::Model, recursion is on Section's classes
+          @_ro_fields ||= parent.send(self.class.superclass.to_s.underscore.split('/').last)._fields(true).freeze
+        else # recursion tail
+          @_ro_fields = @_fields = RailsAdmin::Config::Fields.factory(self)
+        end
+        readonly ? @_ro_fields : (@_fields ||= @_ro_fields.map(&:clone))
+      end
+    end
+  end
+end

data/lib/rails_admin/config/has_groups.rb

@@ -0,0 +1,23 @@
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module HasGroups
+      # Accessor for a group
+      #
+      # If group with given name does not yet exist it will be created. If a
+      # block is passed it will be evaluated in the context of the group
+      def group(name, &block)
+        group = parent.groups.find {|g| name == g.name }
+        group ||= (parent.groups << RailsAdmin::Config::Fields::Group.new(self, name)).last
+        group.tap{|g| g.section = self}.instance_eval &block if block
+        group
+      end
+
+      # Reader for groups that are marked as visible
+      def visible_groups
+        parent.groups.map {|f| f.section = self; f.with(bindings) }.select(&:visible?).select{|g| g.visible_fields.present?}
+      end
+    end
+  end
+end

data/lib/rails_admin/config/hideable.rb

@@ -0,0 +1,28 @@
+module RailsAdmin
+  module Config
+    # Defines a visibility configuration
+    module Hideable
+      # Visibility defaults to true.
+      def self.included(klass)
+        klass.register_instance_option(:visible?) do
+          !root.try :excluded?
+        end
+      end
+
+      # Reader whether object is hidden.
+      def hidden?
+        not visible
+      end
+
+      # Writer to hide object.
+      def hide(&block)
+        visible block ? proc { false == (instance_eval &block) } : false
+      end
+
+      # Writer to show field.
+      def show(&block)
+        visible block || true
+      end
+    end
+  end
+end

data/lib/rails_admin/config/model.rb

@@ -0,0 +1,88 @@
+require 'rails_admin/config'
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
+require 'rails_admin/config/hideable'
+require 'rails_admin/config/has_groups'
+require 'rails_admin/config/fields/group'
+require 'rails_admin/config/fields'
+require 'rails_admin/config/has_fields'
+require 'rails_admin/config/sections'
+require 'rails_admin/config/actions'
+
+
+module RailsAdmin
+  module Config
+    # Model specific configuration object.
+    class Model
+      include RailsAdmin::Config::Proxyable
+      include RailsAdmin::Config::Configurable
+      include RailsAdmin::Config::Hideable
+      include RailsAdmin::Config::Sections
+
+      attr_reader :abstract_model
+      attr_accessor :groups
+      attr_reader :parent, :root
+
+      def initialize(entity)
+        @parent = nil
+        @root = self
+
+        @abstract_model = begin
+          if entity.kind_of?(RailsAdmin::AbstractModel)
+            entity
+          elsif entity.kind_of?(Class) || entity.kind_of?(String) || entity.kind_of?(Symbol)
+            RailsAdmin::AbstractModel.new(entity)
+          else
+            RailsAdmin::AbstractModel.new(entity.class)
+          end
+        end
+        @groups = [ RailsAdmin::Config::Fields::Group.new(self, :default).tap {|g| g.label{I18n.translate("admin.form.basic_info")} } ]
+      end
+
+      def excluded?
+        @excluded ||= !RailsAdmin::AbstractModel.all.map(&:model_name).include?(abstract_model.try(:model_name))
+      end
+
+      def object_label
+        bindings[:object].send object_label_method
+      end
+
+      # The display for a model instance (i.e. a single database record).
+      # Unless configured in a model config block, it'll try to use :name followed by :title methods, then
+      # any methods that may have been added to the label_methods array via Configuration.
+      # Failing all of these, it'll return the class name followed by the model's id.
+      register_instance_option :object_label_method do
+        @object_label_method ||= Config.label_methods.find { |method| (@dummy_object ||= abstract_model.model.new).respond_to? method } || :rails_admin_default_object_label_method
+      end
+
+      register_instance_option :label do
+        (@label ||= {})[::I18n.locale] ||= abstract_model.model.model_name.human(:default => abstract_model.model.model_name.demodulize.underscore.humanize)
+      end
+
+      register_instance_option :label_plural do
+        (@label_plural ||= {})[::I18n.locale] ||= abstract_model.model.model_name.human(:count => 2, :default => label.pluralize)
+      end
+
+      register_instance_option :weight do
+        0
+      end
+
+      # parent node in navigation/breadcrumb
+      register_instance_option :parent do
+        @parent_model ||= begin
+          (klass = abstract_model.model.superclass).to_s.in?(['Object', 'BasicObject', 'ActiveRecord::Base']) ? nil : klass
+        end
+      end
+
+      register_instance_option :navigation_label do
+         @navigation_label ||= (parent_module = abstract_model.model.parent) != Object ? parent_module.to_s : nil
+      end
+
+      # Act as a proxy for the base section configuration that actually
+      # store the configurations.
+      def method_missing(m, *args, &block)
+        self.send(:base).send(m, *args, &block)
+      end
+    end
+  end
+end