bootstrap-component-helper 0.2.3.2

data/app/helpers/bootstrap/image_helper.rb

@@ -0,0 +1,38 @@
+module Bootstrap
+  module ImageHelper
+
+    # Public: Rounded image helper. Use it as the same as image_tag.
+    def r_image_tag(source, options = {})
+      image_tag(source, merge_predef_class('img-rounded', options))
+    end
+
+    # Public: Circle image helper. Use it as the same as image_tag.
+    def c_image_tag(source, options = {})
+      image_tag(source, merge_predef_class('img-circle', options))
+    end
+
+    # public: Polaroid image helper. Use it as the same as image_tag.
+    def p_image_tag(source, options = {})
+      image_tag(source, merge_predef_class('img-polaroid', options))
+    end
+
+    # Public: Bootstrap icons helpers by Glyphicons.
+    #
+    # names - icon names, passed in one by one.
+    #
+    # Examples
+    #
+    #   glyph_icon(:plus)
+    #   # => <i class="icon-plus"></i>
+    #
+    #   glyph_icon(:align_justify, :white)
+    #   # => <i class="icon-align-justify icon-white"></i>
+    #
+    #   glyph_icon(%w(plus white))
+    #
+    # Returns an i tag with icon classes.
+    def glyph_icon(*names)
+      content_tag :i, nil, class: names.flatten.map { |name| "icon-#{name.to_s.gsub('_', '-')}" }
+    end
+  end
+end

data/app/helpers/bootstrap/tab_helper.rb

@@ -0,0 +1,107 @@
+module Bootstrap
+  module TabHelper
+    class Tabs
+      attr_reader :tabs, :default_index, :options, :template, :inline, :stacked,
+      :index, :id, :type, :position, :align, :content_options
+
+      def initialize(template,
+        index: 0,
+        inline: false,
+        stacked: false,
+        id: 'tabs',
+        type: 'tabs',
+        position: 'top',
+        align: 'left',
+        content_options: {},
+        **options)
+        @default_index = index
+        @inline = inline
+        @stacked = stacked
+        @id = id
+        @type = type
+        @position = position
+        @align = align
+        @content_options = content_options
+        @options = options
+        @template = template
+        @tabs = {}
+      end
+
+      # tab label and content of tabs
+      #
+      # label - label of tab
+      # options -
+      #   disabled  - true, false default: false
+      #   clickable - true, false default: true
+      #   other options that can be accpted by li
+      #   pane_options -
+      #     every option that can be accepted by div
+      def tab(label, disabled: false, pane_options: {}, **options, &block)
+        tabs[label] = { disabled: disabled, pane_options: pane_options,
+          options: options, content: block }
+      end
+
+      def to_s
+        tab_wrapper_options = { style: "display: #{inline ? 'inline-block' : 'block'};",
+          class: " tabbable tabs-#{position}" }
+
+        template.div(tab_wrapper_options) do
+          tab_content = ''
+          tab_content << template.nav(options.merge!(type: type, stacked: stacked)) do |item|
+            tabs.keys.each_with_index do |k, i|
+              li_options = (i == default_index.to_i) ? { class: "active" } : {}
+              item.add(render_label(type, k, "#{id}-tab-#{i}", tabs[k]), li_options)
+            end
+          end
+
+          tab_content << template.div(template.merge_predef_class('tab-content', content_options)) do
+            tab_panes = ''
+            tabs.values.each_with_index do |v, i|
+              tab_panes << render_content(i == default_index.to_i, "#{id}-tab-#{i}", v)
+
+            end
+            tab_panes.html_safe
+          end
+
+          tab_content.html_safe
+        end
+
+      end
+
+      private
+        def render_label(type, title, link_id, tab)
+          tab_class = tab[:disabled] ? ' disabled' : ''
+          tab[:options].merge!(data: { toggle: type.singularize })
+
+          template.link_to(title.html_safe, "##{link_id}",
+            template.merge_predef_class(tab_class, tab[:options]))
+        end
+
+        def render_content(active, link_id, tab)
+          pane_class = " tab-pane #{active ? 'active' : ''}"
+          tab[:pane_options][:id] = link_id
+
+          template.div(template.merge_predef_class(pane_class, tab[:pane_options])) do
+            template.capture(&tab[:content]) if tab[:content]
+          end
+        end
+    end
+
+    # Show Tabs
+    # options:
+    #  index: show which tab default
+    #  type: pills, tabs  default: tabs
+    #  position: below, left, right direction of tab
+    #  align: left, right. the alignment of tab, NOT AVAILABLE NOW
+    #  inline: true ,false default: false
+    #  stacked: true, false default: false
+    #  content_options
+    #    every option that can be accepted by tab content div
+    def tabs(options = {}, &block)
+      new_tabs = Tabs.new(self, options)
+      capture(new_tabs, &block) if block_given?
+      new_tabs.to_s
+    end
+
+  end
+end

data/app/helpers/bootstrap/table_helper.rb

@@ -0,0 +1,203 @@
+module Bootstrap
+  module TableHelper
+
+    class Row
+      attr_reader :columns, :options, :template
+
+      def initialize(template, options = {})
+        @template = template
+        @options = options
+        @columns = []
+      end
+
+      def column(width: nil, align: 'left', text: nil, tag: :td, **options, &block)
+        if width && width.to_i <= 12 && width.to_i > 0
+          template.merge_predef_class("span#{width.to_i}", options)
+        end
+
+        columns << {
+          options: options,
+          align: align,
+          text: text,
+          tag: tag,
+          content: block
+        }
+      end
+
+      def header(tag: :th, **options, &block)
+        if block_given?
+          column(options.merge!(tag: tag)) do
+            template.capture(&block)
+          end
+        else
+          column(options.merge!(tag: tag))
+        end
+      end
+
+      def to_s
+        template.content_tag(:tr, nil, options) do
+          tr_content = ''
+          columns.each do |c|
+            column_options = c[:options]
+            column_options[:style] ||= ''
+            column_options[:style] << "text-align: #{c[:align]};"
+
+            tr_content << template.content_tag(c[:tag], nil, column_options) do
+              if c[:content]
+                template.capture(&c[:content])
+              else
+                c[:text]
+              end
+            end
+          end
+
+          tr_content.html_safe
+        end
+      end
+
+    end
+
+    class Table
+      attr_reader :headers, :columns, :rows, :options, :default_row_options,
+      :template, :caption, :caption_options, :collection, :type, :show_header
+
+      def initialize(template,
+        default_row_options: {},
+        collection: [],
+        caption: nil,
+        caption_options: {},
+        type: 'hover',
+        show_header: true,
+        **options)
+        @template = template
+        @type = type
+        @default_row_options = default_row_options
+        @options = options
+        @collection = collection
+        @caption = caption
+        @caption_options = caption_options
+        @show_header = show_header
+        @headers = []
+        @rows = []
+        @columns = []
+        @cust_header = false
+      end
+
+      # options
+      #   width - 1~12
+      #   method - object's method, use send(method) to get value
+      #   align - text alignment: left, center and right
+      #   header_options - options of header
+      def column(method: nil, header_options: {}, **options, &block)
+        if show_header && !@cust_header
+
+          text = if method
+            collection.try(:model).try(:human_attribute_name, method)
+          end
+
+          header(header_options.reverse_merge!(width: options[:width],
+                                               align: options[:align],
+                                               text: text))
+        end
+
+        columns << { method: method, options: options, content: block }
+      end
+
+      def row(options = {}, &block)
+        new_row = Row.new(template, options.reverse_merge!(default_row_options))
+        template.capture(new_row, &block)
+        rows << new_row
+      end
+
+      def header_row(&block)
+        if @cust_header == false
+          @cust_header = true
+          headers.clear
+        end
+
+        new_row = Row.new(template)
+        template.capture(new_row, &block)
+        headers << new_row
+      end
+
+      def to_s
+        table_class = 'table'
+        type.split(' ').each do |table_type|
+          table_class << " table-#{table_type}"
+        end
+
+        template.merge_predef_class(table_class, options)
+        template.content_tag(:table, nil, options) do
+          content = ''
+          content << template.content_tag('caption', caption, caption_options) if caption
+
+          if show_header && headers.any?
+            content << template.content_tag('thead') do
+              header_content = ''
+              headers.each do |h|
+                header_content << h.to_s
+              end
+              header_content.html_safe
+            end
+          end
+
+          content << template.content_tag(:tbody) do
+            tbody_content = ''
+            if collection && collection.any?
+              collection.each_with_index do |o, i|
+                row(default_row_options) do |r|
+                  columns.each do |c|
+                    column_options = c[:options].dup
+
+                    text = if c[:method] && o.respond_to?(c[:method])
+                      o.send(c[:method])
+                    end
+
+                    if c[:content]
+                      r.column(column_options.merge!(text: text)) do
+                        template.capture(o, i, &c[:content])
+                      end
+                    else
+                      r.column(column_options.merge!(text: text))
+                    end
+                  end
+                end
+              end
+            end
+
+            rows.each do |r|
+              tbody_content << r.to_s
+            end
+
+            tbody_content.html_safe
+          end
+
+          content.html_safe
+        end
+
+      end
+
+      private
+
+        def header(options = {})
+          headers << Row.new(template) if headers.empty?
+          headers.last.header(options)
+        end
+    end
+
+    # Show bootstrap style table
+    #
+    # options: Hash
+    #   caption: caption of table.
+    #   caption_options: caption's options
+    #   collection: the collection for generating table.
+    #   type: bootstrap table type, a string is splited by spaces. default: 'hover'
+    #         for example: 'hover striped', 'hover fluid bordered'...
+    #   other options can be accepted by table
+    def table(options={})
+      table = Table.new(self, options)
+      yield table
+      table.to_s
+    end
+  end
+end

data/app/helpers/bootstrap/typography_helper.rb

@@ -0,0 +1,109 @@
+module Bootstrap
+  module TypographyHelper
+
+    # Internal: List class that represents a ul, li list with Bootstrap styles.
+    #
+    # template   - ActionView::Template instance.
+    # li_options - Default options of all li tags. ( default: {} )
+    # type       - Type of the list, can be unordered, ordered or unstyled.
+    #              ( default: 'unordered' )
+    # options    - Options can be accepted by ol or ul.
+    class List
+
+      attr_reader :collection, :options, :template, :li_options, :type
+
+      def initialize(templte, li_options: {}, type: 'unordered', **options)
+        @template = templte
+        @type = type
+        @options = options
+        @li_options = li_options
+        @collection = []
+      end
+
+      def add(content_or_options = nil, options = {})
+        content_or_options, options = '', content_or_options if content_or_options.is_a?(Hash)
+
+        collection << {options: options, content: content_or_options}
+      end
+
+      alias_method :<<, :add
+
+      def to_s
+        tag = (type == 'ordered') ? 'ol' : 'ul'
+        unstyled_class = (type == 'unstyled') ? 'unstyled ' : ''
+
+        template.content_tag(tag, nil, template.merge_predef_class(unstyled_class, options)) do
+          tag_content = ''
+
+          collection.each do |obj|
+            tag_content << template.content_tag('li', nil, obj[:options].reverse_merge(li_options)) do
+              obj[:content].html_safe
+            end
+          end
+
+          tag_content.html_safe
+        end
+      end
+    end
+
+    # Typography
+    # Headings not implemented
+    # Lead not implemented
+    # Small not implemented
+    # Bold not implemented
+    # Italics not implemented
+    # muted, text-warning, text-error, text-info, text-success not implemented
+    # Abbreviations not implemented
+    # Addresses not implemented
+    # Blockquotes not implemented
+
+    # Lists
+    ############################################################################
+
+    # Public: Bootstrap Typography List, wraps List class to generate ul or ol
+    #         tags with html options.
+    #
+    # options - options can be accepted by ul or ol.
+    #         :type       - unordered, ordered, unstyled.
+    #                       ( default: 'unordered' )
+    #         :li_options - common li options in ul ( default: {} )
+    #         other options can be accepted by ul or ol.
+    # block   - yield with List object, used to add li tags into ul or ol.
+    #           Also can add nested lists.
+    #
+    # Examples
+    #
+    #   = list(type: 'ordered') do |i|
+    #     - i.add('line 1')
+    #     - i.add('line 2')
+    #     - i.add(link_to('line 3', hello_world_path), class: "li-class")
+    #     - i.add 'line 4' + list(type: 'unstyled') do |nested_li|
+    #       - nested_li.add('line 4.1')
+    #       - nested_li.add('line 4.2')
+    #   # => <ol>
+    #          <li>line 1</li>
+    #          <li>line 2</li>
+    #          <li class="li-class">
+    #            <a href="/hello_world">line 3</a>
+    #          </li>
+    #          <li>
+    #            line 4
+    #            <ul class="unstyled">
+    #              <li>line 4.1</li>
+    #              <li>line 4.2</li>
+    #            </ul>
+    #          </li>
+    #        </ol>
+    #
+    #
+    # Returns html content of the list.
+    def list(options = {}, &block)
+      builder = List.new(self, options)
+      capture(builder, &block) if block_given?
+      builder.to_s
+    end
+
+    # Inline not implemented
+    # Description not implemented
+  end
+end