activeadmin 0.1.1 → 0.2.0

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,41 @@
+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
+          ActiveAdmin::Namespace.new(ActiveAdmin.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] ||= 
+          ActiveAdmin.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,174 @@
+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[:as] = :q
+        clear_link = link_to("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("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)
+      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, "Search #{method.to_s.titlecase}"),
+        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, method.to_s.titlecase),
+        filter_date_text_field(gt_field_name),
+        " - ",
+        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),
+        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
+      [['Equal To', 'eq'], ['Greater Than', 'gt'], ['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, method.to_s.titlecase),
+        select(input_name, collection, options.merge(:include_blank => '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, method.to_s.titlecase),
+        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.collection?
+      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,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+      
+      def active_admin_form_for(resource, options = {}, &block)
+        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

data/lib/active_admin/view_helpers/sidebar_helper.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module ViewHelpers
+    module SidebarHelper
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/status_tag_helper.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module ViewHelpers
+    module StatusTagHelper
+
+      def status_tag(status, options = {})
+        options[:class] ||= ""
+        options[:class] << ["status", status.downcase].join(' ')
+        content_tag :span, status, options
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/table_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module TableHelper
+
+      # Helper to render a table for a collection
+      def table_for(collection, options = {}, &block)
+        ActiveAdmin::TableBuilder.new(&block).to_html(self, collection, options)
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/title_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module TitleHelper
+
+      def title(_title)
+        @page_title = _title 
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/view_factory_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ViewFactoryHelper
+
+      def view_factory
+        ActiveAdmin.view_factory
+      end
+
+    end
+  end
+end