form 0.0.0 → 0.0.1.alpha1

data/lib/form/version.rb

@@ -2,7 +2,7 @@ module Form
   module Version
     MAJOR = 0
     MINOR = 0
-    PATCH = 0
-    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    PATCH = 1
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}.alpha1"
   end
 end

data/lib/form.rb

@@ -1,3 +1,25 @@
+require "i18n"
+require "forwardable"
+
 module Form
+  autoload :Builder, "form/builder"
+  autoload :Component, "form/component"
+  autoload :Tag, "form/tag"
   autoload :Version, "form/version"
+
+  # Lazily add locale file to I18n.
+  #
+  def self.add_locale(locale)
+    I18n.load_path << File.expand_path("../form/locales/#{locale}.yml", __FILE__)
+  end
+
+  add_locale :en
+
+  # Initialize a new Form::Builder object.
+  #
+  #   form = Form.new(params[:user], "user")
+  #
+  def self.new(data = nil, base_name = nil)
+    Builder.new(data, base_name)
+  end
 end

data/spec/form/builder_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe Form::Builder do
+  describe "#initialize" do
+    let(:data) { mock }
+    let(:base_name) { mock }
+    subject { described_class.new(data, base_name) }
+
+    its(:data) { should eql(data) }
+    its(:base_name) { should eql(base_name) }
+  end
+
+  context "building fields" do
+    describe "#text" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "text" }
+      let(:helper) { "text" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#password" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "password" }
+      let(:helper) { "password" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#file" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "file" }
+      let(:helper) { "file" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#hidden" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "hidden" }
+      let(:helper) { "hidden" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#number" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "number" }
+      let(:helper) { "number" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#email" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "email" }
+      let(:helper) { "email" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#url" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "url" }
+      let(:helper) { "url" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#search" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "search" }
+      let(:helper) { "search" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#phone" do
+      let(:component) { Form::Component::Input }
+      let(:type) { "tel" }
+      let(:helper) { "phone" }
+      it_behaves_like "input instantiation"
+    end
+
+    describe "#textarea" do
+      let(:data) { mock("dataset").as_null_object }
+      let(:options) { mock("textarea options").as_null_object }
+      let(:textarea) { mock("textarea").as_null_object }
+      subject { described_class.new(data, :user) }
+
+      it "instantiates Form::Component::TextArea" do
+        Form::Component::TextArea.should_receive(:new).with(subject, :bio, options).and_return(textarea)
+        subject.textarea :bio, options
+      end
+
+      it "calls #to_html" do
+        Form::Component::TextArea.stub :new => textarea
+        textarea.should_receive(:to_html)
+        subject.textarea :bio
+      end
+    end
+  end
+end

data/spec/form/component/base_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe Form::Component::Base do
+  subject { described_class.new(nil, nil) }
+
+  describe "#composed_name" do
+    let(:form) { mock }
+    let(:name) { "name" }
+    subject { described_class.new(form, name) }
+
+    context "without base name" do
+      before { form.stub base_name: nil }
+      specify { subject.composed_name.should eql("name") }
+    end
+
+    context "for single base name" do
+      before { form.stub base_name: "user" }
+      specify { subject.composed_name.should eql("user[name]") }
+    end
+
+    context "for multiple base name" do
+      before { form.stub base_name: ["user", "profile"] }
+      specify { subject.composed_name.should eql("user[profile][name]") }
+    end
+  end
+
+  describe "#data" do
+    let(:form) { mock.as_null_object }
+    subject { described_class.new(form, "name") }
+
+    it "delegates to form's data" do
+      form.should_receive(:data).once
+      subject.data
+    end
+  end
+
+  describe "#value" do
+    let(:form) { mock }
+    let(:name) { "name" }
+    subject { described_class.new(form, name) }
+
+    context "with objects that respond to []" do
+      it "returns value for string key" do
+        form.stub data: {"name" => "John Doe"}
+        subject.value.should eql("John Doe")
+      end
+
+      it "returns value for symbol key" do
+        form.stub data: {:name => "John Doe"}
+        subject.value.should eql("John Doe")
+      end
+    end
+
+    context "with objects that respond to the attribute" do
+      it "returns value" do
+        form.stub data: mock(name: "John Doe")
+        subject.value.should eql("John Doe")
+      end
+    end
+
+    context "with no data objects" do
+      it "returns nil" do
+        form.stub :data
+        subject.value.should be_nil
+      end
+    end
+  end
+
+  describe "#t" do
+    it "proxies arguments to I18n.t" do
+      I18n.should_receive(:t).with(:a, :b)
+      subject.t(:a, :b)
+    end
+  end
+
+  describe "#humanize" do
+    specify { subject.humanize("name").should eql("Name") }
+    specify { subject.humanize("full_name").should eql("Full name") }
+  end
+end

data/spec/form/component/input_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe Form::Component::Input do
+end

data/spec/form/component/label_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Form::Component::Label do
+  describe "#text" do
+    let(:form) { mock(base_name: nil) }
+    subject { described_class.new(form, :email) }
+
+    context "with simple name" do
+      it "returns specified text" do
+        subject.options[:text] = "E-mail address"
+        subject.text.should eql("E-mail address")
+      end
+
+      it "returns text for full scope" do
+        i18n :en, {form: {
+          labels: {email: "E-mail"}
+        }}
+
+        subject.text.should eql("E-mail")
+      end
+
+      it "returns humanized text" do
+        subject.text.should eql("Email")
+      end
+    end
+
+    context "with composed name" do
+      before { form.stub base_name: %w[user profile] }
+
+      it "returns specified text" do
+        subject.options[:text] = "E-mail address"
+        subject.text.should eql("E-mail address")
+      end
+
+      it "returns text for full scope" do
+        i18n :en, {form: {
+          labels: {user: {profile: {email: "E-mail"}}}
+        }}
+
+        subject.text.should eql("E-mail")
+      end
+
+      it "returns text for root scope" do
+        i18n :en, {form: {
+          labels: {email: "E-mail"}
+        }}
+
+        subject.text.should eql("E-mail")
+      end
+
+      it "returns humanized text" do
+        subject.text.should eql("Email")
+      end
+    end
+  end
+end

data/spec/form/component/text_area_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Form::Component::TextArea do
+  context "with defaults" do
+    let(:form) { mock(:base_name => nil, :data => nil) }
+    subject { described_class.new(form, :bio) }
+
+    it "includes cols" do
+      subject.attributes[:cols].should eql(50)
+    end
+
+    it "includes rows" do
+      subject.attributes[:rows].should eql(5)
+    end
+
+    it "includes name" do
+      subject.attributes[:name].should eql("bio")
+    end
+
+    it "returns html" do
+      html = subject.to_html
+
+      html.should have_tag(:textarea, :count => 1)
+      html.should have_tag("[cols='50']")
+      html.should have_tag("[rows='5']")
+      html.should have_tag("[name='bio']")
+    end
+  end
+
+  context "with custom options" do
+    let(:form) { mock(:base_name => :user, :data => nil) }
+    subject {
+      described_class.new(form, :bio,
+        :autofocus => true,
+        :rows => 10,
+        :cols => 25
+      )
+    }
+
+    it "includes cols" do
+      subject.attributes[:cols].should eql(25)
+    end
+
+    it "includes rows" do
+      subject.attributes[:rows].should eql(10)
+    end
+
+    it "includes name" do
+      subject.attributes[:name].should eql("user[bio]")
+    end
+
+    it "returns html" do
+      html = subject.to_html
+
+      html.should have_tag(:textarea, :count => 1)
+      html.should have_tag("[cols='25']")
+      html.should have_tag("[rows='10']")
+      html.should have_tag("[name='user[bio]']")
+      html.should have_tag("[autofocus]")
+    end
+  end
+end

data/spec/form/extensions/hash_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe Hash, "extensions" do
+  describe "#except" do
+    it "skips specified keys" do
+      {a: 1, b: 2, c: 3}.except(:a, :c).should eql(b: 2)
+    end
+  end
+end

data/spec/form/tag_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Form::Tag do
+  subject { described_class.new(:p) }
+
+  describe "#initialize" do
+    it "yields instance" do
+      tag = nil
+      described_class.new(:p) {|t| tag = t}
+      tag.should be_a(described_class)
+    end
+
+    it "evaluates block" do
+      tag = nil
+      described_class.new(:p) { tag = self }
+      tag.should be_a(described_class)
+    end
+
+    context "argument position" do
+      it "moves position" do
+        tag = described_class.new(:p, class: "hello")
+        tag.attributes.should eql(class: "hello")
+        tag.content.should eql("")
+      end
+
+      it "keeps position" do
+        tag = described_class.new(:p, "Hello", class: "hello")
+        tag.attributes.should eql(class: "hello")
+        tag.content.should eql("Hello")
+      end
+    end
+  end
+
+  describe "#<<" do
+    it "appends content" do
+      tag = described_class.new(:p)
+      tag << "Hello"
+      tag.to_s.should eql("<p>Hello</p>")
+    end
+  end
+
+  describe "#void?" do
+    it "detects void tag" do
+      subject = described_class.new(:br)
+      subject.should be_void
+    end
+
+    it "rejects as open tag" do
+      subject = described_class.new(:p)
+      subject.should_not be_void
+    end
+  end
+
+  describe "#to_s" do
+    it "renders tag" do
+      subject = described_class.new(:p, "Hello")
+      subject.to_s.should eql("<p>Hello</p>")
+    end
+
+    it "renders tag with attributes" do
+      subject = described_class.new(:p, "Hello", class: "hello")
+      subject.to_s.should eql(%[<p class="hello">Hello</p>])
+    end
+
+    it "renders open tag" do
+      subject = described_class.new(:hr)
+      subject.to_s.should eql("<hr>")
+    end
+
+    it "renders open tag with attributes" do
+      subject = described_class.new(:hr, class: "separator")
+      subject.to_s.should eql(%[<hr class="separator">])
+    end
+
+    it "renders boolean attributes" do
+      subject = described_class.new(:input, autofocus: true)
+      subject.to_s.should eql("<input autofocus>")
+    end
+
+    it "skips attributes with false value" do
+      subject = described_class.new(:input, autofocus: false)
+      subject.to_s.should eql("<input>")
+    end
+
+    it "skips attributes with empty value" do
+      subject = described_class.new(:input, value: "")
+      subject.to_s.should eql("<input>")
+    end
+
+    it "escapes attribute value" do
+      subject = described_class.new(:img, alt: "<3")
+      subject.to_s.should eql(%[<img alt="&lt;3">])
+    end
+  end
+
+  describe "#tag" do
+    it "renders simple tag" do
+      subject = described_class.new(:p)
+      subject.tag(:strong, "Hello")
+      subject.to_s.should eql("<p><strong>Hello</strong></p>")
+    end
+
+    it "renders complex tag" do
+      subject = described_class.new(:form, action: "some/path") do |form|
+        form.tag :p do |p|
+          p.tag :label, "E-mail", for: "user_email"
+          p.tag :input, type: "email", autofocus: true
+        end
+      end
+
+      subject.to_s.should have_tag("form[action='some/path']") do |form|
+        form.should have_tag("p") do |p|
+          p.should have_tag("label[for=user_email]")
+          p.should have_tag("input[type=email][autofocus]")
+        end
+      end
+    end
+  end
+end