twitter-bootstrap-for-rails 1.3.3

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/helpers/bootstrap_panel_helper.rb

@@ -0,0 +1,62 @@
+require 'helpers'
+
+module BootstrapPanelHelper
+	def panel(options={}, &block)
+		unless block_given?
+			raise 'Missing block'
+		end
+
+		panel_options = options.dup
+		panel_options[:class] = parse_html_classes_to_arr panel_options[:class]
+		panel_options[:class] << 'panel'
+
+		header = panel_options.delete :header
+		title = panel_options.delete :title
+		footer = panel_options.delete :footer
+		context = panel_options.delete :context
+
+		unless %w(primary info success warning danger).include? context.to_s
+			context = :default
+		end
+
+		panel_options[:class] << "panel-#{context}"
+
+		content = []
+		content << panel_header(header || title)
+		content << panel_body(&block)
+		content << panel_footer(footer)
+
+		content_tag :div, content.join("\n").html_safe, panel_options
+	end
+
+	private
+	def panel_body(&block)
+		content = capture &block
+
+		content_tag :div, content, class: 'panel-body'
+	end
+
+	def panel_header(header)
+		return unless header
+
+		if header.is_a? Hash
+			level = header[:level]
+
+			unless (1..6).include? level
+				level = 1
+			end
+
+			content = content_tag "h#{level}", header[:content], class: 'panel-title'
+		else
+			content = header
+		end
+
+		content_tag :div, content, class: 'panel-heading'
+	end
+
+	def panel_footer(content)
+		if content
+			content_tag :div, content, class: 'panel-footer'
+		end
+	end
+end

data/app/helpers/breadcrumbs_helper.rb

@@ -0,0 +1,10 @@
+require 'helpers'
+
+module BreadcrumbsHelper
+	def render_breadcrumbs(options={})
+		br_options = options.dup
+		br_options[:class] = parse_html_classes_to_arr br_options[:class]
+		br_options[:class] << 'breadcrumb'
+		render :partial => 'twitter-bootstrap/breadcrumbs', :layout => false, locals: {options: br_options}
+	end
+end

data/app/helpers/dropdown_helper.rb

@@ -0,0 +1,144 @@
+module DropdownHelper
+	require 'helpers'
+
+	def dropdown(text, options={}, &block)
+		container_options = options.dup
+		button_options = container_options.delete(:button) || {}
+		menu_options = container_options.delete(:menu) || {}
+
+		drop_direction = container_options.delete :drop_direction
+		container_classes = parse_html_classes_to_arr container_options[:class]
+		container_classes << 'btn-group'
+
+		if drop_direction == :up
+			container_classes << 'dropup'
+		end
+
+		container_options[:class] = container_classes
+
+		content_tag :div, render_dropdown(text, button_options, menu_options, &block), container_options
+	end
+
+	class Dropdown
+		include ActionView::Helpers::TagHelper
+
+		def item(text, link_or_options=nil, options={})
+			if link_or_options.is_a? Hash
+				link_or_options, options = nil, link_or_options
+			end
+
+			link_or_options ||= '#'
+
+			content = content_tag :a, text, href: link_or_options
+			content_tag :li, content, options
+		end
+
+		def divider(options={})
+			classes = parse_html_classes_to_arr options[:class]
+			classes << 'divider'
+			divider_options = options.dup
+			divider_options[:class] = classes
+			content_tag :li, '', divider_options
+		end
+
+		def header(text, options={})
+			header_options = options.dup
+			classes = parse_html_classes_to_arr header_options[:class]
+			classes << 'dropdown-header'
+			header_options[:class] = classes
+
+			content_tag :li, text, header_options
+		end
+	end
+
+	private
+	def render_dropdown(button_text, button_options, menu_options, &block)
+		content = []
+		content << render_button(button_text, button_options)
+		content << render_menu(menu_options, &block)
+		content.join("\n").html_safe
+	end
+
+	def btn_regex
+		/btn-(?>default|primary|warning|success|info|danger|link)/
+	end
+
+	def render_button(button_text, options={})
+		split = options[:split]
+
+		button_classes = parse_html_classes_to_arr options[:class]
+
+		unless button_classes.join =~ btn_regex
+			button_classes << 'btn-default'
+			options[:class] = button_classes
+		end
+
+		if split
+			render_split_button button_text, options
+		else
+			render_single_button button_text, options
+		end
+	end
+
+	def get_split_options(button_options)
+		split_options =
+			case button_options[:split]
+				when Hash then button_options[:split]
+				else {}
+			end
+
+		classes = parse_html_classes_to_arr split_options[:class]
+
+		unless classes.join =~ btn_regex
+			classes << btn_regex.match(parse_html_classes_to_arr(button_options[:class]).join)
+		end
+
+		classes << 'btn'
+		classes << 'dropdown-toggle'
+		split_options[:class] = classes
+		split_options[:type] = 'button'
+		split_options[:data] = { toggle: 'dropdown' }
+
+		split_options
+	end
+
+	def render_single_button(button_text, options)
+		content = []
+		content << button_text
+		content << caret
+
+		button_classes = parse_html_classes_to_arr options[:class]
+		button_classes << 'btn dropdown-toggle'
+		options[:class] = button_classes
+		options[:type] = 'button'
+		options[:data] = { toggle: 'dropdown' }
+
+		content_tag :button, content.join("\n").html_safe, options
+	end
+
+	def render_split_button(button_text, options)
+		content = []
+		split_options = get_split_options(options)
+		options.delete :split
+
+		classes = parse_html_classes_to_arr options[:class]
+		classes << 'btn'
+		options[:class] = classes
+		options[:type] = 'button'
+
+		content << content_tag(:button, button_text, options)
+		content << content_tag(:button, caret, split_options)
+		content.join("\n").html_safe
+	end
+
+	def caret
+		content_tag :span, '', class: 'caret'
+	end
+
+	def render_menu(options, &block)
+		content = capture Dropdown.new, &block
+		options[:class] = 'dropdown-menu'
+		options[:role] = 'menu'
+		content_tag :ul, content, options
+	end
+end

data/app/helpers/flash_block_helper.rb

@@ -0,0 +1,48 @@
+require 'helpers'
+
+module FlashBlockHelper
+	def flash_block(options={})
+		content = []
+
+		flash.each do |type, message|
+			content << bs_alert(type, message)
+		end
+
+		content_tag :div, content.join("\n").html_safe, options
+	end
+
+	def bs_alert(type, message, options={})
+		alert_options = options.dup
+		alert_options[:class] = parse_html_classes_to_arr alert_options[:class]
+		alert_options[:class] << 'alert'
+		alert_options[:class] << 'alert-dismissable'
+		alert_options[:class] << alert_class(type)
+
+		content = []
+		content << content_tag(:button, '&times'.html_safe, class: 'close', type: 'button', data: {dismiss: :alert}, aria: {hidden: 'true'})
+		content << message
+
+		content_tag :div, content.join("\n").html_safe, alert_options
+	end
+
+	private
+	#Render rules
+	#- `:success` render as `.alert-success`;
+	#- `:info` render as `.alert-info`;
+	#- `:warning` render as `.alert-warning`;
+	#- `:danger` render as `.alert-danger`;
+	#- `:notice` render as `.alert-success`;
+	#- `:alert` render as `.alert-danger`;
+	#- another keys render as `alert-info`.
+	def alert_class(type)
+		act_type =
+			case type
+				when :success, :notice then :success
+				when :danger, :alert then :danger
+				when :warning, :info then type
+				else :info
+			end
+
+		"alert-#{act_type}"
+	end
+end

data/app/helpers/form_group_helper.rb

@@ -0,0 +1,21 @@
+module FormGroupHelper
+	# Return a bootstrap form group markup
+	def form_group(options = {}, &block)
+		form_group_options = options.dup
+		classes = split_html_class options[:class]
+		classes << :'form-group'
+		form_group_options[:class] = classes
+		content = capture &block
+		content_tag :div, content, form_group_options
+	end
+
+	private
+	def split_html_class(classes)
+		case classes
+			when NilClass then []
+			when String then classes.split
+			when Array then classes
+			when Symbol then [classes]
+		end
+	end
+end

data/app/helpers/glyphicon_helper.rb

@@ -0,0 +1,38 @@
+module GlyphiconHelper
+	require 'helpers'
+
+	# Return the Twitter Bootstrap glyphicon html markup
+	# Parameter name is the name of icon
+	# Parameter options is the hash of additional options generating span
+	#
+	#
+	# invoke
+	# glyph :search
+	#
+	# returns
+	# <span class="glyphicon glyphicon-search"></span>
+	#
+	#
+	# invoke
+	# glyph :search, class: 'pull-right'
+	#
+	# returns
+	# <span class="pull-right glyphicon glyphicon-search"></span>
+	#
+	#
+	# invoke
+	# glyph :search, class: 'pull-right', data: { action: 'search' }
+	#
+	# returns
+	# <span class="pull-right glyphicon glyphicon-search" data-action="search"></span>
+	def glyph(name, options={})
+		glyph_options = options.dup
+		glyph_classes = parse_html_classes_to_arr glyph_options[:class]
+		glyph_classes << 'glyphicon'
+		glyph_classes << "glyphicon-#{name.to_s.gsub('_', '-')}"
+		glyph_options[:class] = glyph_classes
+
+
+		content_tag :span, '', glyph_options
+	end
+end

data/app/helpers/modal_dialog_helper.rb

@@ -0,0 +1,81 @@
+require 'helpers'
+
+module ModalDialogHelper
+	def modal_dialog(options={})
+		modal_dialog_options = options.dup
+		modal_dialog_options[:class] = parse_html_classes_to_arr modal_dialog_options[:class]
+		modal_dialog_options[:class] << 'modal'
+		modal_dialog_options[:class] << 'fade'
+
+		modal_header = modal_dialog_options.delete :header
+		modal_body = modal_dialog_options.delete :body
+		modal_footer = modal_dialog_options.delete :footer
+
+		modal_dialog_builder = ModalDialog.new self, modal_header, modal_body, modal_footer
+
+		content = modal_dialog_builder.render
+
+		content_tag :div, content, modal_dialog_options
+	end
+
+	def dismiss_button(text, options={})
+		#<button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+		button_options = options.dup
+		button_options[:class] = parse_html_classes_to_arr button_options[:class]
+		button_options[:class] << 'btn'
+		button_options[:data] ||= {}
+		button_options[:data][:dismiss] = 'modal'
+
+		unless button_options[:class].join =~ /btn-(?>default|primary|warning|success|info|danger|link)/
+			button_options[:class] << 'btn-default'
+		end
+
+		content_tag :button, text, button_options
+	end
+
+	class ModalDialog
+		attr_accessor :parent, :header, :body, :footer
+		delegate :content_tag, to: :parent
+
+		def initialize(parent, header, body, footer)
+			@parent = parent
+			@header = header
+			@body = body
+			@footer = footer
+		end
+
+		def render
+			content_tag :div, modal_content_block, class: 'modal-dialog'
+		end
+
+		private
+		def modal_content_block
+			content = []
+			content << modal_header_block
+			content << modal_body_block
+			content << modal_footer_block
+
+			content_tag :div, content.join("\n").html_safe, class: 'modal-content'
+		end
+
+		def modal_header_block
+			if @header
+				content_tag :div, close_button + @header, class: 'modal-header'
+			end
+		end
+
+		def close_button
+			content_tag :button, '&times'.html_safe, type: 'button', class: 'close', data: {dismiss: 'modal'}, aria: {hidden: 'true'}
+		end
+
+		def modal_body_block
+			content_tag :div, @body, class: 'modal-body'
+		end
+
+		def modal_footer_block
+			if @footer
+				content_tag :div, @footer, class: 'modal-footer'
+			end
+		end
+	end
+end

data/app/helpers/navbar_helper.rb

@@ -0,0 +1,234 @@
+module NavbarHelper
+	require 'helpers'
+
+	def navbar(options={}, &block)
+		navbar_options = options.dup
+		navbar_options[:class] = parse_html_classes_to_arr navbar_options[:class]
+		navbar_options[:class] << 'navbar'
+		navbar_options[:class] << 'navbar-default'
+		navbar_options[:role] = :navigation
+
+		fixed = navbar_options.delete(:fixed).to_s
+
+		if fixed == 'top' || fixed == 'bottom'
+			navbar_options[:class] << "navbar-fixed-#{fixed}"
+		end
+
+		static = navbar_options.delete(:static).to_s
+
+		if static == 'top'
+			navbar_options[:class] << 'navbar-static-top'
+		end
+
+		inverse = navbar_options.delete :inverse
+
+		if inverse == true
+			navbar_options[:class] << 'navbar-inverse'
+		end
+
+		brand = navbar_options.delete :brand
+
+		navbar_id = SecureRandom.hex
+
+		content = []
+		content << render_navbar_header(brand, navbar_id)
+		content << render_navbar_body(navbar_id, &block)
+
+		content_tag :nav, content.join("\n").html_safe, navbar_options
+	end
+
+	def uri_state(uri)
+		root_url = request.host_with_port + '/'
+		request_uri = request.path[1..-1]
+
+		uri.gsub(root_url)
+
+		if uri.start_with? '/'
+			uri = uri[1..-1]
+		end
+
+		if uri == request_uri
+			return :active
+		end
+
+		uri_parts = uri.split '/'
+		request_uri_parts = request_uri.split '/'
+
+		uri_parts.each_with_index do |uri_part, index|
+			if uri_part != request_uri_parts[index]
+				return :inactive
+			end
+		end
+
+		:chosen
+	end
+
+	class Navbar
+		attr_accessor :parent
+
+		def initialize(parent)
+			self.parent = parent
+		end
+
+		delegate :capture, :content_tag, :to => :parent
+
+		def group(options={}, &block)
+			navbar_group_builder = NavbarGroup.new self.parent
+			content = capture navbar_group_builder, &block
+
+			menu_group_options = options.dup
+			menu_group_options[:class] = parse_html_classes_to_arr menu_group_options[:class]
+			menu_group_options[:class] << 'nav'
+			menu_group_options[:class] << 'navbar-nav'
+			pull = menu_group_options.delete(:pull).to_s
+
+			if pull == 'left' || pull == 'right'
+				menu_group_options[:class] << "navbar-#{pull}"
+			end
+
+			content_tag :ul, content, menu_group_options
+		end
+
+		def button(text, options={})
+			button_options = options.dup
+			button_options[:class] = parse_html_classes_to_arr button_options[:class]
+			button_options[:class] << 'btn'
+			button_options[:class] << 'navbar-btn'
+
+			unless button_options[:class].join =~ /btn-(?>default|primary|warning|success|info|danger|link)/
+				button_options[:class] << 'btn-default'
+			end
+
+			content_tag :button, text, button_options
+		end
+
+		def text(text, options={})
+			text_options = options.dup
+			text_options[:class] = parse_html_classes_to_arr text_options[:class]
+			text_options[:class] << 'navbar-text'
+
+			pull = text_options.delete(:pull).to_s
+
+			if pull == 'left' || pull  == 'right'
+				text_options[:class] << "navbar-#{pull}"
+			end
+
+			content_tag :p, text, text_options
+		end
+
+		def link(text, uri, options={})
+			link_options = options.dup
+			link_options[:class] = parse_html_classes_to_arr link_options[:class]
+			link_options[:class] << 'navbar-link'
+			link_options[:href] = uri
+
+			content_tag :a, text, link_options
+		end
+	end
+
+	class NavbarGroup
+		attr_accessor :parent
+
+		def initialize(parent)
+			self.parent = parent
+		end
+
+		delegate :capture, :content_tag, :request, :link_to, :uri_state, :to => :parent
+
+		def item(text, uri, options={})
+			menu_item_options = options.dup
+			menu_item_options[:class] = parse_html_classes_to_arr menu_item_options[:class]
+
+			state = uri_state uri
+
+			if state == :active || state == :chosen
+				menu_item_options[:class] << 'active'
+			end
+
+			content = link_to text, uri
+			content_tag :li, content, menu_item_options
+		end
+
+		def dropdown(text, options={}, &block)
+			dropdown_builder = Dropdown.new self.parent
+			content = []
+			content << link_to("#{text} #{caret}".html_safe, '#', class: 'dropdown-toggle', data: {toggle: 'dropdown'})
+			items = capture dropdown_builder, &block
+			content << content_tag(:ul, items, class: 'dropdown-menu')
+
+			dropdown_options = options.dup
+			dropdown_options[:class] = parse_html_classes_to_arr dropdown_options[:class]
+			dropdown_options[:class] << 'dropdown'
+
+			if dropdown_builder.chosen
+				dropdown_options[:class] << 'active'
+			end
+
+			content_tag :li, content.join("\n").html_safe, dropdown_options
+		end
+
+		private
+		def caret
+			content_tag :span, '', class: 'caret'
+		end
+	end
+
+	class Dropdown
+		attr_accessor :parent, :chosen
+
+		def initialize(parent)
+			self.parent = parent
+			@chosen = false
+		end
+
+		delegate :capture, :content_tag, :request, :link_to, :uri_state, :to => :parent
+
+		def item(text, uri, options={})
+			menu_item_options = options.dup
+			menu_item_options[:class] = parse_html_classes_to_arr menu_item_options[:class]
+
+			state = uri_state uri
+
+			if state == :active || state == :chosen
+				menu_item_options[:class] << 'active'
+				@chosen = true
+			end
+
+			content = link_to text, uri
+			content_tag :li, content, menu_item_options
+		end
+
+		def divider
+			content_tag :li, '', class: 'divider'
+		end
+	end
+
+	private
+	def render_navbar_header(brand, navbar_id)
+		content = []
+		content << navbar_collapse_button(navbar_id)
+
+		unless brand.blank?
+			content << link_to(brand, root_path, class: 'navbar-brand')
+		end
+
+		content_tag :div, content.join("\n").html_safe, class: 'navbar-header'
+	end
+
+	def navbar_collapse_button(navbar_id)
+		content = []
+
+		3.times do
+			content << content_tag(:span, '', class: 'icon-bar')
+		end
+
+		content_tag :button, content.join("\n").html_safe, type: 'button', class: 'navbar-toggle',
+								data: {toggle: 'collapse', target: "##{navbar_id}"}
+	end
+
+	def render_navbar_body(navbar_id, &block)
+		navbar_builder = Navbar.new self
+		content = capture navbar_builder, &block
+		content_tag :div, content, class: 'collapse navbar-collapse', id: navbar_id
+	end
+end