arbo 1.2.0

data/spec/arbo/unit/element_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'timeout'
+
+describe Arbo::Element do
+
+  let(:element){ Arbo::Element.new }
+
+  context "when initialized" do
+
+    it "should have no children" do
+      expect(element.children).to be_empty
+    end
+
+    it "should have no parent" do
+      expect(element.parent).to be_nil
+    end
+
+    it "should respond to the HTML builder methods" do
+      expect(element).to respond_to(:span)
+    end
+
+    it "should have a set of local assigns" do
+      context = Arbo::Context.new hello: "World"
+      element = Arbo::Element.new(context)
+      expect(element.assigns[:hello]).to eq("World")
+    end
+
+    it "should have an empty hash with no local assigns" do
+      expect(element.assigns).to eq({})
+    end
+
+  end
+
+  describe "passing in a helper object" do
+
+    let(:helper) do
+      Class.new do
+        def helper_method
+          "helper method"
+        end
+      end
+    end
+
+    let(:element){ Arbo::Element.new(Arbo::Context.new(nil, helper.new)) }
+
+    it "should call methods on the helper object and return TextNode objects" do
+      expect(element.helper_method).to eq("helper method")
+    end
+
+    it "should raise a NoMethodError if not found" do
+      expect {
+        element.a_method_that_doesnt_exist
+      }.to raise_error(NoMethodError)
+    end
+
+  end
+
+  describe "passing in assigns" do
+    let(:post){ double }
+    let(:assigns){ {post: post} }
+
+    it "should be accessible via a method call" do
+      element = Arbo::Element.new(Arbo::Context.new(assigns))
+      expect(element.post).to eq(post)
+    end
+
+  end
+
+  it "to_a.flatten should not infinitely recurse" do
+    Timeout.timeout(1) do
+      element.to_a.flatten
+    end
+  end
+
+  describe "adding a child" do
+
+    let(:child){ Arbo::Element.new }
+
+    before do
+      element.add_child child
+    end
+
+    it "should add the child to the parent" do
+      expect(element.children.first).to eq(child)
+    end
+
+    it "should set the parent of the child" do
+      expect(child.parent).to eq(element)
+    end
+
+    context "when the child is nil" do
+
+      let(:child){ nil }
+
+      it "should not add the child" do
+        expect(element.children).to be_empty
+      end
+
+    end
+
+    context "when the child is a string" do
+
+      let(:child){ "Hello World" }
+
+      it "should add as a TextNode" do
+        expect(element.children.first).to be_instance_of(Arbo::HTML::TextNode)
+        expect(element.children.first.to_s).to eq("Hello World")
+      end
+
+    end
+  end
+
+  describe "setting the content" do
+
+    context "when a string" do
+
+      before do
+        element.add_child "Hello World"
+        element.content = "Goodbye"
+      end
+
+      it "should clear the existing children" do
+        expect(element.children.size).to eq(1)
+      end
+
+      it "should add the string as a child" do
+        expect(element.children.first.to_s).to eq("Goodbye")
+      end
+
+      it "should html escape the string" do
+        string = "Goodbye <br />"
+        element.content = string
+        expect(element.content.to_s).to eq("Goodbye &lt;br /&gt;")
+      end
+    end
+
+    context "when an element" do
+      let(:content_element){ Arbo::Element.new }
+
+      before do
+        element.content = content_element
+      end
+
+      it "should set the content tag" do
+        expect(element.children.first).to eq(content_element)
+      end
+
+      it "should set the tags parent" do
+        expect(content_element.parent).to eq(element)
+      end
+    end
+
+    context "when an array of tags" do
+      let(:first){ Arbo::Element.new }
+      let(:second){ Arbo::Element.new }
+
+      before do
+        element.content = [first, second]
+      end
+
+      it "should set the content tag" do
+        expect(element.children.first).to eq(first)
+      end
+
+      it "should set the tags parent" do
+        expect(element.children.first.parent).to eq(element)
+      end
+    end
+
+  end
+
+  describe "rendering to html" do
+
+    before  { @separator = $, }
+    after   { $, = @separator }
+    let(:collection){ element + "hello world" }
+
+    it "should render the children collection" do
+      expect(element.children).to receive(:to_s).and_return("content")
+      expect(element.to_s).to eq("content")
+    end
+
+    it "should render collection when is set the default separator" do
+      $, = "_"
+      expect(collection.to_s).to eq("hello world")
+    end
+
+    it "should render collection when is not set the default separator" do
+      expect(collection.to_s).to eq("hello world")
+    end
+
+  end
+
+  describe "adding elements together" do
+
+    context "when both elements are tags" do
+      let(:first){ Arbo::Element.new }
+      let(:second){ Arbo::Element.new }
+      let(:collection){ first + second }
+
+      it "should return an instance of Collection" do
+        expect(collection).to be_an_instance_of(Arbo::ElementCollection)
+      end
+
+      it "should return the elements in the collection" do
+        expect(collection.size).to eq(2)
+        expect(collection.first).to eq(first)
+        expect(collection[1]).to eq(second)
+      end
+    end
+
+    context "when the left is a collection and the right is a tag" do
+      let(:first){ Arbo::Element.new }
+      let(:second){ Arbo::Element.new }
+      let(:third){ Arbo::Element.new }
+      let(:collection){ Arbo::ElementCollection.new([first, second]) + third}
+
+      it "should return an instance of Collection" do
+        expect(collection).to be_an_instance_of(Arbo::ElementCollection)
+      end
+
+      it "should return the elements in the collection flattened" do
+        expect(collection.size).to eq(3)
+        expect(collection[0]).to eq(first)
+        expect(collection[1]).to eq(second)
+        expect(collection[2]).to eq(third)
+      end
+    end
+
+    context "when the right is a collection and the left is a tag" do
+      let(:first){ Arbo::Element.new }
+      let(:second){ Arbo::Element.new }
+      let(:third){ Arbo::Element.new }
+      let(:collection){ first + Arbo::ElementCollection.new([second,third]) }
+
+      it "should return an instance of Collection" do
+        expect(collection).to be_an_instance_of(Arbo::ElementCollection)
+      end
+
+      it "should return the elements in the collection flattened" do
+        expect(collection.size).to eq(3)
+        expect(collection[0]).to eq(first)
+        expect(collection[1]).to eq(second)
+        expect(collection[2]).to eq(third)
+      end
+    end
+
+    context "when the left is a tag and the right is a string" do
+      let(:element){ Arbo::Element.new }
+      let(:collection){ element + "Hello World"}
+
+      it "should return an instance of Collection" do
+        expect(collection).to be_an_instance_of(Arbo::ElementCollection)
+      end
+
+      it "should return the elements in the collection" do
+        expect(collection.size).to eq(2)
+        expect(collection[0]).to eq(element)
+        expect(collection[1]).to be_an_instance_of(Arbo::HTML::TextNode)
+      end
+    end
+
+    context "when the left is a string and the right is a tag" do
+      let(:collection){ "hello World" + Arbo::Element.new}
+
+      it "should return a string" do
+        expect(collection.strip.chomp).to eq("hello World")
+      end
+    end
+  end
+
+end

data/spec/arbo/unit/html/class_list_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Arbo::HTML::ClassList do
+
+  describe ".build_from_string" do
+
+    it "should build a new list from a string of classes" do
+      list = Arbo::HTML::ClassList.build_from_string("first second")
+      expect(list.size).to eq(2)
+
+      expect(list).to match_array(%w{first second})
+    end
+
+  end
+
+end

data/spec/arbo/unit/html/tag_attributes_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Arbo::HTML::Tag, "Attributes" do
+
+  let(:tag){ Arbo::HTML::Tag.new }
+
+  describe "attributes" do
+
+    before { tag.build id: "my_id" }
+
+    it "should have an attributes hash" do
+      expect(tag.attributes).to eq({id: "my_id"})
+    end
+
+    describe "#to_s" do
+      it "should render the attributes to html" do
+        expect(tag.to_s).to eq "<tag id=\"my_id\"></tag>\n"
+      end
+
+      it "shouldn't render attributes that are empty" do
+        tag.class_list # initializes an empty ClassList
+        tag.set_attribute :foo, ''
+        tag.set_attribute :bar, nil
+
+        expect(tag.to_s).to eq "<tag id=\"my_id\"></tag>\n"
+      end
+
+      context "with hyphenated attributes" do
+        before { tag.build id: "my_id", "data-method" => "get", "data-remote" => true }
+
+        it "should render the attributes to html" do
+          expect(tag.to_s).to eq "<tag id=\"my_id\" data-method=\"get\" data-remote=\"true\"></tag>\n"
+        end
+      end
+
+      context "when there is a nested attribute" do
+        before { tag.build id: "my_id", data: { action: 'some_action' } }
+
+        it "should flatten the attributes when rendering to html" do
+          expect(tag.to_s).to eq "<tag id=\"my_id\" data-action=\"some_action\"></tag>\n"
+        end
+
+        it "shouldn't render attributes that are empty" do
+          tag.class_list # initializes an empty ClassList
+          tag.set_attribute :foo, { bar: '' }
+          tag.set_attribute :bar, { baz: nil }
+
+          expect(tag.to_s).to eq "<tag id=\"my_id\" data-action=\"some_action\"></tag>\n"
+        end
+      end
+
+      context "when there is a deeply nested attribute" do
+        before { tag.build id: "my_id", foo: { bar: { baz: 'foozle' } } }
+
+        it "should flatten the attributes when rendering to html" do
+          expect(tag.to_s).to eq "<tag id=\"my_id\" foo-bar-baz=\"foozle\"></tag>\n"
+        end
+      end
+
+      context "when there are multiple nested attributes" do
+        before { tag.build id: "my_id", foo: { bar: 'foozle1', baz: 'foozle2' } }
+
+        it "should flatten the attributes when rendering to html" do
+          expect(tag.to_s).to eq "<tag id=\"my_id\" foo-bar=\"foozle1\" foo-baz=\"foozle2\"></tag>\n"
+        end
+      end
+    end
+
+    it "should get an attribute value" do
+      expect(tag.attr(:id)).to eq("my_id")
+    end
+
+    describe "#has_attribute?" do
+      context "when the attribute exists" do
+        it "should return true" do
+          expect(tag.has_attribute?(:id)).to eq(true)
+        end
+      end
+
+      context "when the attribute does not exist" do
+        it "should return false" do
+          expect(tag.has_attribute?(:class)).to eq(false)
+        end
+      end
+    end
+
+    it "should remove an attribute" do
+      expect(tag.attributes).to eq({id: "my_id"})
+      expect(tag.remove_attribute(:id)).to eq("my_id")
+      expect(tag.attributes).to eq({})
+    end
+  end
+
+  describe "rendering attributes" do
+    it "should html safe the attribute values" do
+      tag.set_attribute(:class, '">bad things!')
+      expect(tag.to_s).to eq "<tag class=\"&quot;&gt;bad things!\"></tag>\n"
+    end
+    it "should should escape the attribute names" do
+      tag.set_attribute(">bad", "things")
+      expect(tag.to_s).to eq "<tag &gt;bad=\"things\"></tag>\n"
+    end
+  end
+end

data/spec/arbo/unit/html/tag_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Arbo::HTML::Tag do
+
+  let(:tag){ Arbo::HTML::Tag.new }
+
+  describe "building a new tag" do
+    before { tag.build "Hello World", id: "my_id" }
+
+    it "should set the contents to a string" do
+      expect(tag.content).to eq("Hello World")
+    end
+
+    it "should set the hash of options to the attributes" do
+      expect(tag.attributes).to eq({ id: "my_id" })
+    end
+  end
+
+  describe "creating a tag 'for' an object" do
+    let(:model_name){ double(singular: "resource_class")}
+    let(:resource_class){ double(model_name: model_name) }
+    let(:resource){ double(class: resource_class, to_key: ['5'])}
+
+    before do
+      tag.build for: resource
+    end
+    it "should set the id to the type and id" do
+      expect(tag.id).to eq("resource_class_5")
+    end
+
+    it "should add a class name" do
+      expect(tag.class_list).to include("resource_class")
+    end
+
+
+    describe "for an object that doesn't have a model_name" do
+      let(:resource_class){ double(name: 'ResourceClass') }
+
+      before do
+        tag.build for: resource
+      end
+
+      it "should set the id to the type and id" do
+        expect(tag.id).to eq("resource_class_5")
+      end
+
+      it "should add a class name" do
+        expect(tag.class_list).to include("resource_class")
+      end
+    end
+
+    describe "with a default_id_for_prefix" do
+
+      let(:tag) do
+        Class.new(Arbo::HTML::Tag) do
+          def default_id_for_prefix
+            "a_prefix"
+          end
+        end.new
+      end
+
+      it "should set the id to the type and id" do
+        expect(tag.id).to eq("a_prefix_resource_class_5")
+      end
+
+    end
+  end
+
+  describe "creating a tag with a for attribute" do
+    it "sets the `for` attribute when a string is given" do
+      tag.build for: "email"
+      expect(tag.attributes[:for]).to eq "email"
+    end
+
+    it "sets the `for` attribute when a symbol is given" do
+      tag.build for: :email
+      expect(tag.attributes[:for]).to eq :email
+    end
+  end
+
+  describe "css class names" do
+
+    it "should add a class" do
+      tag.add_class "hello_world"
+      expect(tag.class_names).to eq("hello_world")
+    end
+
+    it "should remove_class" do
+      tag.add_class "hello_world"
+      expect(tag.class_names).to eq("hello_world")
+      tag.remove_class "hello_world"
+      expect(tag.class_names).to eq("")
+    end
+
+    it "should not add a class if it already exists" do
+      tag.add_class "hello_world"
+      tag.add_class "hello_world"
+      expect(tag.class_names).to eq("hello_world")
+    end
+
+    it "should seperate classes with space" do
+      tag.add_class "hello world"
+      expect(tag.class_list.size).to eq(2)
+    end
+
+    it "should create a class list from a string" do
+      tag = Arbo::HTML::Tag.new
+      tag.build(class: "first-class")
+      tag.add_class "second-class"
+      expect(tag.class_list.size).to eq(2)
+    end
+
+  end
+
+  describe "#render_in" do
+    before { tag.build "Hello World", id: "my_id" }
+
+    it "renders tag" do
+      html = tag.render_in(Arbo::Context.new)
+
+      expect(html).to eq "<tag id=\"my_id\">Hello World</tag>\n"
+    end
+  end
+end

data/spec/arbo/unit/html/text_node_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Arbo::HTML::TextNode do
+
+end

data/spec/rails/integration/forms_spec.rb

@@ -0,0 +1,117 @@
+require 'rails/rails_spec_helper'
+
+describe "Building forms" do
+
+  let(:assigns){ {} }
+  let(:helpers){ mock_action_view }
+  let(:html) { form.to_s }
+  let(:output_buffer) { form.render_in(form) }
+
+  describe "building a simple form for" do
+
+    let(:form) do
+      arbo do
+        form_for MockPerson.new, url: "/" do |f|
+          f.label :name
+          f.text_field :name
+        end
+      end
+    end
+
+    it "should build a form" do
+      expect(html).to have_selector("form")
+    end
+
+    it "should include the hidden authenticity token" do
+      expect(html).to have_selector('input[type="hidden"][name="authenticity_token"][value="AUTH_TOKEN"]', visible: :hidden)
+    end
+
+    it "should create a label" do
+      expect(html).to have_selector("form label[for=mock_person_name]")
+    end
+
+    it "should create a text field" do
+      expect(html).to have_selector("form input[type=text]")
+    end
+
+    it "should render equally with each strategy" do
+      expect(output_buffer).to eq html
+    end
+  end
+
+  describe "building a form with fields for" do
+
+    let(:form) do
+      arbo do
+        form_for MockPerson.new, url: "/" do |f|
+          f.label :name
+          f.text_field :name
+          f.fields_for :permission do |pf|
+            pf.label :admin
+            pf.check_box :admin
+          end
+        end
+      end
+    end
+
+    it "should render nested label" do
+      expect(html).to have_selector("form label[for=mock_person_permission_admin]", text: "Admin")
+    end
+
+    it "should render nested label" do
+      expect(html).to have_selector("form input[type=checkbox][name='mock_person[permission][admin]']")
+    end
+
+    it "should not render a div for the proxy" do
+      expect(html).not_to have_selector("form div.fields_for_proxy")
+    end
+
+    it "should render equally with each strategy" do
+      expect(output_buffer).to eq html
+    end
+
+  end
+
+  describe "forms with other elements" do
+    let(:form) do
+      arbo do
+        form_for MockPerson.new, url: "/" do |f|
+
+          div do
+            f.label :name
+            f.text_field :name
+          end
+
+          para do
+            f.label :name
+            f.text_field :name
+          end
+
+          div class: "permissions" do
+            f.fields_for :permission do |pf|
+              div class: "permissions_label" do
+                pf.label :admin
+              end
+              pf.check_box :admin
+            end
+          end
+
+        end
+      end
+    end
+
+    it "should correctly nest elements" do
+      expect(html).to have_selector("form > p > label")
+    end
+
+    it "should correnctly nest elements within fields for" do
+      expect(html).to have_selector("form > div.permissions > div.permissions_label label")
+    end
+
+    it "should render equally with each strategy" do
+      expect(output_buffer).to eq html
+    end
+  end
+
+
+end