rails_admin-lbgraham 0.4.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,43 @@
+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 max_length
+                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
+            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,97 @@
+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
+            nil
+          end
+
+          #Use this if you want to point to a cloud instances of CKeditor
+          register_instance_option :ckeditor_location do
+            nil
+          end
+
+          #Use this if you want to point to a cloud instances of the base CKeditor
+          register_instance_option :ckeditor_base_location do
+            '/assets/ckeditor/'
+          end
+
+          # Codemirror is disabled by default and CKEditor takes precedence
+          register_instance_option :codemirror do
+            false
+          end
+
+          #Pass the theme and mode for Codemirror
+          register_instance_option :codemirror_config do
+            {
+              :mode => 'css',
+              :theme => 'night'
+            }
+          end
+
+          #Pass the location of the theme and mode for Codemirror
+          register_instance_option :codemirror_assets do
+            {
+              :mode => '/assets/codemirror/modes/css.js',
+              :theme => '/assets/codemirror/themes/night.css'
+            }
+          end
+
+          #Use this if you want to point to a cloud instances of CodeMirror
+          register_instance_option :codemirror_js_location do
+            '/assets/codemirror.js'
+          end
+
+          #Use this if you want to point to a cloud instances of CodeMirror
+          register_instance_option :codemirror_css_location do
+            '/assets/codemirror.css'
+          end
+
+          # bootstrap_wysihtml5
+          register_instance_option :bootstrap_wysihtml5 do
+            false
+          end
+
+          # If you want to have a different toolbar configuration for wysihtml5
+          # you can use a Ruby hash to configure these options:
+          # https://github.com/jhollingworth/bootstrap-wysihtml5/#advanced
+          register_instance_option :bootstrap_wysihtml5_config_options do
+            nil
+          end
+
+          register_instance_option :bootstrap_wysihtml5_css_location do
+            '/assets/bootstrap-wysihtml5.css'
+          end
+
+          register_instance_option :bootstrap_wysihtml5_js_location do
+            '/assets/bootstrap-wysihtml5.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,136 @@
+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
+        if field
+          field.show unless field.instance_variable_get("@#{field.name}_registered").is_a?(Proc)
+        end
+        # 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/lazy_model.rb

@@ -0,0 +1,21 @@
+require 'rails_admin/config/model'
+
+module RailsAdmin
+  module Config
+    class LazyModel
+      def initialize(entity, &block)
+        @entity = entity
+        @deferred_block = block
+      end
+
+      def method_missing(method, *args, &block)
+        if !@model
+          @model = RailsAdmin::Config::Model.new(@entity)
+          @model.instance_eval(&@deferred_block) if @deferred_block
+        end
+
+        @model.send(method, *args, &block)
+      end
+    end
+  end
+end