attribute_pair_generator 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bac8f3031dcc068e105bf8f30c4cdc0e2008cf98
+  data.tar.gz: 2420640934192d3de205e99924aaab25eaab4286
+SHA512:
+  metadata.gz: 2b3faef7021f6a4bf7d1ff40fe4762a53d9d9c5bb0145fa1ed964205576344faeecb4b209392dbc8ce6c6e685b198c541faf3bcdaec5c509de2bfb2c56a555e9
+  data.tar.gz: 6c46c0d9b9fa7af72f6494257031911b0e50c6439e181201430d4a2ab1c18c834d9c82477f0270d23a471a4eaf120c813cfb458769fb3d5ea042b3a2cedca341

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013, Andrew Thal, Jeff Whitmire, and Contributors. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# Attribute Pair Generator
+
+* Easily generate form fields and object information fields with labels.
+* Maintain consistent form structure without lots of html overhead:
+
+Using APG, this...
+
+    <% apg = AttributePairGenerator.new(foo) %>
+    <%= form_tag foo_path(foo.id), method: :put do -%>
+      <dl>
+        <%= apg.text_field(attr: :title, help: "the title of your foo") %>
+        <%= apg.date(attr: :starts_at) %>
+        <%= apg.plain_text(attr: :status) %>
+      </dl>
+    <% end %>
+
+generates...
+
+    <form accept-charset="UTF-8" action="/foo" method="post">
+      <dl>
+        <dt>title</dt>
+        <dd>
+          <input id="title" name="title" type="text" value="bar">
+          <span class="help-inline">the title of your foo</span>
+        </dd>
+        <dt>starts at</dt>
+        <dd>
+          <input class="datepicker" id="starts_at" name="starts_at" type="text" value="2013-10-30 05:00:00 +0000">
+          <span class="help-inline"></span>
+        </dd>
+        <dt>status</dt>
+        <dd>
+          approved
+          <span class="help-inline"></span>
+        </dd>
+      </dl>
+    </form>
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'attribute_pair_generator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install attribute_pair_generator
+
+## Common Usage
+
+### Call any of the apg methods, and pass in a hash of options, common options include:
+
+* *attr*: using this option alone, you get the label to be a humanized version of the attr, and the value to be the attr called on the initialized object (if it exists)
+* *label*: override the label
+* *value*: override the value
+* *help*: help text shown after the value
+* *field_options*: pass in options to the `content_tag` for the main desired element (e.g. <a> tag, input, textarea, checkbox)
+* *dd_options*: pass in options to the `content_tag` for the dd (value)
+* *prefix*: give a prefix to input elements' names and values
+* *disabled*: disable the input element or link
+
+## Examples
+
+### link
+
+    apg.link(title: "foo", url: "http://example.com")
+
+### plain text
+
+    apg.plain_text(label: 'contract dates', value: date_field_range('contract', 'contract'))
+
+### date (can be used with jqueryui datepicker)
+
+    apg.date(attr: :starts_at)
+
+### select dropdown
+
+    apg.select(attr: :lead_editor, value: editor_id, collection: [["Tom", 0], ["Dick", 1], ["Harry", 2]])
+
+### checkbox
+
+    apg.checkbox(attr: :ops_complete, disabled: !can_mark_ops_complete?)
+
+### text field
+
+    apg.text_field(attr: :long_title)
+    apg.text_field(prefix: 'tax', attr: :id, value: '', disabled: true)
+
+### text area
+
+    apg.text_area(attr: :email_addresses, value: email_addresses.join("\n"), help: "Email addresses. One per line")
+
+### radio buttons
+
+    apg.radio(attr: :review_source, collection: [[nil, 'none'], 'Review Site'], dd_options: {class: 'horizontal-layout'})
+
+## Authors
+
+* Andrew Thal <andrew.thal@livingsocial.com>
+* Jeff Whitmire <jeff.whitmire@livingsocial.com>
+
+## License
+
+Attribute Pair Generator is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+require "rake/testtask"
+
+FileList["tasks/*.rake"].each { |task| load task }
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['spec/*_spec.rb']
+end
+
+task :default do
+  system("rspec -c")
+end

data/attribute_pair_generator.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = "attribute_pair_generator"
+  gem.version       = "1.0.1"
+  gem.authors       = ["Andrew Thal", "Jeff Whitmire"]
+  gem.email         = "andrew.thal@livingsocial.com"
+  gem.description   = %q{Easily generate form fields and object information fields with labels.}
+  gem.summary       = %q{Easily generate form fields and object information fields with labels.}
+  gem.homepage      = "https://github.com/livingsocial/attribute-pair-generator"
+
+  gem.license = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency "faker"
+  gem.add_development_dependency "rspec", '~> 2.0'
+  gem.add_development_dependency "nokogiri", '~> 1.6'
+  gem.add_dependency "actionpack", '>= 3.0.0'
+end

data/lib/attribute_pair_generator.rb

@@ -0,0 +1,109 @@
+class AttributePairGenerator
+  require 'action_view'
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::FormTagHelper
+
+  attr_accessor :output_buffer
+  attr_reader :obj
+
+  def initialize(init_obj = nil)
+    @obj = init_obj
+  end
+
+  def link(options)
+    content = link_to options[:title], options[:url], options[:field_options]
+    render(content, options)
+  end
+
+  def plain_text(options)
+    render(value(options), options)
+  end
+
+  def date(options)
+    text_field_options = field_options(options)
+    ((text_field_options[:class] ||= '') << ' datepicker').strip!
+
+    content = text_field_tag attribute(options), value(options), text_field_options
+    render(content, options)
+  end
+
+  def select(options)
+    content = select_tag attribute(options), options_for_select(options[:collection], value(options)), field_options(options, prompt: options[:prompt], include_blank: options[:include_blank])
+    render(content, options)
+  end
+
+  def checkbox(options)
+    hidden_tag = hidden_field_tag attribute(options), options[:unchecked_value].nil? ? false : options[:unchecked_value]
+    checked_value = options[:checked_value] || true
+    is_checked = value(options).to_s == checked_value.to_s
+    content = hidden_tag + check_box_tag(attribute(options), checked_value, is_checked, field_options(options))
+    render(content, options)
+  end
+
+  def text_field(options)
+    content = text_field_tag attribute(options), value(options), field_options(options)
+    render(content, options)
+  end
+
+  def text_area(options)
+    content = text_area_tag attribute(options), value(options), field_options(options)
+    render(content, options)
+  end
+
+  def radio(options)
+    content = content_tag :ol, class: 'unstyled' do
+      options[:collection].map do |element|
+        if element.is_a?(Array)
+          value = element[0]
+          label = element[1]
+        else
+          value = label = element
+        end
+        content_tag :li do
+          label_tag("#{attribute(options)}_#{value}", radio_button_tag(attribute(options), value || '', value == value(options), field_options(options)) + label, class: 'radio')
+        end
+      end.flatten.join("").html_safe
+    end
+
+    render(content, options)
+  end
+
+  private
+
+  def field_options(options, overrides={})
+    {disabled: options[:disabled], name: name(options)}.merge(overrides).merge(options.fetch(:field_options, {}))
+  end
+
+  def render(content, options)
+    dt_content = options[:label] ? options[:label].to_s : options[:attr].to_s.humanize.downcase
+    dd_content = content.to_s
+    dd_content += content_tag(:span, class: "help-inline") { options[:help].to_s } if options[:help]
+    content_tag(:dt) { dt_content } +
+      content_tag(:dd, options[:dd_options]) { dd_content.html_safe }
+  end
+
+  def value(options)
+    if options[:value]
+      options[:value]
+    elsif obj.respond_to?(options[:attr])
+      obj.send(options[:attr])
+    end
+  end
+
+  def name(options)
+    if options[:prefix]
+      "#{options[:prefix]}[#{options[:attr]}]"
+    else
+      options[:attr]
+    end
+  end
+
+  def attribute(options)
+    if options[:prefix]
+      "#{options[:prefix]}_#{options[:attr]}"
+    else
+      options[:attr]
+    end
+  end
+end

data/spec/attribute_pair_generator_spec.rb

@@ -0,0 +1,469 @@
+require 'spec_helper'
+
+describe AttributePairGenerator do
+  let(:test_object) { double(id: 1, full_name: "foo bar", date: "2013-05-13", featured: true, scheduler: 2) }
+  let(:subject) { AttributePairGenerator.new(test_object) }
+  let(:generated) { Nokogiri::HTML(subject.send(generator_method, generator_arguments)) }
+
+  shared_examples 'a generated pair structure' do
+    it { generated.css('dt').should be_present }
+    it { generated.css('dd').should be_present }
+  end
+
+  shared_examples 'accepts standard options' do
+    context 'if given a help option' do
+      it 'creates a span with the help text' do
+        generator_arguments[:help] = Faker::Lorem.sentence
+        generated.css("dd span.help-inline").text.should eq(generator_arguments[:help])
+      end
+    end
+
+    context 'if no help text given' do
+      it 'creates an empty help text area' do
+        generator_arguments.keys.should_not include(:help)
+        generated.css("dd span.help-inline").text.should be_empty
+      end
+    end
+
+    context 'if given a label option' do
+      it 'uses the given label in the dt' do
+        generator_arguments[:label] = Faker::Lorem.word
+        generated.css("dt").text.should eq(generator_arguments[:label])
+      end
+    end
+
+    context 'if no label option given' do
+      it 'uses the attribute name for the label' do
+        generator_arguments.keys.should_not include(:label)
+        generated.css("dt").text.should eq(generator_arguments[:attr].to_s.humanize.downcase)
+      end
+    end
+
+    context "if given dd_options" do
+      let(:dd_options) { {class: 'special-fluffy-dd'} }
+      it "uses those options on the dd element" do
+        generator_arguments[:dd_options] = dd_options
+        generated.css("dd").first.attributes["class"].value.should match /#{dd_options[:class]}/
+      end
+    end
+  end
+
+  shared_examples 'form field prefix generator' do
+    context 'if a prefix option is given' do
+      before do
+        generator_arguments[:prefix] = 'foo'
+      end
+
+      it 'creates the id as prefix_attribute' do
+        generated.css('dd').children.last['id'].should == "#{generator_arguments[:prefix]}_#{generator_arguments[:attr]}"
+      end
+
+      it 'creates the name as prefix[attribute]' do
+        generated.css('dd').children.last['name'].should == "#{generator_arguments[:prefix]}[#{generator_arguments[:attr]}]"
+      end
+
+      it 'does not use the prefix in the label' do
+        generated.css("dt").text.should eq(generator_arguments[:attr].to_s.humanize.downcase)
+      end
+    end
+
+    context 'if not given a prefix option' do
+      before do
+        generator_arguments.keys.should_not include(:prefix)
+      end
+
+      it 'uses the attribute as the id' do
+        generated.css('dd').children.last['id'].should == generator_arguments[:attr].to_s
+      end
+
+      it 'uses the attribute as the name' do
+        generated.css('dd').children.last['id'].should == generator_arguments[:attr].to_s
+      end
+    end
+  end
+
+  shared_examples 'form field value generator' do
+    context 'if a value option is given' do
+      before do
+        generator_arguments[:value] = '7337'
+      end
+
+      it 'uses the value given in the params' do
+        node = generated.css('dd').children.first
+
+        if node.has_attribute?('value')
+          node['value'].should == generator_arguments[:value]
+        else
+          node.text.should match /#{generator_arguments[:value]}/
+        end
+      end
+    end
+  end
+
+  describe '#obj' do
+    its(:obj) { should eq(test_object) }
+  end
+
+  context 'information field generators' do
+    describe '#plain_text' do
+      let(:generator_method) { 'plain_text' }
+
+      context 'with basic options' do
+        let(:generator_arguments) { {attr: :id} }
+
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+
+        it 'renders plain text in the dd' do
+          generated.css("dd").text.should eq(test_object.id.to_s)
+        end
+      end
+    end
+
+    describe '#link' do
+      let(:generator_method) { 'link' }
+      let(:generator_arguments) { {title: "foo", url: "http://example.com"} }
+
+      context 'with basic options' do
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+
+        it 'renders a link in the dd' do
+          generated.css("dd").children.first.node_name.should == 'a'
+        end
+
+        it 'uses the title as the text of the link' do
+          generated.css("dd a").text.should eq("foo")
+        end
+
+        it 'uses the url as the target of the link' do
+          generated.css("dd a").first.attributes["href"].value.should eq("http://example.com")
+        end
+      end
+
+      context 'if given an extra field_options parameter' do
+        before do
+          generator_arguments[:field_options] = {class: 'findable_link'}
+        end
+
+        it 'sticks the extra options on the link element' do
+          generated.css("dd a").first.attributes["class"].value.should match /#{generator_arguments[:field_options][:class]}/
+        end
+      end
+    end
+  end
+
+  context 'form input generators' do
+    describe '#date' do
+      let(:generator_method) { 'date' }
+      let(:generator_arguments) { {attr: :date} }
+
+      context 'with basic options' do
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        it_should_behave_like 'form field prefix generator'
+        it_should_behave_like 'form field value generator'
+
+        it 'renders an input element in the dd' do
+          generated.css("dd").children.first.node_name.should == 'input'
+        end
+
+        it 'rendered input element should have a text type' do
+          generated.css("dd input").first['type'].should match /text/
+        end
+
+        it 'adds the datepicker class to work with jquery-ui datepicker' do
+          generated.css("dd input").first['class'].should match /datepicker/
+        end
+      end
+
+      context 'with extra classes pass in field_options' do
+        before do
+          generator_arguments[:field_options] = {class: 'flibberty'}
+        end
+
+        it 'should have both expected classes instead of overwriting' do
+          generated.css("dd input").first['class'].should match /datepicker/
+          generated.css("dd input").first['class'].should match /#{generator_arguments[:field_options][:class]}/
+        end
+      end
+    end
+
+    describe '#select' do
+      let(:generator_method) { 'select' }
+      let(:generator_arguments) { {attr: :scheduler, collection: [[1, "Tom"], [2, "Dick"], [3, "Harry"]]} }
+
+      context 'with basic options' do
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        #it_should_behave_like 'form field generator'
+
+        it 'renders a select element in the dd' do
+          generated.css("dd").children.first.node_name.should == 'select'
+        end
+
+        context 'without the include_blank or prompt options' do
+          it 'should not have a blank option element' do
+            generated.css("dd select option").any? { |option| option.text.blank? }.should be_false
+          end
+        end
+
+        context 'with the include_blank option' do
+          before do
+            generator_arguments[:include_blank] = true
+          end
+
+          it "includes a blank option first in the selector" do
+            generated.css("dd select option")[0].text.should be_blank
+            generated.css("dd select option")[0].attributes["value"].to_s.should be_blank
+            generated.css("dd select option")[0].attributes["selected"].should be_blank
+          end
+        end
+
+        context 'with the prompt option' do
+          let(:prompt) { 'Pick Me' }
+          before do
+            generator_arguments[:prompt] = prompt
+          end
+
+          it "includes a blank option first in the selector" do
+            generated.css("dd select option")[0].text.should == prompt
+            generated.css("dd select option")[0].attributes["value"].to_s.should be_blank
+            generated.css("dd select option")[0].attributes["selected"].should be_blank
+          end
+        end
+
+        context 'with just an array of strings as the collection' do
+          before do
+            generator_arguments[:collection] = %w(Tom Dick Harry)
+          end
+
+          it "generates the expected selector" do
+            generated.css("dd select option")[0].text.should eq("Tom")
+            generated.css("dd select option")[1].text.should eq("Dick")
+            generated.css("dd select option")[2].text.should eq("Harry")
+          end
+        end
+      end
+    end
+
+    describe '#text_field' do
+      let(:generator_method) { 'text_field' }
+
+      context 'with basic options' do
+        let(:generator_arguments) { {attr: :full_name} }
+
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        it_should_behave_like 'form field prefix generator'
+        it_should_behave_like 'form field value generator'
+
+        it 'renders an input element in the dd' do
+          generated.css("dd").children.first.node_name.should == 'input'
+        end
+
+        it 'rendered input element should have a text type' do
+          generated.css("dd input").first['type'].should match /text/
+        end
+      end
+    end
+
+    describe '#text_area' do
+      let(:generator_method) { 'text_area' }
+
+      context 'with basic options' do
+        let(:generator_arguments) { {attr: :full_name} }
+
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        it_should_behave_like 'form field prefix generator'
+        it_should_behave_like 'form field value generator'
+
+        it 'renders a textarea element in the dd' do
+          generated.css("dd").children.first.node_name.should == 'textarea'
+        end
+
+        it 'sets the value of the textarea to the attribute value' do
+          generated.css("dd textarea").text.should match /#{test_object.send(generator_arguments[:attr])}/
+        end
+      end
+    end
+
+    describe '#radio' do
+      let(:generator_method) { 'radio' }
+      context 'with basic options' do
+        let(:generator_arguments) { {attr: :scheduler, collection: [[1, "Tom"], [2, "Dick"], [3, "Harry"]]} }
+
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        # can't use the shared example here, this generates a collection of form elements
+        #it_should_behave_like 'form field generator'
+
+        context 'if a prefix option is given' do
+          before do
+            generator_arguments[:prefix] = 'foo'
+          end
+
+          it 'creates the id as prefix_attribute' do
+            generated.css('dd input').each do |radio_element|
+              radio_element['id'].should match /^#{generator_arguments[:prefix]}_#{generator_arguments[:attr]}_\d$/
+            end
+          end
+
+          it 'creates the name as prefix[attribute]' do
+            generated.css('dd input').each do |radio_element|
+              radio_element['name'].should == "#{generator_arguments[:prefix]}[#{generator_arguments[:attr]}]"
+            end
+          end
+        end
+
+        context 'if given a one dimensional array for a collection' do
+          before do
+            generator_arguments[:collection] = %w(foo bar baz)
+          end
+
+          it 'should generate the same number of labels as the members of the collection' do
+            generated.css("dd label").size.should == generator_arguments[:collection].size
+          end
+
+          it 'should generate a label for each member of the collection' do
+            generated.css("dd label").collect(&:text).should == generator_arguments[:collection]
+          end
+
+          it 'should generate the same number of input elements as the members of the collection' do
+            generated.css("dd input").size.should == generator_arguments[:collection].size
+          end
+
+          it 'should set the input value for each member of the collection' do
+            generated.css("dd input").collect{|e| e.attr('value')}.should == generator_arguments[:collection]
+          end
+        end
+
+        context 'if not given a prefix option' do
+          before do
+            generator_arguments.keys.should_not include(:prefix)
+          end
+
+          it 'uses the attribute as the id' do
+            generated.css('dd input').each do |radio_element|
+              radio_element['id'].should match /^#{generator_arguments[:attr]}_\d$/
+            end
+          end
+
+          it 'uses the attribute as the name' do
+            generated.css('dd input').each do |radio_element|
+              radio_element['name'].should == generator_arguments[:attr].to_s
+            end
+          end
+        end
+
+        it 'should generate the same number of labels as the members of the collection' do
+          generated.css("dd label").size.should == generator_arguments[:collection].size
+        end
+
+        it 'should generate a label for each member of the collection' do
+          generated.css("dd label").collect(&:text).should == generator_arguments[:collection].collect { |m| m[1] }
+        end
+
+        it 'should generate the same number of input elements as the members of the collection' do
+          generated.css("dd input").size.should == generator_arguments[:collection].size
+        end
+
+        it 'builds a proper label' do
+          generator_arguments[:collection].each_with_index do |member, index|
+            generated.css("dd label")[index].attributes["for"].value.should eq("#{generator_arguments[:attr]}_#{member[0]}")
+            generated.css("dd label")[index].text.should eq(member[1])
+          end
+        end
+
+        it 'builds a proper radio button' do
+          generator_arguments[:collection].each_with_index do |member, index|
+            generated.css("dd input")[index].attributes["name"].value.should eq(generator_arguments[:attr].to_s)
+            generated.css("dd input")[index].attributes["value"].value.should eq(member[0].to_s)
+          end
+        end
+
+        it 'correctly sets the checked attribute and value based on the right value' do
+          generator_arguments[:collection].each_with_index do |member, index|
+            if test_object.send(generator_arguments[:attr]) == member[0]
+              generated.css("dd input")[index].attributes["checked"].value.should eq("checked")
+            else
+              generated.css("dd input")[index].should_not have_attribute("checked")
+            end
+          end
+        end
+      end
+    end
+
+    describe '#checkbox' do
+      let(:generator_method) { 'checkbox' }
+      let(:generator_arguments) { { attr: :featured } }
+
+      context 'with basic options' do
+        it_should_behave_like 'a generated pair structure'
+        it_should_behave_like 'accepts standard options'
+        it_should_behave_like 'form field prefix generator'
+
+        it 'renders a hidden input element in the dd' do
+          generated.css("dd").children.first.node_name.should == 'input'
+          generated.css("dd").children.first['type'].should match /hidden/
+        end
+
+        it 'renders a checkbox input element in the dd' do
+          generated.css("dd").children[1].node_name.should == 'input'
+          generated.css("dd").children[1]['type'].should match /checkbox/
+        end
+
+        it 'has a false hiden value' do
+          generated.css("dd input[type='hidden']").first['value'].should eq("false")
+        end
+
+        it 'can override a hidden value' do
+          generator_arguments[:unchecked_value] = "foo"
+          generated.css("dd input[type='hidden']").first['value'].should eq("foo")
+        end
+
+        context 'there is no explicitly set checked value' do
+          let(:generator_arguments) { { attr: :featured } }
+          it 'has a value of true' do
+            generated.css("dd input").last['value'].should eq("true")
+          end
+
+          context 'when the value is true' do
+            it 'sets the checked attribute' do
+              generated.css("dd input").last.should have_attribute("checked")
+            end
+          end
+
+          context 'when the value is not true' do
+            before { test_object.stub(:featured).and_return(false) }
+            it 'does not set the checked attribute' do
+              generated.css("dd input").last.should_not have_attribute("checked")
+            end
+          end
+        end
+
+        context 'a checked value is specified' do
+          let(:generator_arguments) { { attr: :featured, checked_value: 5 } }
+          it 'has a value of the checked value' do
+            generated.css("dd input").last['value'].should eq("5")
+          end
+
+          context 'when the value matches the checked_value' do
+            before { test_object.stub(:featured).and_return(generator_arguments[:checked_value]) }
+            it 'sets the checked attribute' do
+              generated.css("dd input").last.should have_attribute("checked")
+            end
+          end
+
+          context 'when the value does not matches the checked_value' do
+            before { test_object.stub(:featured).and_return(nil) }
+            it 'does not set the checked attribute' do
+              generated.css("dd input").last.should_not have_attribute("checked")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "rubygems"
+require "bundler/setup"
+require 'rspec/autorun'
+require "attribute_pair_generator"
+require 'nokogiri'
+require 'faker'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: attribute_pair_generator
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Andrew Thal
+- Jeff Whitmire
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Easily generate form fields and object information fields with labels.
+email: andrew.thal@livingsocial.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- attribute_pair_generator.gemspec
+- lib/attribute_pair_generator.rb
+- spec/attribute_pair_generator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/livingsocial/attribute-pair-generator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Easily generate form fields and object information fields with labels.
+test_files:
+- spec/attribute_pair_generator_spec.rb
+- spec/spec_helper.rb