drewda_rails_admin 0.0.1

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

@@ -0,0 +1,21 @@
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Hidden < RailsAdmin::Config::Fields::Base
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option :view_helper do
+            :hidden_field
+          end
+          
+          register_instance_option(:partial) do
+            :form_field
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Integer < RailsAdmin::Config::Fields::Base
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option :view_helper do
+            :number_field
+          end
+
+          register_instance_option(:sort_reverse?) do
+            serial?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'rails_admin/config/fields/types/string'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class MongoidType < RailsAdmin::Config::Fields::Types::String
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option(:label) do
+            "Type"
+          end
+
+          register_instance_option(:visible) do
+            false
+          end
+        end
+      end
+    end
+  end
+end
+
+
+

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

@@ -0,0 +1,28 @@
+require 'rails_admin/config/fields/base'
+require 'rails_admin/config/fields/types/file_upload'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        # Field type that supports Paperclip file uploads
+        class Paperclip < RailsAdmin::Config::Fields::Types::FileUpload
+          RailsAdmin::Config::Fields::Types.register(self)
+
+          register_instance_option(:delete_method) do
+            "delete_#{name}" if bindings[:object].respond_to?("delete_#{name}")
+          end
+
+          register_instance_option(:thumb_method) do
+            @styles ||= bindings[:object].send(name).styles.map(&:first)
+            @thumb_method ||= @styles.find{|s| [:thumb, 'thumb', :thumbnail, 'thumbnail'].include?(s)} || @styles.first || :original
+          end
+
+          def resource_url(thumb = false)
+            value.try(:url, (thumb || :original))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'rails_admin/config/fields/types/string'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Password < RailsAdmin::Config::Fields::Types::String
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option :view_helper do
+            :password_field
+          end
+
+          def parse_input(params)
+            params[name] = params[name].presence
+          end
+
+          register_instance_option :formatted_value do
+            "".html_safe
+          end
+
+          # Password field's value does not need to be read
+          def value
+            ""
+          end
+
+          register_instance_option :visible do
+            self.section.is_a?(RailsAdmin::Config::Sections::Edit)
+          end
+
+          register_instance_option :pretty_value do
+            '*****'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'rails_admin/config/fields/types/belongs_to_association'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class PolymorphicAssociation < RailsAdmin::Config::Fields::Types::BelongsToAssociation
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types::register(self)
+
+          register_instance_option(:partial) do
+            :form_polymorphic_association
+          end
+
+          # Accessor whether association is visible or not. By default
+          # association checks that any of the child models are included in
+          # configuration.
+          register_instance_option(:visible?) do
+            associated_model_config.length > 0
+          end
+
+          register_instance_option(:sortable) do
+            false
+          end
+
+          register_instance_option(:searchable) do
+            false
+          end
+
+          # TODO not supported yet
+          register_instance_option :associated_collection_cache_all do
+            false
+          end
+
+          # TODO not supported yet
+          register_instance_option :associated_collection_scope do
+            nil
+          end
+
+          def associated_collection(type)
+            return [] if type.blank?
+            config = RailsAdmin.config(type)
+            config.abstract_model.all.map do |object|
+              [object.send(config.object_label_method), object.id]
+            end
+          end
+
+          def associated_model_config
+            @associated_model_config ||= association[:model_proc].call.map{|type| RailsAdmin.config(type) }.select{|config| !config.excluded? }
+          end
+
+          def polymorphic_type_collection
+            associated_model_config.map do |config|
+              [config.label, config.abstract_model.model.name]
+            end
+          end
+
+          def polymorphic_type_urls
+            types = associated_model_config.map do |config|
+              [config.abstract_model.model.name, config.abstract_model.to_param]
+            end
+
+            ::Hash[*types.collect { |v|
+                  [v[0], bindings[:view].index_path(v[1])]
+                }.flatten]
+          end
+
+          # Reader for field's value
+          def value
+            bindings[:object].send(association[:name])
+          end
+        end
+      end
+    end
+  end
+end

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