yousty-activeadmin 1.0.0.pre

data/lib/active_admin/inputs/filter_check_boxes_input.rb

@@ -0,0 +1,51 @@
+module ActiveAdmin
+  module Inputs
+    class FilterCheckBoxesInput < ::Formtastic::Inputs::CheckBoxesInput
+      include FilterBase
+
+      def input_name
+        "#{object_name}[#{searchable_method_name}_in][]"
+      end
+
+      def selected_values
+        @object.send("#{searchable_method_name}_in") || []
+      end
+
+      def searchable_method_name
+        # Deal with has_many :through relationships in filters
+        # If the relationship is a HMT, we set the search logic to be something
+        # like :#{through_association}_#{end_association_id}.
+        if searchable_through_association?
+          [reflection.through_reflection.name, reflection.foreign_key].join('_')
+        else
+          association_primary_key || method
+        end
+      end
+
+      # Add whitespace before label
+      def choice_label(choice)
+        ' ' + super
+      end
+
+      # Don't wrap in UL tag
+      def choices_group_wrapping(&block)
+        template.capture(&block)
+      end
+
+      # Don't wrap in LI tag
+      def choice_wrapping(html_options, &block)
+        template.capture(&block)
+      end
+
+      # Don't render hidden fields
+      def hidden_field_for_all
+        ""
+      end
+
+      # Don't render hidden fields
+      def hidden_fields?
+        false
+      end
+    end
+  end
+end

data/lib/active_admin/inputs/filter_date_range_input.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module Inputs
+    class FilterDateRangeInput < ::Formtastic::Inputs::StringInput
+      include FilterBase
+
+      def to_html
+        input_wrapping do
+          [ label_html,
+            builder.text_field(gt_input_name, input_html_options(gt_input_name)),
+            template.content_tag(:span, "-", :class => "seperator"),
+            builder.text_field(lt_input_name, input_html_options(lt_input_name)),
+          ].join("\n").html_safe
+        end
+      end
+
+      def gt_input_name
+        "#{method}_gteq"
+      end
+      alias :input_name :gt_input_name
+
+      def lt_input_name
+        "#{method}_lteq"
+      end
+
+      def input_html_options(input_name = gt_input_name)
+        current_value = @object.send(input_name)
+        { :size => 12,
+          :class => "datepicker",
+          :max => 10,
+          :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "" }
+      end
+    end
+  end
+end

data/lib/active_admin/inputs/filter_numeric_input.rb

@@ -0,0 +1,10 @@
+module ActiveAdmin
+  module Inputs
+    class FilterNumericInput < ::Formtastic::Inputs::NumberInput
+      include FilterBase
+      include FilterBase::SearchMethodSelect
+
+      filter :equals, :greater_than, :less_than
+    end
+  end
+end

data/lib/active_admin/inputs/filter_select_input.rb

@@ -0,0 +1,61 @@
+module ActiveAdmin
+  module Inputs
+    class FilterSelectInput < ::Formtastic::Inputs::SelectInput
+      include FilterBase
+
+      # If Ransack will likely respond to the given method, use it.
+      #
+      # Otherwise:
+      # When it's a HABTM or has_many association, Formtastic builds "object_ids".
+      # That doesn't fit our scenario, so we override it here.
+      def input_name
+        return method if seems_searchable?
+
+        searchable_method_name.concat multiple? ? '_in' : '_eq'
+      end
+
+      def searchable_method_name
+        # Deal with has_many :through relationships in filters
+        # If the relationship is a HMT, we set the search logic to be something
+        # like :#{through_association}_#{end_association_id}.
+        if searchable_through_association?
+          name = [reflection.through_reflection.name, reflection.foreign_key].join('_')
+        else
+          name = method.to_s
+          name.concat '_id' if reflection
+        end
+        name
+      end
+
+      # Provide the AA translation to the blank input field.
+      def include_blank
+        I18n.t 'active_admin.any' if super
+      end
+
+      # was "#{object_name}[#{association_primary_key}]"
+      def input_html_options_name
+        "#{object_name}[#{input_name}]"
+      end
+
+      # Would normally return true for has_many and HABTM, which would subsequently
+      # cause the select field to be multi-select instead of a dropdown.
+      def multiple_by_association?
+        false
+      end
+
+      # Provides an efficient default lookup query if the attribute is a DB column.
+      def collection
+        if !options[:collection] && column
+          pluck_column
+        else
+          super
+        end
+      end
+
+      def pluck_column
+        klass.reorder("#{method} asc").uniq.pluck method
+      end
+
+    end
+  end
+end

data/lib/active_admin/inputs/filter_string_input.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  module Inputs
+    class FilterStringInput < ::Formtastic::Inputs::StringInput
+      include FilterBase
+      include FilterBase::SearchMethodSelect
+
+      filter :contains, :equals, :starts_with, :ends_with
+
+      # If the filter method includes a search condition, build a normal string search field.
+      # Else, build a search field with a companion dropdown to choose a search condition from.
+      def to_html
+        if seems_searchable?
+          input_wrapping do
+            label_html <<
+            builder.text_field(method, input_html_options)
+          end
+        else
+          super # SearchMethodSelect#to_html
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/inputs.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :DatepickerInput
+
+    autoload :FilterBase
+    autoload :FilterStringInput
+    autoload :FilterDateRangeInput
+    autoload :FilterNumericInput
+    autoload :FilterSelectInput
+    autoload :FilterCheckBoxesInput
+    autoload :FilterBooleanInput
+  end
+end

data/lib/active_admin/menu.rb

@@ -0,0 +1,107 @@
+module ActiveAdmin
+
+  # Each Namespace builds up it's own menu as the global navigation
+  #
+  # To build a new menu:
+  #
+  #   menu = Menu.new do |m|
+  #     m.add label: 'Dashboard', url: '/'
+  #     m.add label: 'Users',     url: '/users'
+  #   end
+  #
+  # If you're interested in configuring a menu item, take a look at the
+  # options available in `ActiveAdmin::MenuItem`
+  #
+  class Menu
+
+    def initialize
+      super # MenuNode
+      yield(self) if block_given?
+    end
+
+    module MenuNode
+      def initialize
+        @children = {}
+      end
+
+      def [](id)
+        @children[normalize_id(id)]
+      end
+      def []=(id, child)
+        @children[normalize_id(id)] = child
+      end
+
+      # Recursively builds any given menu items. There are two syntaxes supported,
+      # as shown in the below examples. Both create an identical menu structure.
+      #
+      # Example 1:
+      #   menu = Menu.new
+      #   menu.add label: 'Dashboard' do |dash|
+      #     dash.add label: 'My Child Dashboard'
+      #   end
+      #
+      # Example 2:
+      #   menu = Menu.new
+      #   menu.add label:  'Dashboard'
+      #   menu.add parent: 'Dashboard', label: 'My Child Dashboard'
+      #
+      def add(options)
+        item = if parent = options.delete(:parent)
+          (self[parent] || add(:label => parent)).add options
+        else
+          _add options.merge :parent => self
+        end
+
+        yield(item) if block_given?
+
+        item
+      end
+
+      # Whether any children match the given item.
+      def include?(item)
+        @children.values.include? item
+      end
+
+      # Used in the UI to visually distinguish which menu item is selected.
+      def current?(item)
+        self == item || include?(item)
+      end
+
+      # Returns sorted array of menu items that should be displayed in this context.
+      # Sorts by priority first, then alphabetically by label if needed.
+      def items(context = nil)
+        @children.values.select{ |i| i.display?(context) }.sort do |a,b|
+          result = a.priority       <=> b.priority
+          result = a.label(context) <=> b.label(context) if result == 0
+          result
+        end
+      end
+
+      attr_reader :children
+      private
+      attr_writer :children
+
+      # The method that actually adds new menu items. Called by the public method.
+      # If this ID is already taken, transfer the children of the existing item to the new item.
+      def _add(options)
+        item = ActiveAdmin::MenuItem.new(options)
+        item.send :children=, self[item.id].children if self[item.id]
+        self[item.id] = item
+      end
+
+      def normalize_id(id)
+        case id
+        when String, Symbol, ActiveModel::Name
+          id.to_s.downcase.gsub ' ', '_'
+        when ActiveAdmin::Resource::Name
+          id.param_key
+        else
+          raise TypeError, "#{id.class} isn't supported as a Menu ID"
+        end
+      end
+    end
+
+    include MenuNode
+
+  end
+end

data/lib/active_admin/menu_collection.rb

@@ -0,0 +1,96 @@
+module ActiveAdmin
+
+  DEFAULT_MENU = :default
+
+  # A MenuCollection stores multiple menus for any given namespace. Namespaces delegate
+  # the addition of menu items to this class.
+  class MenuCollection
+
+    NoMenuError = Class.new(KeyError)
+
+    def initialize
+      @menus = {}
+      @build_callbacks = []
+      @built = false
+    end
+
+    # Add a new menu item to a menu in the collection
+    def add(menu_name, menu_item_options = {})
+      menu = find_or_create(menu_name)
+
+      menu.add menu_item_options
+    end
+
+    def clear!
+      @menus = {}
+      @built = false
+    end
+
+    def exists?(menu_name)
+      @menus.keys.include? menu_name
+    end
+
+    def fetch(menu_name)
+      build_menus!
+
+      @menus[menu_name] or
+        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in availble menus: #{@menus.keys.join(", ")}"
+    end
+
+    # Add callbacks that will be run when the menu is going to be built. This
+    # helps use with reloading and allows configurations to add items to menus.
+    #
+    # @param [Proc] block A block which will be ran when the menu is built. The
+    #                   will have the menu collection yielded.
+    def on_build(&block)
+      @build_callbacks << block
+    end
+
+    # Add callbacks that will be run before the menu is built
+    def before_build(&block)
+      @build_callbacks.unshift(block)
+    end
+
+    def menu(menu_name)
+      menu = find_or_create(menu_name)
+
+      yield(menu) if block_given?
+
+      menu
+    end
+
+    private
+
+    def built?
+      @built
+    end
+
+    def build_menus!
+      return if built?
+
+      build_default_menu
+      run_on_build_callbacks
+
+      @built = true
+    end
+
+    def run_on_build_callbacks
+      @build_callbacks.each do |callback|
+        callback.call(self)
+      end
+    end
+
+    def build_default_menu
+      find_or_create DEFAULT_MENU
+    end
+
+    def find_or_create(menu_name)
+      menu_name ||= DEFAULT_MENU
+      @menus[menu_name] ||= ActiveAdmin::Menu.new
+    end
+
+
+
+  end
+
+end

data/lib/active_admin/menu_item.rb

@@ -0,0 +1,97 @@
+require 'active_admin/view_helpers/method_or_proc_helper'
+
+module ActiveAdmin
+  class MenuItem
+    include Menu::MenuNode
+    include MethodOrProcHelper
+
+    attr_reader :html_options, :parent, :priority
+
+    # Builds a new menu item
+    #
+    # @param [Hash] options The options for the menu
+    #
+    # @option options [String, Symbol, Proc] :label
+    #         The label to display for this menu item.
+    #         Default: Titleized Resource Name
+    #
+    # @option options [String] :id
+    #         A custom id to reference this menu item with.
+    #         Default: underscored_resource_name
+    #
+    # @option options [String, Symbol, Proc] :url
+    #         The URL this item will link to.
+    #
+    # @option options [Integer] :priority
+    #         The lower the priority, the earlier in the menu the item will be displayed.
+    #         Default: 10
+    #
+    # @option options [Symbol, Proc] :if
+    #         This decides whether the menu item will be displayed. Evaluated on each request.
+    #
+    # @option options [Hash] :html_options
+    #         A hash of options to pass to `link_to` when rendering the item
+    #
+    # @option [ActiveAdmin::MenuItem] :parent
+    #         This menu item's parent. It will be displayed nested below its parent.
+    #
+    # NOTE: for :label, :url, and :if
+    # These options are evaluated in the view context at render time. Symbols are called
+    # as methods on `self`, and Procs are exec'd within `self`.
+    # Here are some examples of what you can do:
+    #
+    #   menu if:  :admin?
+    #   menu url: :new_book_path
+    #   menu url: :awesome_helper_you_defined
+    #   menu label: ->{ User.some_method }
+    #   menu label: ->{ I18n.t 'menus.user' }
+    #
+    def initialize(options = {})
+      super() # MenuNode
+      @label          = options[:label]
+      @dirty_id       = options[:id]           || options[:label]
+      @url            = options[:url]          || '#'
+      @priority       = options[:priority]     || 10
+      @html_options   = options[:html_options] || {}
+      @should_display = options[:if]           || proc{true}
+      @parent         = options[:parent]
+
+      yield(self) if block_given? # Builder style syntax
+    end
+
+    def id
+      @id ||= normalize_id @dirty_id
+    end
+
+    def label(context = nil)
+      render_in_context context, @label
+    end
+
+    def url(context = nil)
+      render_in_context context, @url
+    end
+
+    # Don't display if the :if option passed says so
+    # Don't display if the link isn't real, we have children, and none of the children are being displayed.
+    def display?(context = nil)
+      return false unless render_in_context(context, @should_display)
+      return false if     !real_url?(context) && @children.any? && !items(context).any?
+      true
+    end
+
+    # Returns an array of the ancestory of this menu item.
+    # The first item is the immediate parent of the item.
+    def ancestors
+      parent ? [parent, parent.ancestors].flatten : []
+    end
+
+    private
+
+    # URL is not nil, empty, or '#'
+    def real_url?(context = nil)
+      url = url context
+      url.present? && url != '#'
+    end
+
+  end
+end