andrewroth_activeadmin 0.3.4

data/lib/active_admin/version.rb

@@ -0,0 +1,3 @@
+module ActiveAdmin
+  VERSION = '0.3.4'
+end

data/lib/active_admin/view_factory.rb

@@ -0,0 +1,23 @@
+require 'active_admin/abstract_view_factory'
+
+module ActiveAdmin
+  class ViewFactory < AbstractViewFactory
+
+    # Register Helper Renderers
+    register  :global_navigation  => ActiveAdmin::Views::TabbedNavigation,
+              :action_items       => ActiveAdmin::Views::ActionItems,
+              :header             => ActiveAdmin::Views::HeaderRenderer,
+              :dashboard_section  => ActiveAdmin::Views::DashboardSection,
+              :index_scopes       => ActiveAdmin::Views::Scopes,
+              :blank_slate        => ActiveAdmin::Views::BlankSlate
+
+    # Register All The Pages
+    register  :dashboard_page     => ActiveAdmin::Views::Pages::Dashboard,
+              :index_page         => ActiveAdmin::Views::Pages::Index,
+              :show_page          => ActiveAdmin::Views::Pages::Show,
+              :new_page           => ActiveAdmin::Views::Pages::New,
+              :edit_page          => ActiveAdmin::Views::Pages::Edit,
+              :layout             => ActiveAdmin::Views::Pages::Layout
+
+  end
+end

data/lib/active_admin/view_helpers.rb

@@ -0,0 +1,22 @@
+module ActiveAdmin
+  module ViewHelpers
+
+    # Require all ruby files in the view helpers dir
+    Dir[File.expand_path('../view_helpers', __FILE__) + "/*.rb"].each{|f| require f }
+
+    include AssignsWithIndifferentAccessHelper
+    include ActiveAdminApplicationHelper
+    include RendererHelper
+    include AutoLinkHelper
+    include BreadcrumbHelper
+    include DisplayHelper
+    include IconHelper
+    include MethodOrProcHelper
+    include SidebarHelper
+    include FormHelper
+    include FilterFormHelper
+    include TitleHelper
+    include ViewFactoryHelper
+
+  end
+end

data/lib/active_admin/view_helpers/active_admin_application_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ActiveAdminApplicationHelper
+
+      # Returns the current Active Admin application instance
+      def active_admin_application
+        ActiveAdmin.application
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/assigns_with_indifferent_access_helper.rb

@@ -0,0 +1,7 @@
+module AssignsWithIndifferentAccessHelper
+
+  def assigns
+    @assigns_with_indifferent_access_helper ||= HashWithIndifferentAccess.new(super)
+  end
+
+end

data/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -0,0 +1,42 @@
+module ActiveAdmin
+  module ViewHelpers
+    module AutoLinkHelper
+
+      # Automatically links objects to their resource controllers. If
+      # the resource has not been registered, a string representation of
+      # the object is returned.
+      #
+      # The default content in the link is returned from ActiveAdmin::ViewHelpers::DisplayHelper#display_name
+      #
+      # You can pass in the content to display
+      #   eg: auto_link(@post, "My Link Content")
+      #
+      def auto_link(resource, link_content = nil)
+        content = link_content || display_name(resource)
+        if registration = active_admin_resource_for(resource.class)
+          begin
+            content = link_to(content, send(registration.route_instance_path, resource))
+          rescue
+          end
+        end
+        content
+      end
+
+      # Returns the ActiveAdmin::Resource instance for a class
+      def active_admin_resource_for(klass)
+        active_admin_namespace.resource_for(klass)
+      end
+
+      # Returns the current Active Admin namespace
+      def active_admin_namespace
+        if respond_to?(:active_admin_config) && active_admin_config
+          active_admin_config.namespace
+        else
+          # Return a default namespace if none exists
+          active_admin_application.find_or_create_namespace(active_admin_application.default_namespace)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -0,0 +1,29 @@
+module ActiveAdmin
+  module ViewHelpers
+    module BreadcrumbHelper
+
+      # Returns an array of links to use in a breadcrumb
+      def breadcrumb_links(path = nil)
+        path ||= request.fullpath
+        parts = path.gsub(/^\//, '').split('/')
+        parts.pop unless %w{ create update }.include?(params[:action])
+        crumbs = []
+        parts.each_with_index do |part, index|
+          name = ""
+          if part =~ /^\d/ && parent = parts[index - 1]
+            begin
+              parent_class = parent.singularize.camelcase.constantize
+              obj = parent_class.find(part.to_i)
+              name = obj.display_name if obj.respond_to?(:display_name)
+            rescue
+            end
+          end
+          name = part.titlecase if name == ""
+          crumbs << link_to(name, "/" + parts[0..index].join('/'))
+        end
+        crumbs
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/display_helper.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DisplayHelper
+
+      def display_name_method_for(resource)
+        @@display_name_methods_cache ||= {}
+        @@display_name_methods_cache[resource.class] ||= 
+          active_admin_application.display_name_methods.find{|method| resource.respond_to? method }
+      end
+
+      # Tries to display an object with as friendly of output
+      # as possible.
+      def display_name(resource)
+        resource.send(display_name_method_for(resource))
+      end
+
+      # Return a pretty string for any object
+      # Date Time are formatted via #localize with :format => :long
+      # ActiveRecord objects are formatted via #auto_link
+      # We attempt to #display_name of any other objects
+      def pretty_format(object)
+        case object
+        when String
+          object
+        when Arbre::HTML::Element
+          object
+        when Date, Time
+          localize(object, :format => :long)
+        when ActiveRecord::Base
+          auto_link(object)
+        else
+          display_name(object)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/filter_form_helper.rb

@@ -0,0 +1,186 @@
+module ActiveAdmin
+
+  module ViewHelpers
+    module FilterFormHelper
+
+      # Helper method to render a filter form
+      def active_admin_filters_form_for(search, filters, options = {})
+        options[:builder] ||= ActiveAdmin::FilterFormBuilder
+        options[:url] ||= collection_path
+        options[:html] ||= {}
+        options[:html][:method] = :get
+        options[:html][:class] ||= "filter_form"
+        options[:as] = :q
+        clear_link = link_to(I18n.t('active_admin.clear_filters'), "#", :class => "clear_filters_btn")
+        form_for search, options do |f|
+          filters.each do |filter_options|
+            filter_options = filter_options.dup
+            attribute = filter_options.delete(:attribute)
+            f.filter attribute, filter_options
+          end
+
+          buttons = content_tag :div, :class => "buttons" do
+            f.submit(I18n.t('active_admin.filter')) +
+              clear_link +
+              hidden_field_tag("order", params[:order]) +
+              hidden_field_tag("scope", params[:scope])
+          end
+
+          f.form_buffers.last + buttons
+        end
+      end
+
+    end
+  end
+
+  # This form builder defines methods to build filter forms such
+  # as the one found in the sidebar of the index page of a standard resource.
+  class FilterFormBuilder < FormBuilder
+
+    def filter(method, options = {})
+      return "" if method.nil? || method == ""
+      options[:as] ||= default_filter_type(method)
+      return "" unless options[:as]
+      field_type = options.delete(:as)
+      options[:label] ||= default_filter_label(method)
+      content = with_new_form_buffer do
+        send("filter_#{field_type}_input", method, options)
+      end
+      @form_buffers.last << template.content_tag(:div, content, :class => "filter_form_field filter_#{field_type}")
+    end
+
+    protected
+
+    def filter_string_input(method, options = {})
+      field_name = "#{method}_contains"
+
+      [ label(field_name, I18n.t('active_admin.search_field', :field => options[:label])),
+        text_field(field_name)
+      ].join("\n").html_safe
+    end
+
+    def filter_date_range_input(method, options = {})
+      gt_field_name = "#{method}_gte"
+      lt_field_name = "#{method}_lte"
+
+      [ label(gt_field_name, options[:label]),
+        filter_date_text_field(gt_field_name),
+        template.content_tag(:span, "-", :class => "seperator"),
+        filter_date_text_field(lt_field_name)
+      ].join("\n").html_safe
+    end
+
+    def filter_date_text_field(method)
+      current_value = @object.send(method)
+      text_field(method, :size => 12, :class => "datepicker", :max => 10, :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "")
+    end
+
+    def filter_numeric_input(method, options = {})
+      filters = numeric_filters_for_method(method, options.delete(:filters) || default_numeric_filters)
+      current_filter = current_numeric_scope(filters)
+      filter_select = @template.select_tag '', @template.options_for_select(filters, current_filter),
+                                  :onchange => "document.getElementById('#{method}_numeric').name = 'q[' + this.value + ']';"
+      filter_input = text_field current_filter, :size => 10, :id => "#{method}_numeric"
+
+      [ label(method, options[:label]),
+        filter_select,
+        " ",
+        filter_input
+      ].join("\n").html_safe
+    end
+
+    def numeric_filters_for_method(method, filters)
+      filters.collect{|scope| [scope[0], [method,scope[1]].join("_") ] }
+    end
+
+    # Returns the scope for which we are currently searching. If no search is available
+    # it returns the first scope
+    def current_numeric_scope(filters)
+      filters[1..-1].inject(filters.first){|a,b| object.send(b[1].to_sym) ? b : a }[1]
+    end
+
+    def default_numeric_filters
+      [[I18n.t('active_admin.equal_to'), 'eq'], [I18n.t('active_admin.greater_than'), 'gt'], [I18n.t('active_admin.less_than'), 'lt']]
+    end
+
+    def filter_select_input(method, options = {})
+      association_name = method.to_s.gsub(/_id$/, '').to_sym
+      input_name = (generate_association_input_name(method).to_s + "_eq").to_sym
+      collection = find_collection_for_column(association_name, options)
+
+      [ label(input_name, options[:label]),
+        select(input_name, collection, options.merge(:include_blank => I18n.t('active_admin.any')))
+      ].join("\n").html_safe
+    end
+
+    def filter_check_boxes_input(method, options = {})
+      input_name = (generate_association_input_name(method).to_s + "_in").to_sym
+      collection = find_collection_for_column(method, options)
+      selected_values = @object.send(input_name) || []
+      checkboxes = template.content_tag :div, :class => "check_boxes_wrapper" do
+        collection.map do |c|
+          label = c.is_a?(Array) ? c.first : c
+          value = c.is_a?(Array) ? c.last : c
+          "<label><input type=\"checkbox\" name=\"q[#{input_name}][]\" value=\"#{value}\" #{selected_values.include?(value) ? "checked" : ""}/> #{label}</label>"
+        end.join("\n").html_safe
+      end
+
+      [ label(input_name, options[:label]),
+        checkboxes
+      ].join("\n").html_safe
+    end
+
+    # Override the standard finder to accept a proc
+    def find_collection_for_column(method, options = {})
+      options = options.dup
+      case options[:collection]
+      when Proc
+        options[:collection] = options[:collection].call
+      end
+      super(method, options)
+    end
+
+    # Returns the default filter type for a given attribute
+    def default_filter_type(method)
+      if column = column_for(method)
+        case column.type
+        when :date, :datetime
+          return :date_range
+        when :string, :text
+          return :string
+        when :integer
+          return :select if reflection_for(method.to_s.gsub('_id','').to_sym)
+          return :numeric
+        when :float, :decimal
+          return :numeric
+        end
+      end
+
+      if reflection = reflection_for(method)
+        return :select if reflection.macro == :belongs_to && !reflection.options[:polymorphic]
+      end
+    end
+
+    # Returns the default label for a given attribute
+    # Will use ActiveModel I18n if possible
+    def default_filter_label(method)
+      if @object.base.respond_to?(:human_attribute_name)
+        @object.base.human_attribute_name(method)
+      else
+        method.to_s.titlecase
+      end
+    end
+
+    # Returns the column for an attribute on the object being searched
+    # if it exists. Otherwise returns nil
+    def column_for(method)
+      @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
+    end
+
+    # Returns the association reflection for the method if it exists
+    def reflection_for(method)
+      @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
+    end
+
+  end
+end

data/lib/active_admin/view_helpers/form_helper.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+      
+      def active_admin_form_for(resource, options = {}, &block)
+        options = Marshal.load( Marshal.dump(options) )
+        options[:builder] ||= ActiveAdmin::FormBuilder
+        semantic_form_for resource, options, &block
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/icon_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module IconHelper
+      
+      # Render an icon from the Iconic icon set
+      def icon(*args)
+        ActiveAdmin::Iconic.icon(*args)
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/method_or_proc_helper.rb

@@ -0,0 +1,26 @@
+module MethodOrProcHelper
+
+  # Many times throughout the views we want to either call a method on an object
+  # or instance_exec a proc passing in the object as the first parameter. This
+  # method takes care of this functionality.
+  #
+  #   call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
+  # OR
+  #   proc = Proc.new{|s| s.size }
+  #   call_method_or_proc_on(@my_obj, proc)
+  #
+  def call_method_or_proc_on(obj, symbol_or_proc, options = {})
+    exec = options[:exec].nil? ? true : options[:exec]
+    case symbol_or_proc
+    when Symbol, String
+      obj.send(symbol_or_proc.to_sym)
+    when Proc
+      if exec
+        instance_exec(obj, &symbol_or_proc)
+      else
+        symbol_or_proc.call(obj)
+      end
+    end
+  end
+
+end

data/lib/active_admin/view_helpers/renderer_helper.rb

@@ -0,0 +1,29 @@
+module ActiveAdmin
+  module ViewHelpers
+    module RendererHelper
+
+      # Adds the ability to render ActiveAdmin::Renderers using the
+      # standard render method. 
+      #
+      # Example:
+      #
+      #   render MyRendererClass, "Arg1", "Arg2"
+      #
+      # which is the same as doing
+      #
+      #   MyRendererClass.new(self).to_html("Arg1", "Arg2")
+      def render(*args)
+        if args[0].is_a?(Class) && args[0].ancestors.include?(ActiveAdmin::Renderer)
+          renderer = args.shift
+          renderer.new(self).to_html(*args)
+        elsif args[0].is_a?(Class) && args[0].ancestors.include?(Arbre::HTML::Tag)
+          tag_class = args.shift
+          insert_tag tag_class, *args
+        else
+          super
+        end
+      end
+
+    end
+  end
+end