twitter-bootstrap-form-builder 0.0.3 → 0.0.4

data/README.md

@@ -99,17 +99,24 @@ the regular `FormBuilder#text_field`, use `:label => false`:
 <%= f.text_field :email, :label => false %> # <input type="text" id="post_email" />
 ```
 
+To render the field within the Bootstrap control-group markup but without a label tag,
+use `:label => nil`:
+
+```erb
+<%= f.text_field :email, :label => nil %>
+```
+
 Checkboxes are a special case. They can contain two labels in a horizontal form, on to the left and
 one to the right.
 
 The left label uses the `:label` option and works as expected.
 
-The right label is controled by the `:about` option.
+The right label is controled by the `:text` option.
 
 Example:
 
 ```erb
-<%= f.check_box :hide_email, :about => "Do not display my email in my post" %>
+<%= f.check_box :hide_email, :text=> "Do not display my email in my post" %>
 ```
 
 Produces the following HTML:

data/lib/twitter-bootstrap-form-builder/form_builder.rb

@@ -25,24 +25,22 @@ module MNE
         define_method method_name.to_sym do |field, *args|
 
           # find the options hash, and extract the options for the label tag
-          opts       = extract_options(args)
-          label_opts = extract_sub_options(opts, :label)
+          opts = extract_options(args)
 
-          # If label is false, we're rendering the field without modification
-          return super(field, *args) if label_opts === false
+          label_tag = build_label_tag(field, opts)
 
-          # Add the TB class to the label
-          label_opts << { :class => "control-label" }
+          # If label is false, we're rendering the field without modification
+          return super(field, *args) if label_tag === false
 
           # create a help-block if present
           help_block = opts[:help_block] ? @template.content_tag(:p, opts[:help_block], :class => "help-block") : ""
 
           # propogate properties of control group up
           control_group_opts = opts[:control_group] || {}
-          control_group_opts[:class] = control_group_opts[:class] ? control_group_opts[:class] + " #{method_name}" : "#{method_name}"
+          control_group_opts[:class] = "#{control_group_opts[:class]} #{method_name}"
 
           control_group(field, control_group_opts) do
-            label(field, *label_opts) + @template.content_tag(:div, :class => "controls") do
+            label_tag + @template.content_tag(:div, :class => "controls") do
               super(field, *args) + help_block + errors_for(field)
             end
           end.html_safe
@@ -52,48 +50,85 @@ module MNE
 
       # Special handling for check boxes, which can have two labels
       def check_box(field, options = {}, checked_value = "1", unchecked_value = "0")
-        label_opts = extract_sub_options(options, :label)
-        about_opts = extract_sub_options(options, :about)
-
-        return super if label_opts == false
+        label_tag = build_label_tag(field, options)
 
-        #raise [object.errors.messages, errors_for(field)].inspect
-        # Add the TB class to the thelabel
-        label_opts << { :class => "control-label" } unless label_opts.nil?
-        about_opts << { :class => "checkbox" } if about_opts.any?
+        return super if label_tag === false
 
         control_group_opts = options[:control_group] || {}
 
-        label_tag = (label_opts ? label(field, *label_opts) : "").html_safe
-        check_box = super(field, options, checked_value, unchecked_value).html_safe
+        options[:text] ||= false
 
         control_group(field, control_group_opts) do
           label_tag + @template.content_tag(:div, :class => "controls") do
-            check_box = label(field, *about_opts) { check_box + about_opts[0] } if about_opts
-            check_box + errors_for(field)
-          end
+
+            check_box_tag = super(field, options, checked_value, unchecked_value).html_safe
+
+            about_tag = build_label_tag(field, options, :text, {:class => "checkbox"}) do |opts|
+              check_box_tag + opts[0].html_safe
+            end
+
+            about_tag ||= @template.content_tag(:label, check_box_tag, :class => "checkbox")
+
+            about_tag.html_safe + errors_for(field)
+          end.html_safe
         end.html_safe
       end
 
       protected
 
       def extract_options(args)
-        args.find { |a| a.is_a?(Hash) && a.has_key?(:label) } || {}
+        args.find { |a| a.is_a?(Hash) } || {}
       end
 
-      def extract_sub_options(opts, key = :label)
-        sub_opts = opts.keys.include?(key) ? opts[key] : []
-        opts.delete(key)
-        return false if sub_opts === false
-        return nil   if sub_opts.nil?
-        Array(sub_opts)
+      # Build a label tag (or return false, or "") based on the rules for passing
+      # nil/false/a string/an array/a hash into the options hash
+      def build_label_tag(field, opts, key = :label, defaults = { :class => "control-label" }, &block)
+        label_opts = extract_sub_options(opts, key, defaults)
+
+        # False indicates complete fall-back to FormBuilder's implementation
+        return false if label_opts === false
+
+        if label_opts
+          if block_given?
+            label(field, *label_opts) { yield(label_opts) }
+          else
+            label(field, *label_opts)
+          end
+        else
+          ""
+        end.html_safe
       end
 
-      def label_opts(opts, key = :label)
-        label_opts = extract_sub_options(opts, key)
-        label_opts << { :class => "control-label" }
+      # Pull nested (label) options out of an options hash
+      # Used primarily by checkbox's :label/:text tags
+      def extract_sub_options(opts, key = :label, defaults = {})
+        if opts.keys.include?(key)
+          sub_opts = opts.delete(key)
+
+          return [sub_opts.merge(defaults)] if sub_opts.is_a? Hash
+          return [sub_opts, defaults] if sub_opts.is_a? String
+
+          # If we were explicitly given an array, we're done.
+          # Freeze it, and pass it directly to label_tag
+          if sub_opts.is_a? Array
+            sub_opts.freeze
+            return sub_opts
+          end
+
+          # If the user explicitly passed in nil, return it
+          return nil if sub_opts.nil?
+        end
+
+        return false if sub_opts === false
+
+        sub_opts || [defaults]
       end
 
+      #def label_opts(opts, key = :label)
+      #  label_opts = Array(extract_sub_options(opts, key))
+      #  label_opts << { :class => "control-label" }
+      #end
+
       def errors_for(field)
         @template.content_tag(:span, "#{object.class.human_attribute_name(field)} #{object.errors.messages[field].to_sentence}",
                               :class => "help-inline") if object.errors.messages.has_key?(field) && object.errors.messages[field].any?

data/lib/twitter-bootstrap-form-builder/version.rb

@@ -1,5 +1,5 @@
 module MNE
   module TwitterBootstrapFormBuilder
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Matthew Eagar
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-03 00:00:00 -04:00
+date: 2012-08-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency