bootstrap_ui_helper 0.3.0

data/app/helpers/bootstrap_form_options_helper.rb

@@ -0,0 +1,141 @@
+module BootstrapFormOptionsHelper
+
+  class ActionView::Helpers::FormBuilder
+    include FormatHelper
+    include BootstrapFormHelper
+
+
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      label_class, field_wrapper = horizontal_layout? ? ['col-sm-3 control-label', true] : []
+
+      required = 'required' if html_options.delete(:required)
+      label_sr_only = 'sr-only' if html_options[:label].is_a?(FalseClass)
+      html_options[:class] = squeeze_n_strip("form-control #{html_options[:class]}")
+      label_class = squeeze_n_strip("#{label_class} #{required} #{label_sr_only}")
+      help_text = (html_options[:help] ? "<span class='help-block text-left'>#{html_options[:help]}</span>" : '').html_safe
+
+      select_proc = proc do
+        @template.select(@object_name,
+                         method,
+                         choices,
+                         objectify_options(options),
+                         @default_options.merge(html_options),
+                         &block) + help_text
+      end
+
+      label_proc = proc { label(method, html_options[:label], class: label_class) }
+
+      render_field(field_wrapper, label_proc, select_proc)
+    end
+
+    def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      check_boxes_proc = proc do
+        @template.collection_check_boxes(@object_name, method, collection, value_method, text_method,
+                                         objectify_options(options), @default_options.merge(html_options),
+                                         &block)
+      end
+
+      render_collection(options[:label], &check_boxes_proc)
+    end
+
+    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      radion_buttons_prc = proc do
+        @template.collection_radio_buttons(@object_name, method, collection, value_method, text_method,
+                                           objectify_options(options), @default_options.merge(html_options),
+                                           &block)
+      end
+
+      render_collection(options[:label], &radion_buttons_prc)
+    end
+
+    private
+
+    def render_label(label)
+      label_class = 'col-sm-3 control-label' if horizontal_layout?
+
+      label.present? ? "<label class='#{label_class}'>#{label}</label>  " : ''
+    end
+
+    def render_input(&input_block)
+      horizontal_layout? ? (content_tag :div, class: 'col-sm-9', &input_block) : yield
+    end
+
+    def render_collection(label, &input_block)
+      content_tag :div, class: 'form-group' do
+        (render_label(label) + render_input(&input_block)).html_safe
+      end
+    end
+
+    def horizontal_layout?
+      BootstrapFormHelper.layout == :horizontal
+    end
+  end
+
+  class ActionView::Helpers::Tags::CollectionCheckBoxes
+    attr_accessor :output_buffer
+
+    def render(&block)
+      rendered_collection = render_collection do |item, value, text, default_html_options|
+        default_html_options[:multiple] = true
+        builder = instantiate_builder(CheckBoxBuilder, item, value, text, default_html_options)
+
+        if block_given?
+          @template_object.capture(builder, &block)
+        else
+          render_check_box(builder, @options.fetch(:inline, false))
+        end
+      end
+
+      if @options.fetch(:include_hidden, true)
+        rendered_collection + hidden_field
+      else
+        rendered_collection
+      end
+    end
+
+    private
+
+    def render_check_box(builder, inline=false)
+      label_class, input_wrapper = 'checkbox-inline', true if inline
+
+      input_proc = proc do
+        content_tag :label, class: label_class do
+          builder.check_box + ' ' + builder.text
+        end
+      end
+
+      input_wrapper ? input_proc.call : (content_tag :div, class: 'checkbox', &input_proc)
+    end
+  end
+
+  class ActionView::Helpers::Tags::CollectionRadioButtons
+    attr_accessor :output_buffer
+
+    def render(&block)
+      render_collection do |item, value, text, default_html_options|
+        builder = instantiate_builder(RadioButtonBuilder, item, value, text, default_html_options)
+
+        if block_given?
+          @template_object.capture(builder, &block)
+        else
+          render_radio_button(builder, @options.fetch(:inline, false))
+        end
+      end
+    end
+
+    private
+
+    def render_radio_button(builder, inline=false)
+      label_class, input_wrapper = 'radio-inline', true if inline
+
+      input_proc = proc do
+        content_tag :label, class: label_class do
+          builder.radio_button + ' ' + builder.text
+        end
+      end
+
+      input_wrapper ? input_proc.call : (content_tag :div, class: 'radio', &input_proc)
+    end
+  end
+
+end

data/app/helpers/breadcrumb_helper.rb

@@ -0,0 +1,23 @@
+module BreadcrumbHelper
+  include FormatHelper
+
+  def breadcrumb(links=[], options={})
+    return if links.blank?
+
+    prepend_class(options, 'breadcrumb')
+
+    content_tag :ol, options do
+      links.map.with_index do |link, index|
+        render_li(link, (index == links.length - 1))
+      end.join('').html_safe
+    end
+  end
+
+  def render_li(link, last_li)
+    active = {class: 'active'} if last_li
+
+    content_tag :li, active do
+      last_li ? link[:text] : (link_to link.delete(:text), link.delete(:link), link)
+    end
+  end
+end

data/app/helpers/button_helper.rb

@@ -0,0 +1,91 @@
+module ButtonHelper
+  include ActionView::Helpers
+  include FormatHelper
+
+  def button(content_or_options=nil, options={}, &block)
+    content_or_options.is_a?(Hash) ? options = content_or_options : content = content_or_options
+
+    layout = 'btn-block' if options.delete(:layout).try(:to_sym) == :block
+    size   = get_btn_size(options.delete(:size))
+    type   = get_btn_type(options.delete(:type))
+    prepend_class(options, 'btn', type, size, layout)
+
+    content_tag :button, options do
+      content.presence || capture(&block)
+    end
+  end
+
+  def button_group(options={}, &block)
+    size   = get_btn_group_size(options.delete(:size))
+    layout = if options.delete(:layout).try(:to_sym) == :vertical
+               'btn-group-vertical'
+             else
+               'btn-group'
+             end
+
+    prepend_class(options, layout, size)
+    options[:role] = squeeze_n_strip("group #{options[:role]}")
+    options[:data] = (options[:data] || {}).merge({bui: 'btn_group', size: size})
+
+    content_tag :div, options, &block
+  end
+
+  def button_toolbar(options={}, &block)
+    prepend_class(options, 'btn-toolbar')
+    prepend_role(options, 'toolbar')
+
+    content_tag :div, options, &block
+  end
+
+  def navbar_button(content_or_options=nil, options={}, &block)
+    content_or_options.is_a?(Hash) ? options = content_or_options : content = content_or_options
+
+    prepend_class(options, 'navbar-btn')
+    button content, options, &block
+  end
+
+  private
+
+  def get_btn_size(size)
+    case size.try(:to_sym)
+    when :xsmall
+      'btn-xs'
+    when :small
+      'btn-sm'
+    when :large
+      'btn-lg'
+    else
+    end
+  end
+
+  def get_btn_type(type)
+    case type.try(:to_sym)
+    when :primary
+      'btn-primary'
+    when :info
+      'btn-info'
+    when :success
+      'btn-success'
+    when :warning
+      'btn-warning'
+    when :danger
+      'btn-danger'
+    when :link
+      'btn-link'
+    else
+      'btn-default'
+    end
+  end
+
+  def get_btn_group_size(size)
+    case size.try(:to_sym)
+    when :xsmall
+      'btn-group-xs'
+    when :small
+      'btn-group-sm'
+    when :large
+      'btn-group-lg'
+    else
+    end
+  end
+end

data/app/helpers/button_to_helper.rb

@@ -0,0 +1,17 @@
+module ButtonToHelper
+  include FormatHelper
+
+  def button_to(name = nil, options = nil, html_options = nil, &block)
+    html_options, options = options, name if block_given?
+    options      ||= {}
+    html_options ||= {}
+
+    layout = 'btn-block' if html_options.delete(:layout).try(:to_sym) == :block
+    size   = get_btn_size(html_options.delete(:size))
+    style  = get_btn_type(html_options.delete(:style))
+
+    prepend_class(html_options, 'btn', style, layout, size)
+
+    super(name, options, html_options, &block)
+  end
+end

data/app/helpers/dropdown_helper.rb

@@ -0,0 +1,137 @@
+module DropdownHelper
+
+  # TODO: support split button dropdowns
+  class DropdownListItem
+    include FormatHelper
+    include ActionView::Helpers
+
+    attr_accessor :options
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def construct
+      content_tag :li, parse_type(options), options
+    end
+
+    def parse_type(options={})
+      case options[:type].try(:to_sym)
+      when :link
+        return link_to(options[:text], options[:link], role: :menuitem,
+                       tabindex: -1)
+      when :header
+        prepend_class(options, 'dropdown-header')
+        return options[:text]
+      when :divider
+        prepend_class(options, 'divider')
+        options[:role] = 'separator'
+      else
+      end
+    end
+  end
+
+  class DropdownCreator
+    include FormatHelper
+    include ActionView::Helpers
+
+    attr_accessor :content
+    attr_accessor :list
+    attr_accessor :options
+    attr_accessor :output_buffer
+
+    def initialize(content, list, options)
+      @content = content
+      @list    = list
+      @options = options
+    end
+
+    def build
+      navbar, btn_id, klass, align, direction, size, type = process_dropdown_options(options)
+
+      btn_options  = button_options(content, size, type, btn_id, navbar)
+      list_options = list_options(btn_id, align)
+
+      tag = navbar ? :li : :div
+      prepend_class(options, 'btn-group',
+                    (direction == :up ? 'dropup' : 'dropdown'), klass)
+
+      content_tag tag, options do
+        (dropdown_button(btn_options) +
+          dropdown_list(list, list_options)).html_safe
+      end
+    end
+
+    private
+    def process_dropdown_options(options)
+      navbar    = options.delete(:category).try(:to_sym) == :navbar
+      btn_id    = options.delete(:id) || "dropdown-#{rand(0...999)}"
+      klass     = options.delete(:class)
+      active    = 'active' if options.delete(:active)
+      align     = options.delete(:align).try(:to_sym)
+      direction = options.delete(:direction).try(:to_sym)
+      size      = get_btn_size(options.delete(:size))
+      type      = get_btn_type(options.delete(:type))
+
+      [navbar, btn_id, "#{klass} #{active}", align, direction, size,
+       "btn #{type}"]
+    end
+
+    def button_options(content, size, type, id, navbar)
+      klass = navbar ? 'dropdown-toggle' : "dropdown-toggle #{size} #{type}"
+
+      {
+        content: content,
+        class: klass,
+        id: id,
+        data: {toggle: 'dropdown'},
+        aria: {haspopup: true, expended: false},
+        navbar: navbar
+      }
+    end
+
+    def list_options(btn_id, align)
+      {
+        class: align == :right ? 'dropdown-menu-right' : 'dropdown-menu-left',
+        role: 'menu',
+        aria: {labelledby: btn_id}
+      }
+    end
+
+    def dropdown_button(options={})
+      content = options.delete(:content)
+      navbar  = options.delete(:navbar)
+
+      if navbar
+        link_to '#', options do
+          (content + " <span class='caret'></span>").html_safe
+        end
+      else
+        button_tag options do
+          (content + " <span class='caret'></span>").html_safe
+        end
+      end
+    end
+
+    def dropdown_list(list_items, options={})
+      prepend_class(options, 'dropdown-menu')
+
+      content_tag :ul, options do
+        list_items.map do |item|
+          DropdownListItem.new(item).construct
+        end.join('').html_safe
+      end
+    end
+
+  end
+
+  def dropdown(content=nil, list=[], options={})
+    return if content.blank? || list.empty?
+
+    DropdownCreator.new(content, list, options).build
+  end
+
+  def navbar_dropdown(content=nil, list=[], options={})
+    dropdown(content, list, options.merge({category: :navbar}))
+  end
+end

data/app/helpers/format_helper.rb

@@ -0,0 +1,12 @@
+module FormatHelper
+
+  def squeeze_n_strip(string='')
+    string.squeeze(' ').strip
+  end
+
+  %w(class role).each do |attr|
+    define_method "prepend_#{attr}" do |options={}, *attrs|
+      options[attr.to_sym] = squeeze_n_strip("#{attrs.join(' ')} #{options[attr.to_sym]}")
+    end
+  end
+end

data/app/helpers/icon_helper.rb

@@ -0,0 +1,112 @@
+module IconHelper
+
+  class IconCreator
+    include ValidIcons
+    include FormatHelper
+    include ActionView::Helpers
+
+    attr_accessor :type
+    attr_accessor :options
+
+    def initialize(type, options)
+      @type    = type
+      @options = options
+    end
+
+    def build
+      icon_options = {
+        type:        type,
+        size:        options.delete(:size).presence || :normal,
+        fw:          options.delete(:fixed_with).presence,
+        li:          options.delete(:list_icon).presence,
+        inverse:     options.delete(:inverse).presence,
+        border:      options.delete(:border).presence,
+        pull:        options.delete(:pull).presence,
+        animate:     options.delete(:animate).presence,
+        orientation: options.delete(:orientation).presence
+
+        # TODO add fa-stack support
+        # stack = options.delete(:stack).presence
+      }
+
+      prepend_class(options, 'fa', build_fa_class(icon_options))
+
+      content_tag :i, nil, options
+    end
+
+    private
+    def build_fa_class(options)
+      type = "fa-#{options[:type]}"
+      raise 'Invalid Icon Type!' if ValidIcons::VALID_ICONS.exclude?(type)
+
+      size        = get_icon_size(options.delete(:size))
+      fw          = options[:fw].presence ? 'fa-fw' : nil
+      li          = options[:li].presence ? 'fa-li' : nil
+      inverse     = options[:inverse].presence ? 'fa-inverse' : nil
+      border      = options[:border].presence ? 'fa-border' : nil
+      pull        = get_icon_position(options[:pull])
+      animate     = get_icon_animation(options[:animate])
+      orientation = get_icon_orientation(options[:orientation])
+
+      "#{type} #{size} #{fw} #{li} #{inverse} #{border} #{pull} #{animate} #{orientation}"
+    end
+
+    def get_icon_size(size)
+      case size.try(:to_sym)
+      when :lg
+        'fa-lg'
+      when :'2x'
+        'fa-2x'
+      when :'3x'
+        'fa-3x'
+      when :'4x'
+        'fa-4x'
+      when :'5x'
+        'fa-5x'
+      else
+      end
+    end
+
+    def get_icon_position(position)
+      case position.try(:to_sym)
+      when :right
+        'fa-pull-right'
+      when :left
+        'fa-pull-left'
+      else
+      end
+    end
+
+    def get_icon_animation(animation)
+      case animation.try(:to_sym)
+      when :spin
+        'fa-spin'
+      when :pulse
+        'fa-pulse'
+      else
+      end
+    end
+
+    def get_icon_orientation(orientation)
+      case orientation.try(:to_sym)
+      when :'90'
+        'fa-rotate-90'
+      when :'180'
+        'fa-rotate-180'
+      when :'270'
+        'fa-rotate-270'
+      when :horizontal
+        'fa-flip-horizontal'
+      when :vertical
+        'fa-flip-vertical'
+      else
+      end
+    end
+  end
+
+  def icon(type=nil, options={})
+    raise 'Please provide an icon type!' if type.blank?
+
+    IconCreator.new(type, options).build
+  end
+end