upstream-rails_admin 1.0.2

data/app/assets/stylesheets/rails_admin/themes/default/mixins.css.scss

@@ -0,0 +1,8 @@
+/*
+  Customize Sass mixins from Twitter-Bootstrap/RailsAdmin theme or add new ones for your own use.
+
+  Available mixins to use/override:
+
+  https://github.com/thomas-mcdonald/bootstrap-sass/blob/master/vendor/assets/stylesheets/bootstrap/mixins.css.scss
+  https://github.com/sferik/rails_admin/blob/master/app/assets/stylesheets/rails_admin/base/mixins.css.scss
+*/

data/app/assets/stylesheets/rails_admin/themes/default/theming.css.scss

@@ -0,0 +1,11 @@
+/*
+  Customize RailsAdmin theme here.
+
+  Look at the markup in RailsAdmin and go there to get inspiration from:
+
+  http://twitter.github.com/bootstrap/
+
+  Test me: (actual color should be the one defined in variables.css.scss if you did)
+
+  body{ background-color: $linkColor; }
+*/

data/app/assets/stylesheets/rails_admin/themes/default/variables.css.scss

@@ -0,0 +1,12 @@
+/*
+  Customize Sass variables from Twitter-Bootstrap/RailsAdmin theme or add new ones for your own use.
+
+  Available variables to use/override:
+
+  https://github.com/thomas-mcdonald/bootstrap-sass/blob/master/vendor/assets/stylesheets/bootstrap/variables.css.scss
+  https://github.com/sferik/rails_admin/blob/master/app/assets/stylesheets/rails_admin/base/variables.css.scss
+
+  Test me: pink links
+
+  $linkColor: #F0F;
+*/

data/app/controllers/rails_admin/application_controller.rb

@@ -0,0 +1,82 @@
+require 'rails_admin/abstract_model'
+
+module RailsAdmin
+  class ModelNotFound < ::StandardError
+  end
+
+  class ObjectNotFound < ::StandardError
+  end
+
+  class ApplicationController < ::ApplicationController
+    newrelic_ignore if defined?(NewRelic)
+
+    before_filter :_authenticate!
+    before_filter :_authorize!
+    before_filter :_audit!
+
+    helper_method :_current_user, :_attr_accessible_role, :_get_plugin_name
+
+    attr_reader :object, :model_config, :abstract_model
+
+    def get_model
+      @model_name = to_model_name(params[:model_name])
+      raise RailsAdmin::ModelNotFound unless (@abstract_model = RailsAdmin::AbstractModel.new(@model_name))
+      raise RailsAdmin::ModelNotFound if (@model_config = @abstract_model.config).excluded?
+      @properties = @abstract_model.properties
+    end
+
+    def get_object
+      raise RailsAdmin::ObjectNotFound unless (@object = @abstract_model.get(params[:id]))
+    end
+
+    def to_model_name(param)
+      model_name = param.split("~").map(&:camelize).join("::")
+    end
+
+    private
+
+    def _get_plugin_name
+      @plugin_name_array ||= [RailsAdmin.config.main_app_name.is_a?(Proc) ? instance_eval(&RailsAdmin.config.main_app_name) : RailsAdmin.config.main_app_name].flatten
+    end
+
+    def _authenticate!
+      instance_eval &RailsAdmin::Config.authenticate_with
+    end
+
+    def _authorize!
+      instance_eval &RailsAdmin::Config.authorize_with
+    end
+
+    def _audit!
+      instance_eval &RailsAdmin::Config.audit_with
+    end
+
+    def _current_user
+      instance_eval &RailsAdmin::Config.current_user_method
+    end
+
+    def _attr_accessible_role
+      instance_eval &RailsAdmin::Config.attr_accessible_role
+    end
+
+    rescue_from RailsAdmin::ObjectNotFound do
+      flash[:error] = I18n.t('admin.flash.object_not_found', :model => @model_name, :id => params[:id])
+      params[:action] = 'index'
+      index
+    end
+
+    rescue_from RailsAdmin::ModelNotFound do
+      flash[:error] = I18n.t('admin.flash.model_not_found', :model => @model_name)
+      params[:action] = 'dashboard'
+      dashboard
+    end
+
+    def not_found
+      render :file => Rails.root.join('public', '404.html'), :layout => false, :status => :not_found
+    end
+
+    def rails_admin_controller?
+      true
+    end
+  end
+end

data/app/controllers/rails_admin/main_controller.rb

@@ -0,0 +1,155 @@
+module RailsAdmin
+
+  class MainController < RailsAdmin::ApplicationController
+
+    include ActionView::Helpers::TextHelper
+    include RailsAdmin::MainHelper
+    include RailsAdmin::ApplicationHelper
+
+    layout :get_layout
+
+    before_filter :get_model, :except => RailsAdmin::Config::Actions.all(:root).map(&:action_name)
+    before_filter :get_object, :only => RailsAdmin::Config::Actions.all(:member).map(&:action_name)
+    before_filter :check_for_cancel
+
+    RailsAdmin::Config::Actions.all.each do |action|
+      class_eval %{
+        def #{action.action_name}
+          action = RailsAdmin::Config::Actions.find('#{action.action_name}'.to_sym)
+          @authorization_adapter.try(:authorize, action.authorization_key, @abstract_model, @object)
+          @action = action.with({:controller => self, :abstract_model => @abstract_model, :object => @object})
+          @page_name = wording_for(:title)
+
+          instance_eval &@action.controller
+        end
+      }
+    end
+
+    def bulk_action
+      self.send(params[:bulk_action]) if params[:bulk_action].in?(RailsAdmin::Config::Actions.all(:controller => self, :abstract_model => @abstract_model).select(&:bulkable?).map(&:route_fragment))
+    end
+
+    def list_entries(model_config = @model_config, auth_scope_key = :index, additional_scope = get_association_scope_from_params, pagination = !(params[:associated_collection] || params[:all]))
+      scope = model_config.abstract_model.scoped
+      if auth_scope = @authorization_adapter && @authorization_adapter.query(auth_scope_key, model_config.abstract_model)
+        scope = scope.merge(auth_scope)
+      end
+      scope = scope.instance_eval(&additional_scope) if additional_scope
+
+      get_collection(model_config, scope, pagination)
+    end
+
+    private
+    
+    def get_layout
+      "rails_admin/#{request.headers['X-PJAX'] ? 'pjax' : 'application'}"
+    end
+
+    def back_or_index
+      params[:return_to].presence && params[:return_to].include?(request.host) && (params[:return_to] != request.fullpath) ? params[:return_to] : index_path
+    end
+
+    def get_sort_hash(model_config)
+      abstract_model = model_config.abstract_model
+      params[:sort] = params[:sort_reverse] = nil unless model_config.list.fields.map {|f| f.name.to_s}.include? params[:sort]
+
+      params[:sort] ||= model_config.list.sort_by.to_s
+      params[:sort_reverse] ||= 'false'
+
+      field = model_config.list.fields.find{ |f| f.name.to_s == params[:sort] }
+
+      column = if field.nil? || field.sortable == true # use params[:sort] on the base table
+        "#{abstract_model.table_name}.#{params[:sort]}"
+      elsif field.sortable == false # use default sort, asked field is not sortable
+        "#{abstract_model.table_name}.#{model_config.list.sort_by}"
+      elsif field.sortable.is_a?(String) && field.sortable.include?('.') # just provide sortable, don't do anything smart
+        field.sortable
+      elsif field.sortable.is_a?(Hash) # just join sortable hash, don't do anything smart
+        "#{field.sortable.keys.first}.#{field.sortable.values.first}"
+      elsif field.association? # use column on target table
+        "#{field.associated_model_config.abstract_model.table_name}.#{field.sortable}"
+      else # use described column in the field conf.
+        "#{abstract_model.table_name}.#{field.sortable}"
+      end
+
+      reversed_sort = (field ? field.sort_reverse? : model_config.list.sort_reverse?)
+      {:sort => column, :sort_reverse => (params[:sort_reverse] == reversed_sort.to_s)}
+    end
+
+    def redirect_to_on_success
+      notice = t("admin.flash.successful", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+      if params[:_add_another]
+        redirect_to new_path(:return_to => params[:return_to]), :flash => { :success => notice }
+      elsif params[:_add_edit]
+        redirect_to edit_path(:id => @object.id, :return_to => params[:return_to]), :flash => { :success => notice }
+      else
+        redirect_to back_or_index, :flash => { :success => notice }
+      end
+    end
+
+    def sanitize_params_for!(action, model_config = @model_config, _params = params[@abstract_model.param_key])
+      return unless _params.present?
+      fields = model_config.send(action).fields
+      fields.select{ |f| f.respond_to?(:parse_input) }.each {|f| f.parse_input(_params) }
+
+      fields.select(&:nested_form).each do |association|
+        children_params = association.multiple? ? _params[association.method_name].try(:values) : [_params[association.method_name]].compact
+        (children_params || []).each do |children_param|
+          sanitize_params_for!(:nested, association.associated_model_config, children_param)
+        end
+      end
+    end
+
+    def handle_save_error whereto = :new
+      action = params[:action]
+
+      flash.now[:error] = t("admin.flash.error", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+      flash.now[:error] += ". #{@object.errors[:base].to_sentence}" unless @object.errors[:base].blank?
+
+      respond_to do |format|
+        format.html { render whereto, :status => :not_acceptable }
+        format.js   { render whereto, :layout => false, :status => :not_acceptable  }
+      end
+    end
+
+    def check_for_cancel
+      if params[:_continue]
+        redirect_to(back_or_index, :flash => { :info => t("admin.flash.noaction") })
+      end
+    end
+
+    def get_collection(model_config, scope, pagination)
+      associations = model_config.list.fields.select {|f| f.type == :belongs_to_association && !f.polymorphic? }.map {|f| f.association[:name] }
+      options = {}
+      options = options.merge(:page => (params[:page] || 1).to_i, :per => (params[:per] || model_config.list.items_per_page)) if pagination
+      options = options.merge(:include => associations) unless associations.blank?
+      options = options.merge(get_sort_hash(model_config)) unless params[:associated_collection]
+      options = options.merge(:query => params[:query]) if params[:query].present?
+      options = options.merge(:filters => params[:f]) if params[:f].present?
+      options = options.merge(:bulk_ids => params[:bulk_ids]) if params[:bulk_ids]
+
+      objects = model_config.abstract_model.all(options, scope)
+    end
+
+    def get_association_scope_from_params
+      return nil unless params[:associated_collection].present?
+      source_abstract_model = RailsAdmin::AbstractModel.new(to_model_name(params[:source_abstract_model]))
+      source_model_config = source_abstract_model.config
+      source_object = source_abstract_model.get(params[:source_object_id])
+      action = params[:current_action].in?(['create', 'update']) ? params[:current_action] : 'edit'
+      @association = source_model_config.send(action).fields.find{|f| f.name == params[:associated_collection].to_sym }.with(:controller => self, :object => source_object)
+      @association.associated_collection_scope
+    end
+
+    def associations_hash
+      associations = {}
+      @abstract_model.associations.each do |association|
+        if [:has_many, :has_and_belongs_to_many].include?(association[:type])
+          records = Array(@object.send(association[:name]))
+          associations[association[:name]] = records.collect(&:id)
+        end
+      end
+      associations
+    end
+  end
+end

data/app/helpers/rails_admin/application_helper.rb

@@ -0,0 +1,125 @@
+require 'rails_admin/i18n_support'
+
+module RailsAdmin
+  module ApplicationHelper
+
+    include RailsAdmin::I18nSupport
+
+    def authorized?(*args)
+      @authorization_adapter.nil? || @authorization_adapter.authorized?(*args)
+    end
+
+    def current_action?(action, abstract_model = @abstract_model, object = @object)
+      @action.custom_key == action.custom_key && 
+      abstract_model.try(:to_param) == @abstract_model.try(:to_param) && 
+      (@object.try(:persisted?) ? @object.id == object.try(:id) : !object.try(:persisted?))
+    end
+
+    def action(key, abstract_model = nil, object = nil)
+      RailsAdmin::Config::Actions.find(key, { :controller => self.controller, :abstract_model => abstract_model, :object => object })
+    end
+
+    def actions(scope = :all, abstract_model = nil, object = nil)
+      RailsAdmin::Config::Actions.all(scope, { :controller => self.controller, :abstract_model => abstract_model, :object => object })
+    end
+
+    def edit_user_link
+      return nil unless authorized?(:edit, _current_user.class, _current_user) && _current_user.respond_to?(:email)
+      return nil unless abstract_model = RailsAdmin.config(_current_user.class).abstract_model
+      return nil unless edit_action = RailsAdmin::Config::Actions.find(:edit, {:controller => self.controller, :abstract_model => abstract_model, :object => _current_user })
+      link_to _current_user.email, url_for(:action => edit_action.action_name, :model_name => abstract_model.to_param, :id => _current_user.id, :controller => 'rails_admin/main')
+    end
+
+    def wording_for(label, action = @action, abstract_model = @abstract_model, object = @object)
+      model_config = abstract_model.try(:config)
+      object = abstract_model && object.is_a?(abstract_model.model) ? object : nil
+      action = RailsAdmin::Config::Actions.find(action.to_sym) if (action.is_a?(Symbol) || action.is_a?(String))
+
+      I18n.t("admin.actions.#{action.i18n_key}.#{label}",
+        :model_label => model_config.try(:label),
+        :model_label_plural => model_config.try(:label_plural),
+        :object_label => model_config && object.try(model_config.object_label_method)
+      )
+    end
+
+    def main_navigation
+      nodes_stack = RailsAdmin::Config.visible_models(:controller => self.controller)      
+      nodes_stack.group_by(&:navigation_label).map do |navigation_label, nodes|
+
+        %{<li class='nav-header'>#{navigation_label || t('admin.misc.navigation')}</li>}.html_safe +
+        nodes.select{|n| n.parent.nil? || !n.parent.to_s.in?(nodes_stack.map{|c| c.abstract_model.model_name }) }.map do |node|
+          %{
+            <li data-model="#{node.abstract_model.to_param}">
+              <a class="pjax" href="#{url_for(:action => :index, :controller => 'rails_admin/main', :model_name => node.abstract_model.to_param)}">#{node.label_plural}</a>
+            </li>
+            #{navigation(nodes_stack, nodes_stack.select{|n| n.parent.to_s == node.abstract_model.model_name}, 1)}
+          }.html_safe
+        end.join.html_safe
+      end.join.html_safe
+    end
+
+    def navigation nodes_stack, nodes, level
+      nodes.map do |node|
+        %{
+          <li data-model="#{node.abstract_model.to_param}">
+            <a class="pjax nav-level-#{level}" href="#{url_for(:action => :index, :controller => 'rails_admin/main', :model_name => node.abstract_model.to_param)}">#{node.label_plural}</a>
+          </li>
+          #{navigation(nodes_stack, nodes_stack.select{ |n| n.parent.to_s == node.abstract_model.model_name}, level + 1)}
+        }.html_safe
+      end.join
+    end
+
+    def breadcrumb action = @action, acc = []
+      begin
+        (parent_actions ||= []) << action
+      end while action.breadcrumb_parent && (action = action(*action.breadcrumb_parent))
+      parent_actions << action(:dashboard) if parent_actions.last.key != :dashboard # in case chain is interrupted
+
+      content_tag(:ul, :class => "breadcrumb") do
+        parent_actions.map do |a|
+          am = a.send(:eval, 'bindings[:abstract_model]')
+          o = a.send(:eval, 'bindings[:object]')
+          content_tag(:li, :class => "#{"active" if current_action?(a, am, o)}") do
+            if a.http_methods.include?(:get)
+              link_to wording_for(:breadcrumb, a, am, o), { :action => a.action_name, :controller => 'rails_admin/main', :model_name => am.try(:to_param), :id => (o.try(:persisted?) && o.try(:id) || nil) }, :class => 'pjax'
+            else
+              content_tag(:span, wording_for(:breadcrumb, a, am, o))
+            end
+          end
+        end.reverse.join('<span class="divider">/</span>').html_safe
+      end
+    end
+
+    # parent => :root, :collection, :member
+    def menu_for(parent, abstract_model = nil, object = nil, only_icon = false) # perf matters here (no action view trickery)
+      actions = actions(parent, abstract_model, object).select{ |a| a.http_methods.include?(:get) }
+      actions.map do |action|
+        wording = wording_for(:menu, action)
+        %{
+          <li data-original-title="#{wording}" rel="#{'tooltip' if only_icon}" class="icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}">
+            <a class="pjax" href="#{url_for({ :action => action.action_name, :controller => 'rails_admin/main', :model_name => abstract_model.try(:to_param), :id => (object.try(:persisted?) && object.try(:id) || nil) })}">
+              <i class="#{action.link_icon}"></i>
+              <span#{only_icon ? " style='display:none'" : ""}>#{wording}</span>
+            </a>
+          </li>
+        }
+      end.join.html_safe
+    end
+
+    def bulk_menu abstract_model = @abstract_model
+      actions = actions(:bulkable, abstract_model)
+      return '' if actions.empty?
+      content_tag :li, { :class => 'dropdown', :style => 'float:right' } do
+        content_tag(:a, { :class => 'dropdown-toggle', :'data-toggle' => "dropdown", :href => '#' }) { t('admin.misc.bulk_menu_title').html_safe + '<b class="caret"></b>'.html_safe } +
+        content_tag(:ul, :class => 'dropdown-menu', :style => 'left:auto; right:0;') do
+          actions.map do |action|
+            content_tag :li do
+              link_to_function wording_for(:bulk_link, action), "jQuery('#bulk_action').val('#{action.action_name}'); jQuery('#bulk_form').submit()"
+            end
+          end.join.html_safe
+        end
+      end
+    end
+  end
+end
+

data/app/helpers/rails_admin/form_builder.rb

@@ -0,0 +1,113 @@
+ActionView::Base.field_error_proc = Proc.new { |html_tag, instance| html_tag }
+
+module RailsAdmin
+  class FormBuilder < ::ActionView::Helpers::FormBuilder
+    include ::NestedForm::BuilderMixin
+
+    def generate(options = {})
+      options.reverse_merge!({
+        :action => @template.controller.params[:action],
+        :model_config => @template.instance_variable_get(:@model_config),
+        :nested_in => false
+      })
+
+      if options[:nested_in]
+        action = :nested
+      elsif @template.request.format == 'text/javascript'
+        action = :modal      
+      else
+        action = options[:action]
+      end
+      
+      groups = options[:model_config].send(action).with(:form => self, :object => @object, :view => @template).visible_groups
+
+      object_infos +
+      groups.map do |fieldset|
+        fieldset_for fieldset, options[:nested_in]
+      end.join.html_safe +
+      (options[:nested_in] ? '' : @template.render(:partial => 'submit_buttons'))
+    end
+
+    def fieldset_for fieldset, nested_in
+      if (fields = fieldset.with(:form => self, :object => @object, :view => @template).visible_fields).length > 0
+        @template.content_tag :fieldset do
+          contents = []
+          contents << @template.content_tag(:legend, %{<i class="icon-chevron-#{(fieldset.active? ? 'down' : 'right')}"></i> #{fieldset.label}}.html_safe, :style => "#{fieldset.name == :default ? 'display:none' : ''}")
+          contents << @template.content_tag(:p, fieldset.help) if fieldset.help.present?
+          contents << fields.map{ |field| field_wrapper_for(field, nested_in) }.join
+          contents.join.html_safe
+        end
+      end
+    end
+
+    def field_wrapper_for field, nested_in
+      # do not show nested field if the target is the origin
+      unless field.inverse_of.presence && field.inverse_of == nested_in
+        @template.content_tag(:div, :class => "control-group #{field.type_css_class} #{field.css_class} #{'error' if field.errors.present?}", :id => "#{dom_id(field)}_field") do
+          label(field.method_name, field.label, :class => 'control-label') +
+          (field.nested_form ? field_for(field) : input_for(field))
+        end
+      end
+    end
+
+    def input_for field
+      @template.content_tag(:div, :class => 'controls') do
+        field_for(field) +
+        errors_for(field) +
+        help_for(field)
+      end
+    end
+
+    def errors_for field
+      field.errors.present? ? @template.content_tag(:span, "#{field.label} #{field.errors.to_sentence}", :class => 'help-inline') : ''.html_safe
+    end
+
+    def help_for field
+      field.help.present? ? @template.content_tag(:p, field.help, :class => 'help-block') : ''.html_safe
+    end
+
+    def field_for field
+      if field.read_only?
+        field.pretty_value.to_s.html_safe
+      else
+        field.render
+      end
+    end
+
+    def object_infos
+      model_config = RailsAdmin.config(object)
+      model_label = model_config.label
+      object_label = (object.new_record? ? I18n.t('admin.form.new_model', :name => model_label) : object.send(model_config.object_label_method).presence || "#{model_config.label} ##{object.id}")
+      %{<span style="display:none" class="object-infos" data-model-label="#{model_label}" data-object-label="#{object_label}"></span>}.html_safe
+    end
+
+    def javascript_for(field, options = {}, &block)
+      %{<script type="text/javascript">
+          jQuery(function($) {
+            if(!$("#{jquery_namespace(field)}").parents(".fields_blueprint").length) {
+              if(#{options[:modal] == false ? '!$("#modal").length' : 'true'}) {
+                #{@template.capture(&block)}
+              }
+            }
+          });
+        </script>}.html_safe
+    end
+
+    def jquery_namespace field
+      %{#{(@template.controller.params[:modal] ? '#modal ' : '')}##{dom_id(field)}_field}
+    end
+
+    def dom_id field
+      (@dom_id ||= {})[field.name] ||=
+        [
+          @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, ""),
+          options[:index],
+          field.method_name
+        ].reject(&:blank?).join('_')
+    end
+
+    def dom_name field
+      (@dom_name ||= {})[field.name] ||= %{#{@object_name}#{options[:index] && "[#{options[:index]}]"}[#{field.method_name}]#{field.is_a?(Config::Fields::Association) && field.multiple? ? '[]' : ''}}
+    end
+  end
+end