pure-admin-rails 2.0.0

data/app/helpers/pure_admin/dropdown_helper.rb

@@ -0,0 +1,40 @@
+##
+# Helper methods for dropdown functionality.
+#
+# The recommended way of using this helper is
+#
+#   dropdown 'Tools', class: ''do
+#     dropdown_item :name, 'url', item_html: { class: '' }
+#   end
+#
+# @note this helper depends {PureAdmin::MenuHelper}
+module PureAdmin::DropdownHelper
+  ##
+  # Renders a dropdown to the view.
+  # @param name (String) the name to display on the main dropdown link.
+  # @param options (Hash) all options that can be passed to the menu_helper as menu_html are
+  # respected here.
+  # @yield The contents for the dropdown
+  def dropdown(name, options = {}, &block)
+    opts = {}
+    opts[:menu_html] = options
+    opts[:menu_html][:class] = merge_html_classes('dropdown pure-menu-horizontal', opts[:class])
+
+    content = capture(&block)
+    content = content_tag(:ul, content, class: 'pure-menu-children')
+    content = content_tag(:li, link_to(name, '', class: 'pure-menu-link') + content,
+      class: 'pure-menu-item pure-menu-has-children')
+
+    menu(opts) { content }
+  end
+
+  ##
+  # Renders a dropdown item to the view.
+  # @param name (String) the name to pass to PureAdmin::MenuHelper.menu_item_and_link
+  # @param name (url) the url to pass to PureAdmin::MenuHelper.menu_item_and_link
+  # @param name (Hash) the options to pass to PureAdmin::MenuHelper.menu_item_and_link
+  # @yield the content to pass to PureAdmin::MenuHelper.menu_item_and_link
+  def dropdown_item(name = nil, url = nil, options = nil, &block)
+    menu_item_and_link(name, url, options, &block)
+  end
+end

data/app/helpers/pure_admin/menu_helper.rb

@@ -0,0 +1,120 @@
+
+##
+# Helper methods to assist in building the Pure Admin menu.
+module PureAdmin::MenuHelper
+  ##
+  # Renders a pure menu wrapper to the view.
+  # @param options (Hash) a container for options to be passed to menus and menu lists.
+  # @param options[:menu_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @param options[:list_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @yield The contents of the menu panel
+  def menu(options = {}, &block)
+    menu_html = options.delete(:menu_html) || {}
+    menu_html[:class] = merge_html_classes('pure-menu', menu_html[:class])
+
+    list_html = options.delete(:list_html) || {}
+    list_html[:class] = merge_html_classes('pure-menu-list', list_html[:class])
+
+    content_tag(:nav, menu_html) do
+      content_tag(:ul, '', list_html, &block)
+    end
+  end
+
+  ##
+  # Renders a pure sub-menu to the view.
+  # @param options (Hash) all options that can be passed to content_tag are respected here.
+  # @yield The contents of the menu panel
+  def sub_menu(options = {}, &block)
+    options[:class] = merge_html_classes('pure-menu-list sub-menu', options[:class])
+    content_tag(:ul, '', options, &block)
+  end
+
+  ##
+  # Renders a "menu link" to the view.
+  # @param name (String, Symbol)
+  # @param url (String, Array)
+  # @param options (Hash) all options that can be passed to link_to are respected here.
+  def menu_link(name = nil, url = nil, options = nil, &block)
+    options, url, name = url, name, capture(&block) if block_given?
+    options ||= {}
+
+    name = name.to_s.titleize unless block_given? || name.respond_to?(:titleize)
+
+    options[:class] = merge_html_classes('pure-menu-link', options[:class])
+
+    url.present? ? link_to(name, url, options) : content_tag(:span, name, options)
+  end
+
+  ##
+  # Renders a "menu item" to the view.
+  # @param options (Hash) all options that can be passed to content_tag are respected here.
+  def menu_item(options = {}, &block)
+    options[:class] = merge_html_classes('pure-menu-item', options[:class])
+    options[:class] << 'current' if options.delete(:current)
+
+    condition = options.key?(:if) ? options.delete(:if) : true
+    condition = !options.delete(:unless) if options.key?(:unless)
+
+    content_tag(:li, capture(&block), options) if condition
+  end
+
+  ##
+  # Renders a "menu item" and "menu link" to the view.
+  # @param name (String, Symbol)
+  # @param url (String, Array)
+  # @param options (Hash) a container for options to be passed to menu items and links.
+  # @param options[:item_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @param options[:link_html] (Hash) all options that can be passed to link_to are respected here.
+  def menu_item_and_link(name = nil, url = nil, options = nil, &block)
+    options, url, name = url, name, capture(&block) if block_given?
+    options ||= {}
+
+    item_html = options.delete(:item_html) || {}
+    item_html[:class] = merge_html_classes('pure-menu-item', item_html[:class])
+    item_html[:if] = options[:if] if options.key?(:if)
+    item_html[:unless] = options[:unless] if options.key?(:unless)
+    item_html[:current] = true if current_menu_item?(url)
+
+    link_html = options.delete(:link_html) || {}
+
+    menu_item(item_html) do
+      menu_link(name, url, link_html)
+    end
+  end
+
+  ##
+  # Check if the menu item is currently active
+  # @param url (String) the menu item's URL.
+  def current_menu_item?(url)
+    return false unless url
+
+    begin
+      menu_item_path = URI.parse(url).try(:path)
+    rescue
+      menu_item_path = nil
+    end
+
+    return false unless menu_item_path
+
+    # only match roots on exact match
+    return request.original_fullpath == menu_item_path
+  end
+
+  ##
+  # Check if the menu item is currently active. Is active if it is parent or current.
+  # @param url (String) the menu item's URL.
+  def current_parent?(url)
+    return false unless url
+
+    begin
+      menu_item_path = URI.parse(url).try(:path)
+    rescue
+      menu_item_path = nil
+    end
+
+    return false unless menu_item_path
+
+    # match all other items to start of original_fullpath
+    return request.original_fullpath =~ /^#{Regexp.escape(menu_item_path)}(\/|$)/
+  end
+end

data/app/helpers/pure_admin/portlet_helper.rb

@@ -0,0 +1,75 @@
+##
+# Helper methods to assist in building Pure Admin portlets.
+module PureAdmin::PortletHelper
+  ##
+  # Renders a "portlet" to the view.
+  # @param title (String)
+  # @param options (Hash) a container for options to the portlet.
+  # @param options[:portlet_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @param options[:heading_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @param options[:body_html] (Hash) all options that can be passed to content_tag are respected here.
+  # @yield The contents of the portlet
+  def portlet(title, options = {}, &block)
+    portlet_html = options[:portlet_html] || {}
+    portlet_html[:class] = ['portlet clear-fix', portlet_html[:class]]
+    portlet_html[:data] ||= {}
+    portlet_html[:data][:source] = options[:source] unless block_given?
+
+    heading_html = options.delete(:heading_html) || {}
+    heading_html[:class] = merge_html_classes('portlet-heading', heading_html[:class])
+
+    body_html = options.delete(:body_html) || {}
+    body_html[:class] = merge_html_classes('portlet-body clear-fix', body_html[:class])
+
+    if options[:icon]
+      icon = content_tag(:i, nil, class: "portlet-heading-icon fa fa-fw fa-#{options[:icon].to_s.dasherize}")
+    end
+
+    # This determines if the portlet can be closed. If it is remote it can be closed. If not,
+    # it is determined by the presence of expand in the options.
+    # e.g. <%= portlet 'A title', expand: true do %>...
+    closable = options.key?(:source) || options.key?(:expand)
+
+    portlet_html[:data][:closable] = closable
+
+    controls_content = ''.html_safe
+    controls = options.delete(:controls)
+    if controls.present?
+      if controls.respond_to?(:each)
+        controls.each do |control|
+          controls_content << content_tag(:span, control, class: 'portlet-control-item')
+        end
+      else
+        controls_content << content_tag(:span, controls, class: 'portlet-control-item')
+      end
+    end
+
+    if closable
+      controls_content << content_tag(:span, nil, class: 'portlet-indicator')
+    end
+
+    if controls_content.present?
+      controls_wrapper = content_tag(:div, controls_content, class: 'portlet-controls')
+    end
+
+    # This determines if the portlet should be expanded by default. If it is explicitly given that
+    # takes precedence. If not, by default all remote portlets are not expanded and all static
+    # portlets are.
+    expand = options.key?(:expand) ? options[:expand] : block_given?
+
+    if expand
+      portlet_html[:class] << 'expanded'
+      portlet_html[:data][:expand] = true
+    end
+
+    heading_content = content_tag(:div, heading_html) do
+      (icon || ''.html_safe) + content_tag(:h4, title) + (controls_wrapper || ''.html_safe)
+    end
+
+    body_content = content_tag(:div, (capture(&block) if block_given?), body_html)
+
+    content_tag(:div, portlet_html) do
+      heading_content + body_content
+    end
+  end
+end

data/app/helpers/pure_admin/table_filters_helper.rb

@@ -0,0 +1,158 @@
+##
+# Helper methods for table filters functionality.
+#
+# The recommended way of using this helper is
+#
+#   filters_for admin_members_path do |filter|
+#     filter.on :query                           the default is a text field
+#     filter.on :answer, options: %w(Yes No)     if given an options hash, a select will be used
+#     filter.on :status, as: :active_status      when given :active_status it will use the options
+#                                                  All, Active, and Inactive and the default of
+#                                                  Active. However these can be overridden by
+#                                                  :options and :default respectively.
+#     filter.on :starts_on, as: :date            when given :date, it will enable the pure_date
+#                                                  input type
+#  end
+module PureAdmin::TableFiltersHelper
+  ##
+  # Renders the table filters form to the view.
+  # @param path (String) the path for the form_tag
+  # @param options (Hash) all options that can be passed to form_tag are respected here.
+  # @yield The contents for the table filters
+  def table_filters(path, options = {}, &block)
+    options[:class] = merge_html_classes('pure-form pure-form-stacked table-filters
+      js-partial-refresh clear-fix', options[:class])
+
+    options[:remote] = false || options[:remote]
+    options[:method] ||= :get
+
+    content = capture(&block)
+
+    if content
+      content << content_tag(:div, submit_tag('Go', class: 'pure-button pure-button-primary'),
+        class: 'filter-group filter-submit')
+      content << hidden_field_tag(:sort, params[:sort])
+      content << hidden_field_tag(:reverse_order, params[:reverse_order])
+
+      form_tag path, options do
+        content
+      end
+    end
+  end
+
+  ##
+  # Renders a table filter item to the view.
+  # @param attribute (String, Symbol)
+  # @param options (Hash)
+  # @options options (Symbol) :type the type of field to display
+  # @options options (Hash) :options the select options for select inputs
+  # @options options (String) :default the default select option for select inputs
+  # @options options (Hash) :input_html any data contained within this hash will be passed to
+  #   the appropriate *_tag method
+  # @options options (Boolean, String) :label the text to display as a label if a string. If false,
+  #   this will prevent the label from being shown
+  # @options options (Hash) :label_html any data contained within this hash will be passed to
+  #   the content_tag builder for the label
+  # @yield The contents of the table filter with the label (unless options[:label] is false)
+  def table_filter_item(attribute, options = {}, &block)
+    if block_given?
+      field = capture(&block)
+    else
+      type = options.delete(:as) || :string
+
+      # If we're given an options array, we assume it to be a select filter.
+      # This allows for more concise code in the form
+      #   table_filter_item :status, options: %w(Yes No)
+      # or
+      #   filter.on :status, options %W(Yes No)
+      type = :select if options[:options].present?
+
+      # We define the :active_status type to shortcut a common filter type.
+      if type == :active_status
+        type = :select
+        options[:options] ||= %w(All Active Inactive)
+        options[:default] ||= 'Active'
+      end
+
+      input_html = options.delete(:input_html) || {}
+      input_html[:class] = merge_html_classes('filter-control', input_html[:class])
+
+      # Defaulting to a simple text field, we choose which field to output here.
+      # @note if at some point we wish to add a new field type, here is the place to add it
+      case type
+        when :select
+          options[:options] ||= []
+          field = select_tag(attribute,
+            options_for_select(options[:options], params[attribute.to_sym] || options[:default]),
+            input_html)
+        when :date
+          input_html[:class] = merge_html_classes('pure-admin-date', input_html[:class])
+          field = text_field_tag(attribute, params[attribute.to_sym], input_html)
+          icon = content_tag(:span, nil, class: 'input-addon fa fa-fw fa-calendar')
+          field = content_tag(:div, icon + field, class: 'addon-wrapper')
+        else # :string
+          field = text_field_tag(attribute, params[attribute.to_sym], input_html)
+      end
+    end
+
+    label = ''.html_safe
+    if options[:label] != false
+      label_html = options.delete(:label_html) || {}
+      label_text = options.delete(:label) || attribute.to_s.titleize
+      label = label_tag(attribute, label_text, label_html)
+    end
+
+    content_tag(:div, label + field, class: 'filter-group')
+  end
+
+  ##
+  # Renders a table filters section to the view using the table filter builder DSL.
+  # @param resource (ActiveRecord::Base) the model instance to build the table filters for.
+  # @param options (Hash) all options that can be passed to content_tag are respected here.
+  # @yield The contents of the table filters section
+  def filters_for(path, options = {}, &block)
+    builder = TableFiltersBuilder.new(self)
+    table_filters(path, options) do
+      capture(builder, &block)
+    end
+  end
+
+  ##
+  # Allows building of table filters using a custom DSL.
+  #
+  # <%= filters_for resources_path do |filter| %>
+  #   <%= filter.on :query %>
+  # <% end %>
+  class TableFiltersBuilder
+    ##
+    # Creates an instance of TableFiltersBuilder
+    # @param helper (ApplicationHelper) instance of application helper to allow access to view helpers.
+    # @yield instance of TableFiltersBuilder
+    def initialize(helper)
+      @helper = helper
+    end
+
+    ##
+    # Renders a table_filter_item inside the table_filters using a custom DSL.
+    #
+    # @param attribute (Symbol) the attribute on the resource
+    # @param options (Hash) all options that can be passed to content_tag are respected here.
+    # @yield The contents of the details panel item
+    def on(attribute, options = {}, &block)
+      if block_given?
+        helper.table_filter_item(attribute, options, &block)
+      else
+        helper.table_filter_item(attribute, options)
+      end
+    end
+
+    private
+
+      ##
+      # Access view helpers within the details panel builder
+      # @yield instance of ApplicationHelper
+      def helper
+        @helper
+      end
+  end
+end

data/app/inputs/addon_input.rb

@@ -0,0 +1,17 @@
+##
+# Overrides the :email input type to add a default prefix.
+class AddonInput < SimpleForm::Inputs::StringInput
+  extend PureAdmin::ApplicationHelper
+
+  def icon
+    if options[:icon].present?
+      template.content_tag(:span, nil, class: ['input-addon', 'fa', 'fa-fw', options[:icon]])
+    else
+      ''
+    end
+  end
+
+  def input(wrapper_options = nil)
+    icon + super(wrapper_options)
+  end
+end

data/app/inputs/collection_select_input.rb

@@ -0,0 +1,17 @@
+##
+# Overrides SimpleForm's default CollectionSelectInput to add a class.
+# This class is then used to initialise Select2 on all collection select inputs.
+class CollectionSelectInput < SimpleForm::Inputs::CollectionSelectInput
+  def input_html_classes
+    super.push('pure-admin-select')
+  end
+
+  def input_html_options
+    super.deep_merge(
+      style: 'width: 100%;',
+      data: {
+        tags: options[:create_when_no_match] || false
+      }
+    )
+  end
+end

data/app/inputs/email_input.rb

@@ -0,0 +1,5 @@
+##
+# Overrides the :email input type to add a default prefix.
+class EmailInput < AddonInput
+  self.default_options = { icon: 'fa-envelope' }
+end

data/app/inputs/tel_input.rb

@@ -0,0 +1,5 @@
+##
+# Overrides the :tel input type to add a default prefix.
+class TelInput < AddonInput
+  self.default_options = { icon: 'fa-phone' }
+end

data/lib/generators/pure_admin/layout/USAGE

@@ -0,0 +1,10 @@
+Description:
+    This will generate skeleton layout files that you will need to modify to suit your application.
+
+Example:
+    rails generate pure_admin:layout
+
+    This will create:
+        app/views/layouts/admin.html.erb
+        app/assets/stylesheets/admin.css.scss
+