formulary 0.0.2 → 0.0.3

data/spec/html_form/fields/field_spec.rb

@@ -1,10 +1,49 @@
 require 'spec_helper'
 
 describe Formulary::HtmlForm::Fields::Field do
+  let(:html_form) { Formulary::HtmlForm.new(markup) }
+  let(:field) { Formulary::HtmlForm::Fields::Field.new(html_form, element) }
+
   describe "#name" do
-    subject { Formulary::HtmlForm::Fields::Field.new(element).name }
+    subject { field.name }
     let(:markup) { %{<input type="text" name="field" />} }
 
     it { should eq("field") }
   end
+
+  describe "#label" do
+    subject { field.label }
+
+    context "when the there is no label" do
+      let(:markup) { %{<input type="text" name="field" />} }
+      it { should be_nil }
+    end
+
+    context "when the label is from a singular field" do
+      let(:markup) do
+        %{
+          <label for="field">Field</label>
+          <input type="text" id="field" name="field" />
+        }
+      end
+      it { should eql("Field") }
+    end
+
+    context "when the label is for a field group" do
+      let(:markup) do
+        %{
+          <fieldset>
+            <legend>Field</legend>
+            <label>
+              <input type="checkbox" name="field" value="first">
+            </label>
+            <label>
+              <input type="checkbox" name="field" value="second">
+            </label>
+          </fieldset>
+        }
+      end
+      it { should eql("Field") }
+    end
+  end
 end

data/spec/html_form/fields/hidden_input_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Formulary::HtmlForm::Fields::HiddenInput do
+  let(:html_form) { Formulary::HtmlForm.new(markup) }
+
   describe ".compatible_with?" do
     subject { Formulary::HtmlForm::Fields::HiddenInput.compatible_with?(element) }
     let(:markup) { %{<input type="#{type}" name="name" />} }
@@ -17,7 +19,7 @@ describe Formulary::HtmlForm::Fields::HiddenInput do
   end
 
   describe "validations" do
-    subject(:input) { Formulary::HtmlForm::Fields::HiddenInput.new(element) }
+    subject(:input) { Formulary::HtmlForm::Fields::HiddenInput.new(html_form, element) }
     let(:markup) { %{<input type="hidden" name="field"></input>} }
 
     context "passed a value" do

data/spec/html_form/fields/month_input_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::MonthInput do
+  let(:markup_with_label) { "<label for='field'>Field</label>#{markup}" }
+  let(:html_form) { Formulary::HtmlForm.new(markup_with_label) }
+
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::MonthInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_false }
+    end
+
+    context "month type" do
+      let(:type) { "month" }
+      it { should be_true }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="month" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="month" id="field" name="field" />} }
+    let(:valid_value) { "2014-01-01" }
+  end
+
+  describe "validations" do
+    subject(:input) { Formulary::HtmlForm::Fields::MonthInput.new(html_form, element) }
+    let(:markup) { %{<input type="month" id="field" name="test" min="2013-11" max="2014-02" />} }
+
+    context "with a valid month" do
+      before { input.set_value("2014-01") }
+
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "with a invalid month" do
+      before { input.set_value("1/14") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' is not a properly formatted month, please use YYYY-MM") }
+    end
+
+    context "with a month less than the min" do
+      before { input.set_value("2013-01-01") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a month after 2013-11") }
+    end
+
+    context "with a month greater than the max" do
+      before { input.set_value("2015-01") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a month before 2014-02") }
+    end
+  end
+end

data/spec/html_form/fields/number_input_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::NumberInput do
+  let(:markup_with_label) { "<label for='field'>Field</label>#{markup}" }
+  let(:html_form) { Formulary::HtmlForm.new(markup_with_label) }
+
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::NumberInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "number type" do
+      let(:type) { "number" }
+      it { should be_true }
+    end
+
+    context "email type" do
+      let(:type) { "email" }
+      it { should be_false }
+    end
+  end
+
+  describe "validations" do
+    subject(:input) { Formulary::HtmlForm::Fields::NumberInput.new(html_form, element) }
+    let(:markup) { %{<input type="number" id="field" name="name" min="2" max="10" step="2" />} }
+
+    context "with a valid number" do
+      before { input.set_value("8") }
+
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "with not a number" do
+      before { input.set_value("invalid!") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a valid number") }
+    end
+
+    context "with a number less than the min" do
+      before { input.set_value("0") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be greater than or equal to 2") }
+    end
+
+    context "with a number greater than the max" do
+      before { input.set_value("11") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be less than or equal to 10") }
+    end
+
+    context "with a number that does not fit the step" do
+      before { input.set_value("7") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a step of 2, the nearest valid values are 6 and 8") }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="number" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="number" id="field" name="field" />} }
+    let(:valid_value) { "8" }
+  end
+end

data/spec/html_form/fields/password_input_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::PasswordInput do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::PasswordInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "password type" do
+      let(:type) { "password" }
+      it { should be_true }
+    end
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_false }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="password" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="password" id="field" name="field" />} }
+    let(:valid_value) { "test" }
+  end
+
+  it_should_behave_like "a field that allows the pattern attribute" do
+    let(:markup) { %{<input type="password" id="field" name="field" pattern="^test$" />} }
+    let(:valid_value) { "test" }
+  end
+end

data/spec/html_form/fields/radio_button_group_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe Formulary::HtmlForm::Fields::RadioButtonGroup do
+  let(:markup_with_label) do
+    "<fieldset><legend>Field</legend>#{markup}</fieldset>"
+  end
+  let(:html_form) { Formulary::HtmlForm.new(markup_with_label) }
+
   describe ".compatible_with?" do
     subject { Formulary::HtmlForm::Fields::RadioButtonGroup.compatible_with?(elements) }
 
@@ -39,12 +44,20 @@ describe Formulary::HtmlForm::Fields::RadioButtonGroup do
   end
 
   describe "validations" do
-    subject(:radio_group) { Formulary::HtmlForm::Fields::RadioButtonGroup.new("food", elements) }
+    subject(:radio_group) do
+      Formulary::HtmlForm::Fields::RadioButtonGroup.new(html_form, "food", elements)
+    end
 
     context "when one of the items in the group is required" do
       let(:markup) do
-        %{<input type="radio" name="food" value="bacon" required />
-        <input type="radio" name="food" value="butter" /> }
+        %{
+          <label>
+            Bacon<input type="radio" name="food" value="bacon" required />
+          </label>
+          <label>
+            Butter<input type="radio" name="food" value="butter" />
+          </label>
+        }
       end
 
       context "with a valid submission" do
@@ -56,26 +69,32 @@ describe Formulary::HtmlForm::Fields::RadioButtonGroup do
       context "with a value that isn't expected" do
         before { radio_group.set_value("eggplant") }
         it { should_not be_valid }
-        its(:error) { should include("choose") }
+        its(:error) { should eql("'Field' must be chosen from the available options") }
       end
 
       context "with no value" do
         before { radio_group.set_value("") }
         it { should_not be_valid }
-        its(:error) { should include("required") }
+        its(:error) { should eql("'Field' is required") }
       end
     end
 
     context "when none are required" do
       let(:markup) do
-        %{<input type="radio" name="food" value="bacon" />
-        <input type="radio" name="food" value="butter" /> }
+        %{
+          <label>
+            <input type="radio" name="food" value="bacon" />
+          </label>
+          <label>
+            <input type="radio" name="food" value="butter" />
+          </label>
+        }
       end
 
       context "with a value that isn't expected" do
         before { radio_group.set_value("eggplant") }
         it { should_not be_valid }
-        its(:error) { should include("choose") }
+        its(:error) { should eql("'Field' must be chosen from the available options") }
       end
 
       context "with no value" do

data/spec/html_form/fields/range_input_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::RangeInput do
+  let(:html_form) { Formulary::HtmlForm.new(markup) }
+
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::RangeInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "range type" do
+      let(:type) { "range" }
+      it { should be_true }
+    end
+
+    context "email type" do
+      let(:type) { "email" }
+      it { should be_false }
+    end
+  end
+end

data/spec/html_form/fields/search_input_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::SearchInput do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::SearchInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "search type" do
+      let(:type) { "search" }
+      it { should be_true }
+    end
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_false }
+    end
+  end
+end

data/spec/html_form/fields/select_spec.rb

@@ -1,30 +1,33 @@
 require 'spec_helper'
 
 describe Formulary::HtmlForm::Fields::Select do
+  let(:markup_with_label) { "<label for='field'>Field</label>#{markup}" }
+  let(:html_form) { Formulary::HtmlForm.new(markup_with_label) }
+
   describe ".compatible_with?" do
     subject { Formulary::HtmlForm::Fields::Select.compatible_with?(element) }
 
     context "with a select" do
-      let(:markup) { %{<select name="name"></select>} }
+      let(:markup) { %{<select name="field"></select>} }
       it { should be_true }
     end
 
     context "with a textarea" do
-      let(:markup) { %{<textarea name="name"></textarea>} }
+      let(:markup) { %{<textarea name="field"></textarea>} }
       it { should be_false }
     end
 
     context "with an input type" do
-      let(:markup) { %{<input type="text" name="name" />} }
+      let(:markup) { %{<input type="text" name="field" />} }
       it { should be_false }
     end
   end
 
   describe "validations" do
-    subject(:input) { Formulary::HtmlForm::Fields::Select.new(element) }
+    subject(:input) { Formulary::HtmlForm::Fields::Select.new(html_form, element) }
     let(:markup) do
       <<-EOS
-        <select name="name">
+        <select id="field" name="field">
           <option>First Text</option>
           <option value="second_value">Second Text</option>
         </select>
@@ -49,14 +52,14 @@ describe Formulary::HtmlForm::Fields::Select do
       before { input.set_value("Second Text") }
 
       it { should_not be_valid }
-      its(:error) { should include("choose") }
+      its(:error) { should eql("'Field' must be chosen from the available options") }
     end
 
     context "passed a value that is not in the options" do
       before { input.set_value("unknown") }
 
       it { should_not be_valid }
-      its(:error) { should include("choose") }
+      its(:error) { should eql("'Field' must be chosen from the available options") }
     end
   end
 end

data/spec/html_form/fields/tel_input_spec.rb

@@ -17,13 +17,13 @@ describe Formulary::HtmlForm::Fields::TelInput do
   end
 
   it_should_behave_like "a field that allows the required attribute" do
-    let(:markup_with_required) { %{<input type="tel" name="field" required />} }
-    let(:markup_without_required) { %{<input type="tel" name="field" />} }
+    let(:markup_with_required) { %{<input type="tel" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="tel" id="field" name="field" />} }
     let(:valid_value) { "123-123-1234" }
   end
 
   it_should_behave_like "a field that allows the pattern attribute" do
-    let(:markup) { '<input type="tel" name="field" pattern="\d{3}-\d{3}-\d{4}" />' }
+    let(:markup) { '<input type="tel" id="field" name="field" pattern="\d{3}-\d{3}-\d{4}" />' }
     let(:valid_value) { "123-123-1234" }
   end
 end

data/spec/html_form/fields/text_input_spec.rb

@@ -17,13 +17,13 @@ describe Formulary::HtmlForm::Fields::TextInput do
   end
 
   it_should_behave_like "a field that allows the required attribute" do
-    let(:markup_with_required) { %{<input type="text" name="field" required />} }
-    let(:markup_without_required) { %{<input type="text" name="field" />} }
+    let(:markup_with_required) { %{<input type="text" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="text" id="field" name="field" />} }
     let(:valid_value) { "test" }
   end
 
   it_should_behave_like "a field that allows the pattern attribute" do
-    let(:markup) { %{<input type="text" name="field" pattern="^test$" />} }
+    let(:markup) { %{<input type="text" id="field" name="field" pattern="^test$" />} }
     let(:valid_value) { "test" }
   end
 end

data/spec/html_form/fields/textarea_spec.rb

@@ -21,8 +21,8 @@ describe Formulary::HtmlForm::Fields::Textarea do
   end
 
   it_should_behave_like "a field that allows the required attribute" do
-    let(:markup_with_required) { %{<textarea name="field" required></textarea>} }
-    let(:markup_without_required) { %{<textarea name="field"></textarea>} }
+    let(:markup_with_required) { %{<textarea id="field" name="field" required></textarea>} }
+    let(:markup_without_required) { %{<textarea id="field" name="field"></textarea>} }
     let(:valid_value) { "test" }
   end
 end

data/spec/html_form/fields/week_input_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::WeekInput do
+  let(:markup_with_label) { "<label for='field'>Field</label>#{markup}" }
+  let(:html_form) { Formulary::HtmlForm.new(markup_with_label) }
+
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::WeekInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_false }
+    end
+
+    context "week type" do
+      let(:type) { "week" }
+      it { should be_true }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="week" id="field" name="field" required />} }
+    let(:markup_without_required) { %{<input type="week" id="field" name="field" />} }
+    let(:valid_value) { "2014-W01" }
+  end
+
+  describe "validations" do
+    subject(:input) { Formulary::HtmlForm::Fields::WeekInput.new(html_form, element) }
+    let(:markup) { %{<input type="week" id="field" name="test" min="2013-W01" max="2014-W52" />} }
+
+    context "with a valid week" do
+      before { input.set_value("2014-W01") }
+
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "with a invalid week" do
+      before { input.set_value("1/44") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' is not a properly formatted week, please use YYYY-W##") }
+    end
+
+    context "with a week less than the min" do
+      before { input.set_value("2012-W01") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a week after 2013-W01") }
+    end
+
+    context "with a week greater than the max" do
+      before { input.set_value("2015-W01") }
+
+      it { should_not be_valid }
+      its(:error) { should eql("'Field' must be a week before 2014-W52") }
+    end
+  end
+end