drewda_rails_admin 0.0.1

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)
+            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)) : 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

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

@@ -0,0 +1,281 @@
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
+require 'rails_admin/config/hideable'
+require 'rails_admin/config/groupable'
+
+module RailsAdmin
+  module Config
+    module Fields
+      class Base
+        include RailsAdmin::Config::Proxyable
+        include RailsAdmin::Config::Configurable
+        include RailsAdmin::Config::Hideable
+        include RailsAdmin::Config::Groupable
+        
+        attr_reader :name, :properties, :abstract_model
+        attr_accessor :defined, :order, :section
+        attr_reader :parent, :root
+
+        def initialize(parent, name, properties)
+          @parent = parent
+          @root = parent.root
+
+          @abstract_model = parent.abstract_model
+          @defined = false
+          @name = name
+          @order = 0
+          @properties = properties
+          @section = parent
+        end
+
+        register_instance_option :css_class do
+          "#{self.name}_field"
+        end
+
+        def type_css_class
+          "#{type}_type"
+        end
+
+        def virtual?
+          properties.blank?
+        end
+
+        register_instance_option :column_width do
+          nil
+        end
+
+        register_instance_option :sortable do
+          !virtual? || children_fields.first || false
+        end
+
+        register_instance_option :searchable do
+          !virtual? || children_fields.first || false
+        end
+
+        register_instance_option :queryable? do
+          !virtual?
+        end
+
+        register_instance_option :filterable? do
+          !!searchable
+        end
+
+        register_instance_option :search_operator do
+          @search_operator ||= RailsAdmin::Config.default_search_operator
+        end
+
+        # serials and dates are reversed in list, which is more natural (last modified items first).
+        register_instance_option :sort_reverse? do
+          false
+        end
+
+        # list of columns I should search for that field [{ :column => 'table_name.column', :type => field.type }, {..}]
+        register_instance_option :searchable_columns do
+          @searchable_columns ||= case self.searchable
+          when true
+            [{ :column => "#{self.abstract_model.table_name}.#{self.name}", :type => self.type }]
+          when false
+            []
+          when :all # valid only for associations
+            table_name = self.associated_model_config.abstract_model.table_name
+            self.associated_model_config.list.fields.map { |f| { :column => "#{table_name}.#{f.name}", :type => f.type } }
+          else
+            [self.searchable].flatten.map do |f|
+              if f.is_a?(String) && f.include?('.')                            #  table_name.column
+                table_name, column = f.split '.'
+                type = nil
+              elsif f.is_a?(Hash)                                              #  <Model|table_name> => <attribute|column>
+                am = f.keys.first.is_a?(Class) && AbstractModel.new(f.keys.first)
+                table_name = am && am.table_name || f.keys.first
+                column = f.values.first
+                property = am && am.properties.find{ |p| p[:name] == f.values.first.to_sym }
+                type = property && property[:type]
+              else                                                             #  <attribute|column>
+                am = (self.association? ? self.associated_model_config.abstract_model : self.abstract_model)
+                table_name = am.table_name
+                column = f
+                property = am.properties.find{ |p| p[:name] == f.to_sym }
+                type = property && property[:type]
+              end
+
+              { :column => "#{table_name}.#{column}", :type => (type || :string) }
+            end
+          end
+        end
+
+        register_instance_option :formatted_value do
+          value.to_s
+        end
+
+        # output for pretty printing (show, list)
+        register_instance_option :pretty_value do
+          formatted_value.presence || ' - '
+        end
+
+        # output for printing in export view (developers beware: no bindings[:view] and no data!)
+        register_instance_option :export_value do
+          pretty_value
+        end
+
+
+        # Accessor for field's help text displayed below input field.
+        register_instance_option :help do
+          (@help ||= {})[::I18n.locale] ||= (required? ? I18n.translate("admin.form.required") : I18n.translate("admin.form.optional")) + '. '
+        end
+
+        register_instance_option :html_attributes do
+          {}
+        end
+
+        register_instance_option :default_value do
+          nil
+        end
+
+        # Accessor for field's label.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option :label do
+          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name name
+        end
+
+        # Accessor for field's maximum length per database.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option :length do
+          @length ||= properties && properties[:length]
+        end
+
+        # Accessor for field's length restrictions per validations
+        #
+        register_instance_option :valid_length do
+          @valid_length ||= abstract_model.model.validators_on(name).find{|v|
+            v.is_a?(ActiveModel::Validations::LengthValidator)}.try{|v| v.options} || {}
+        end
+
+        register_instance_option :partial do
+          :form_field
+        end
+
+        # Accessor for whether this is field is mandatory.
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option :required? do
+          @required ||= !!([name] + children_fields).uniq.find do |column_name|
+            !!abstract_model.model.validators_on(column_name).find do |v|
+              v.is_a?(ActiveModel::Validations::PresenceValidator) && !v.options[:allow_nil] ||
+              v.is_a?(ActiveModel::Validations::NumericalityValidator) && !v.options[:allow_nil]
+            end
+          end
+        end
+
+        # Accessor for whether this is a serial field (aka. primary key, identifier).
+        #
+        # @see RailsAdmin::AbstractModel.properties
+        register_instance_option :serial? do
+          properties && properties[:serial?]
+        end
+
+        register_instance_option :view_helper do
+          :text_field
+        end
+
+        register_instance_option :read_only? do
+          not editable?
+        end
+
+        # init status in the view
+        register_instance_option :active? do
+          false
+        end
+
+        register_instance_option :visible? do
+          returned = true
+          (RailsAdmin.config.default_hidden_fields || {}).each do |section, fields|
+            if self.section.is_a?("RailsAdmin::Config::Sections::#{section.to_s.camelize}".constantize)
+              returned = false if fields.include?(self.name)
+            end
+          end
+          returned
+        end
+
+        # columns mapped (belongs_to, paperclip, etc.). First one is used for searching/sorting by default
+        register_instance_option :children_fields do
+          []
+        end
+
+        register_instance_option :render do
+          bindings[:view].render :partial => partial.to_s, :locals => {:field => self, :form => bindings[:form] }
+        end
+
+        def editable?
+          return false if @properties && @properties[:read_only]
+          !bindings[:object].class.active_authorizer[bindings[:view].controller.send(:_attr_accessible_role)].deny?(self.method_name)
+        end
+
+        # Is this an association
+        def association?
+          kind_of?(RailsAdmin::Config::Fields::Association)
+        end
+
+        # Reader for validation errors of the bound object
+        def errors
+          ([name] + children_fields).uniq.map do |column_name|
+            bindings[:object].errors[column_name]
+          end.uniq.flatten
+        end
+
+        # Reader whether field is optional.
+        #
+        # @see RailsAdmin::Config::Fields::Base.register_instance_option(:required?)
+        def optional?
+          not required?
+        end
+
+        # Inverse accessor whether this field is required.
+        #
+        # @see RailsAdmin::Config::Fields::Base.register_instance_option(:required?)
+        def optional(state = nil, &block)
+          if !state.nil? || block
+            required state.nil? ? proc { false == (instance_eval &block) } : false == state
+          else
+            optional?
+          end
+        end
+
+        # Writer to make field optional.
+        #
+        # @see RailsAdmin::Config::Fields::Base.optional
+        def optional=(state)
+          optional(state)
+        end
+
+        # Reader for field's type
+        def type
+          @type ||= self.class.name.to_s.demodulize.underscore.to_sym
+        end
+
+        # Reader for field's value
+        def value
+          bindings[:object].safe_send(name)
+        end
+
+        # Reader for nested attributes
+        register_instance_option :nested_form do
+          false
+        end
+
+        def inverse_of
+          nil
+        end
+
+        def method_name
+          name
+        end
+
+        def html_default_value
+          bindings[:object].new_record? && self.value.nil? && !self.default_value.nil? ? self.default_value : nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/fields/factories/belongs_to_association.rb

@@ -0,0 +1,29 @@
+require 'rails_admin/config/fields'
+require 'rails_admin/config/fields/types'
+require 'rails_admin/config/fields/types/belongs_to_association'
+
+RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
+  if association = parent.abstract_model.associations.find {|a| a[:foreign_key] == properties[:name] }
+    field = RailsAdmin::Config::Fields::Types.load("#{association[:polymorphic] ? :polymorphic : association[:type]}_association").new(parent, association[:name], association)
+    fields << field
+
+    child_columns = []
+    id_column = parent.abstract_model.properties.find {|p| p[:name].to_s == association[:foreign_key].to_s }
+    child_columns << RailsAdmin::Config::Fields.default_factory.call(parent, id_column, fields)
+
+    if association[:polymorphic]
+      type_colum = parent.abstract_model.properties.find {|p| p[:name].to_s == association[:foreign_type].to_s }
+      unless type_field = fields.find{|f| f.name.to_s == type_colum[:name].to_s }
+        type_field = RailsAdmin::Config::Fields.default_factory.call(parent, type_colum, fields)
+      end
+      child_columns << type_field
+    end
+
+    child_columns.each do |child_column|
+      child_column.hide
+      child_column.filterable(false)
+    end
+
+    field.children_fields child_columns.map(&:name)
+  end
+end

data/lib/rails_admin/config/fields/factories/carrierwave.rb

@@ -0,0 +1,31 @@
+require 'rails_admin/config/fields'
+require 'rails_admin/config/fields/types'
+require 'rails_admin/config/fields/types/file_upload'
+
+RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
+  extensions = [nil, :file_name]
+  model = parent.abstract_model.model
+
+  if defined?(::CarrierWave) && (model = parent.abstract_model.model).kind_of?(CarrierWave::Mount) && model.uploaders.include?(attachment_name = properties[:name].to_s.chomp('_file_name').to_sym)
+
+
+    columns = [model.uploader_options[attachment_name][:mount_on] || attachment_name, "#{attachment_name}_content_type".to_sym, "#{attachment_name}_file_size".to_sym]
+
+    field = RailsAdmin::Config::Fields::Types.load(:carrierwave).new(parent, attachment_name, properties)
+    fields << field
+    children_fields = []
+    columns.each do |children_column_name|
+      if child_properties = parent.abstract_model.properties.find {|p| p[:name].to_s == children_column_name.to_s }
+        children_field = fields.find{ |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
+        children_field.hide unless field == children_field
+        children_field.filterable(false) unless field == children_field
+        children_fields << children_field.name
+      end
+    end
+    field.children_fields(children_fields)
+
+    true
+  else
+    false
+  end
+end