nsm-activeadmin 0.2.2

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

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/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
+        active_admin_application.view_factory
+      end
+
+    end
+  end
+end

data/lib/active_admin/views.rb

@@ -0,0 +1,8 @@
+module ActiveAdmin
+  module Views
+
+    # Loads all the classes in views/*.rb
+    Dir[File.expand_path('../views', __FILE__) + "/**/*.rb"].sort.each{ |f| require f }
+
+  end
+end

data/lib/active_admin/views/action_items.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+
+    class ActionItems < ActiveAdmin::Component
+
+      def build(action_items)
+        action_items.each do |action_item|
+          span :class => "action_item" do
+            instance_eval(&action_item.block)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/views/components/attributes_table.rb

@@ -0,0 +1,66 @@
+module ActiveAdmin
+  module Views
+
+    class AttributesTable < ActiveAdmin::Component
+      builder_method :attributes_table_for
+
+      attr_reader :resource
+
+      def build(record, *attrs)
+        @record = record
+        super(:for => @record)
+        @table = table
+        rows(*attrs)
+      end
+
+      def rows(*attrs)
+        attrs.each {|attr| row(attr) }
+      end
+
+      def row(attr, &block)
+        @table << tr do
+          th do
+            header_content_for(attr)
+          end
+          td do
+            content_for(block || attr)
+          end
+        end
+      end
+
+      protected
+
+      def default_id_for_prefix
+        'attributes_table'
+      end
+
+      def header_content_for(attr)
+        @record.class.respond_to?(:human_attribute_name) ? @record.class.human_attribute_name(attr).titleize : attr.to_s.titleize
+      end
+
+      def empty_value
+        span I18n.t('active_admin.empty'), :class => "empty"
+      end
+
+      def content_for(attr_or_proc)
+        value = case attr_or_proc
+                when Proc
+                  attr_or_proc.call
+                else
+                  content_for_attribute(attr_or_proc)
+                end
+        value = pretty_format(value)
+        value == "" || value == nil ? empty_value : value
+      end
+
+      def content_for_attribute(attr)
+        if attr.to_s =~ /^([\w]+)_id$/ && @record.respond_to?($1.to_sym)
+          content_for_attribute($1)
+        else
+          @record.send(attr.to_sym)
+        end
+      end
+    end
+
+  end
+end

data/lib/active_admin/views/components/blank_slate.rb

@@ -0,0 +1,33 @@
+module ActiveAdmin
+  module Views
+    # Build a Blank Slate
+    class BlankSlate < ActiveAdmin::Component
+      builder_method :blank_slate
+      
+      def default_class_name
+        'blank_slate_container'
+      end
+      
+      def build(name, url = nil)
+        if url
+          super(span(blank_slate_content_with_link(name, url), :class => "blank_slate"))
+        else
+          super(span(blank_slate_content_without_link(name), :class => "blank_slate"))
+        end
+      end
+      
+      private
+      
+      def blank_slate_content_with_link(name, url)
+        I18n.t('active_admin.blank_slate.content', :resource_name => name).html_safe +
+          " " +
+            link_to(I18n.t('active_admin.blank_slate.link').html_safe, url)
+      end
+      
+      def blank_slate_content_without_link(name)
+        I18n.t('active_admin.blank_slate.content', :resource_name => name).html_safe
+      end
+      
+    end
+  end
+end