elucid-rails_admin 0.0.1

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

@@ -0,0 +1,34 @@
+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)
+
+          @view_helper = :text_field
+
+          register_instance_option(:html_attributes) do
+            {
+              :class => css_class,
+              :maxlength => length,
+              :size => [50, length.to_i].min
+            }
+           end
+
+          register_instance_option(:help) do
+            text = (required? ? I18n.translate("admin.new.required") : I18n.translate("admin.new.optional")) + '. '
+            text += "#{length} #{length == 1 ? I18n.translate("admin.new.one_char") : I18n.translate("admin.new.many_chars")}." if length.present?
+            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,39 @@
+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)
+
+          @view_helper = :text_area
+
+          # 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
+            "/javascripts/ckeditor/config.js"
+          end
+
+          register_instance_option(:html_attributes) do
+            {
+              :class => css_class,
+              :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,31 @@
+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]
+          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/has_fields.rb

@@ -0,0 +1,112 @@
+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, &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 = parent.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
+        unless 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
+          @fields.sort! {|a, b| a.order <=> b.order }
+        end
+        field
+      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
+
+      # does pretty much what it says in the can
+      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)
+        if field_names.empty?
+          defined = @fields.select {|f| f.defined }
+          defined.sort! {|a, b| a.order <=> b.order }
+          defined = @fields if defined.empty?
+          if block
+            defined.each {|f| f.instance_eval &block }
+          end
+          defined
+        else
+          defined = field_names.map{|field_name| @fields.find {|f| f.name == field_name } }
+          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
+      end
+
+      # Defines configuration for fields by their type.
+      def fields_of_type(type, &block)
+        selected = @fields.select {|f| type == f.type }
+        if block
+          selected.each {|f| f.instance_eval &block }
+        end
+        selected
+      end
+
+      # Get all fields defined as visible.
+      def visible_fields
+        fields.select {|f| f.with(bindings).visible? }.map{|f| f.with(bindings)}
+      end
+    end
+  end
+end

data/lib/rails_admin/config/has_groups.rb

@@ -0,0 +1,39 @@
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module HasGroups
+      # Access fields by their group
+      def fields_of_group(group, &block)
+        selected = @fields.select {|f| group == f.group }
+        if block
+          selected.each {|f| f.instance_eval &block }
+        end
+        selected
+      end
+
+      # 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 = @groups.find {|g| name == g.name }
+        if group.nil?
+          group = (@groups << RailsAdmin::Config::Fields::Group.new(self, name)).last
+        end
+        group.instance_eval &block if block
+        group
+      end
+
+      # Reader for groups
+      def groups
+        @groups
+      end
+
+      # Reader for groups that are marked as visible
+      def visible_groups
+        groups.select {|g| g.visible? }
+      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.excluded?
+        end
+      end
+
+      # Reader whether field is hidden.
+      def hidden?
+        not visible
+      end
+
+      # Writer to hide field.
+      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,89 @@
+require 'rails_admin/config'
+require 'rails_admin/config/base'
+require 'rails_admin/config/sections'
+
+module RailsAdmin
+  module Config
+    # Model specific configuration object.
+    class Model < RailsAdmin::Config::Base
+      include RailsAdmin::Config::Hideable
+      include RailsAdmin::Config::Sections
+
+      def initialize(entity)
+        @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
+        @bindings = {}
+        @parent = nil
+        @root = self
+      end
+
+      def excluded?
+        @excluded ||= !RailsAdmin::AbstractModel.all.map(&:model).include?(abstract_model.model)
+      end
+
+      # Configure create and update views as a bulk operation with given block
+      # or get update view's configuration if no block is given
+      def edit(&block)
+        return send(:update) unless block_given?
+        [:create, :update].each do |s|
+          send(s, &block)
+        end
+      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 ||= abstract_model.model.model_name.human(:default => abstract_model.model.model_name.demodulize.underscore.humanize)
+      end
+
+      register_instance_option(:label_plural) do
+        @label_plural ||= abstract_model.model.model_name.human(:count => 2, :default => label.pluralize)
+      end
+
+      register_instance_option(:weight) do
+        0
+      end
+
+      register_instance_option(:parent) do
+        :root
+      end
+
+      register_deprecated_instance_option(:dropdown, :navigation_label) # same API, deprecated 2011-07-21
+
+      register_instance_option(:navigation_label) do
+        false
+      end
+
+      # Act as a proxy for the section configurations that actually
+      # store the configurations.
+      def method_missing(m, *args, &block)
+        responded_to = false
+        [:create, :list, :show, :navigation, :update, :export].each do |s|
+          section = send(s)
+          if section.respond_to?(m)
+            responded_to = true
+            section.send(m, *args, &block)
+          end
+        end
+        raise NoMethodError.new("#{self} has no method #{m}") unless responded_to
+      end
+    end
+  end
+end

data/lib/rails_admin/config/proxy.rb

@@ -0,0 +1,40 @@
+module RailsAdmin
+  module Config
+    class Proxy
+
+      instance_methods.each {|m| undef_method m unless m =~ /^(__|instance_eval|object_id)/ }
+
+      attr_reader :bindings
+
+      def initialize(object, bindings = {})
+        @object = object
+        @bindings = bindings
+      end
+
+      # Bind variables to be used by the configuration options
+      def bind(key, value = nil)
+        if key.kind_of?(Hash)
+          @bindings = key
+        else
+          @bindings[key] = value
+        end
+        self
+      end
+
+      def method_missing(name, *args, &block)
+        if @object.respond_to?(name)
+          reset = @object.instance_variable_get("@bindings")
+          begin
+            @object.instance_variable_set("@bindings", @bindings)
+            response = @object.__send__(name, *args, &block)
+          ensure
+            @object.instance_variable_set("@bindings", @reset)
+          end
+          response
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/config/sections/create'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/config/sections/navigation'
+require 'rails_admin/config/sections/update'
+require 'rails_admin/config/sections/export'
+require 'rails_admin/config/sections/show'
+
+module RailsAdmin
+  module Config
+    # Sections describe different views in the RailsAdmin engine. Configurable sections are
+    # list and navigation.
+    #
+    # Each section's class object can store generic configuration about that section (such as the
+    # number of visible tabs in the main navigation), while the instances (accessed via model
+    # configuration objects) store model specific configuration (such as the visibility of the
+    # model).
+    module Sections
+      def self.included(klass)
+        # Register accessors for all the sections in this namespace
+        constants.each do |name|
+          section = "RailsAdmin::Config::Sections::#{name}".constantize
+          name = name.to_s.downcase.to_sym
+          klass.send(:define_method, name) do |&block|
+            @sections = {} unless @sections
+            unless @sections[name]
+              @sections[name] = section.new(self)
+            end
+            @sections[name].instance_eval &block if block
+            @sections[name]
+          end
+          # Register a shortcut to define the model's label for each section.
+          klass.send(:define_method, "label_for_#{name}") do
+            # TODO: Remove this warning in the next release, after people have updated their applications
+            $stderr.puts("WARNING: label_for_#{name} has been removed. This configuration will be ignored. Model names can be configured with 'label' and section-specific names are no longer supported. See README for details.")
+          end
+          # Register a shortcut to hide the model for each section.
+          klass.send(:define_method, "hide_from_#{name}") do |&block|
+            # TODO: Remove this warning in the next release, after people have updated their applications
+            $stderr.puts("WARNING: hide_from_#{name} has been removed. This configuration will be ignored. Model visibility can be configured with 'hide', 'show' and 'visibility'. Section-specific visibility is no longer supported. See README for details.")
+          end
+          # Register a shortcut to show the model for each section.
+          klass.send(:define_method, "show_in_#{name}") do |&block|
+            # TODO: Remove this warning in the next release, after people have updated their applications
+            $stderr.puts("WARNING: show_in_#{name} has been removed. This configuration will be ignored. Model visibility can be configured with 'hide', 'show' and 'visibility'. Section-specific visibility is no longer supported. See README for details.")
+          end
+        end
+      end
+    end
+  end
+end