arbre 1.0.0.rc4 → 1.2.1

data/spec/arbre/unit/element_spec.rb

@@ -7,25 +7,25 @@ describe Arbre::Element do
   context "when initialized" do
 
     it "should have no children" do
-      element.children.should be_empty
+      expect(element.children).to be_empty
     end
 
     it "should have no parent" do
-      element.parent.should be_nil
+      expect(element.parent).to be_nil
     end
 
     it "should respond to the HTML builder methods" do
-      element.should respond_to(:span)
+      expect(element).to respond_to(:span)
     end
 
     it "should have a set of local assigns" do
-      context = Arbre::Context.new :hello => "World"
+      context = Arbre::Context.new hello: "World"
       element = Arbre::Element.new(context)
-      element.assigns[:hello].should == "World"
+      expect(element.assigns[:hello]).to eq("World")
     end
 
     it "should have an empty hash with no local assigns" do
-      element.assigns.should == {}
+      expect(element.assigns).to eq({})
     end
 
   end
@@ -43,28 +43,34 @@ describe Arbre::Element do
     let(:element){ Arbre::Element.new(Arbre::Context.new(nil, helper.new)) }
 
     it "should call methods on the helper object and return TextNode objects" do
-      element.helper_method.should == "helper method"
+      expect(element.helper_method).to eq("helper method")
     end
 
     it "should raise a NoMethodError if not found" do
-      lambda {
+      expect {
         element.a_method_that_doesnt_exist
-      }.should raise_error(NoMethodError)
+      }.to raise_error(NoMethodError)
     end
 
   end
 
   describe "passing in assigns" do
-    let(:post){ stub }
-    let(:assigns){ {:post => post} }
+    let(:post){ double }
+    let(:assigns){ {post: post} }
 
     it "should be accessible via a method call" do
       element = Arbre::Element.new(Arbre::Context.new(assigns))
-      element.post.should == post
+      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){ Arbre::Element.new }
@@ -74,11 +80,11 @@ describe Arbre::Element do
     end
 
     it "should add the child to the parent" do
-      element.children.first.should == child
+      expect(element.children.first).to eq(child)
     end
 
     it "should set the parent of the child" do
-      child.parent.should == element
+      expect(child.parent).to eq(element)
     end
 
     context "when the child is nil" do
@@ -86,7 +92,7 @@ describe Arbre::Element do
       let(:child){ nil }
 
       it "should not add the child" do
-        element.children.should be_empty
+        expect(element.children).to be_empty
       end
 
     end
@@ -96,8 +102,8 @@ describe Arbre::Element do
       let(:child){ "Hello World" }
 
       it "should add as a TextNode" do
-        element.children.first.should be_instance_of(Arbre::HTML::TextNode)
-        element.children.first.to_s.should == "Hello World"
+        expect(element.children.first).to be_instance_of(Arbre::HTML::TextNode)
+        expect(element.children.first.to_s).to eq("Hello World")
       end
 
     end
@@ -113,17 +119,17 @@ describe Arbre::Element do
       end
 
       it "should clear the existing children" do
-        element.children.size.should == 1
+        expect(element.children.size).to eq(1)
       end
 
       it "should add the string as a child" do
-        element.children.first.to_s.should == "Goodbye"
+        expect(element.children.first.to_s).to eq("Goodbye")
       end
 
       it "should html escape the string" do
         string = "Goodbye <br />"
         element.content = string
-        element.content.to_s.should == "Goodbye &lt;br /&gt;"
+        expect(element.content.to_s).to eq("Goodbye &lt;br /&gt;")
       end
     end
 
@@ -135,11 +141,11 @@ describe Arbre::Element do
       end
 
       it "should set the content tag" do
-        element.children.first.should == content_element
+        expect(element.children.first).to eq(content_element)
       end
 
       it "should set the tags parent" do
-        content_element.parent.should == element
+        expect(content_element.parent).to eq(element)
       end
     end
 
@@ -152,11 +158,11 @@ describe Arbre::Element do
       end
 
       it "should set the content tag" do
-        element.children.first.should == first
+        expect(element.children.first).to eq(first)
       end
 
       it "should set the tags parent" do
-        element.children.first.parent.should == element
+        expect(element.children.first.parent).to eq(element)
       end
     end
 
@@ -164,9 +170,22 @@ describe Arbre::Element do
 
   describe "rendering to html" do
 
+    before  { @separator = $, }
+    after   { $, = @separator }
+    let(:collection){ element + "hello world" }
+
     it "should render the children collection" do
-      element.children.should_receive(:to_s).and_return("content")
-      element.to_s.should == "content"
+      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
@@ -179,13 +198,13 @@ describe Arbre::Element do
       let(:collection){ first + second }
 
       it "should return an instance of Collection" do
-        collection.should be_an_instance_of(Arbre::ElementCollection)
+        expect(collection).to be_an_instance_of(Arbre::ElementCollection)
       end
 
       it "should return the elements in the collection" do
-        collection.size.should == 2
-        collection.first.should == first
-        collection[1].should == second
+        expect(collection.size).to eq(2)
+        expect(collection.first).to eq(first)
+        expect(collection[1]).to eq(second)
       end
     end
 
@@ -196,14 +215,14 @@ describe Arbre::Element do
       let(:collection){ Arbre::ElementCollection.new([first, second]) + third}
 
       it "should return an instance of Collection" do
-        collection.should be_an_instance_of(Arbre::ElementCollection)
+        expect(collection).to be_an_instance_of(Arbre::ElementCollection)
       end
 
       it "should return the elements in the collection flattened" do
-        collection.size.should == 3
-        collection[0].should == first
-        collection[1].should == second
-        collection[2].should == third
+        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
 
@@ -214,14 +233,14 @@ describe Arbre::Element do
       let(:collection){ first + Arbre::ElementCollection.new([second,third]) }
 
       it "should return an instance of Collection" do
-        collection.should be_an_instance_of(Arbre::ElementCollection)
+        expect(collection).to be_an_instance_of(Arbre::ElementCollection)
       end
 
       it "should return the elements in the collection flattened" do
-        collection.size.should == 3
-        collection[0].should == first
-        collection[1].should == second
-        collection[2].should == third
+        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
 
@@ -230,13 +249,13 @@ describe Arbre::Element do
       let(:collection){ element + "Hello World"}
 
       it "should return an instance of Collection" do
-        collection.should be_an_instance_of(Arbre::ElementCollection)
+        expect(collection).to be_an_instance_of(Arbre::ElementCollection)
       end
 
       it "should return the elements in the collection" do
-        collection.size.should == 2
-        collection[0].should == element
-        collection[1].should be_an_instance_of(Arbre::HTML::TextNode)
+        expect(collection.size).to eq(2)
+        expect(collection[0]).to eq(element)
+        expect(collection[1]).to be_an_instance_of(Arbre::HTML::TextNode)
       end
     end
 
@@ -244,7 +263,7 @@ describe Arbre::Element do
       let(:collection){ "hello World" + Arbre::Element.new}
 
       it "should return a string" do
-        collection.strip.chomp.should == "hello World"
+        expect(collection.strip.chomp).to eq("hello World")
       end
     end
   end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Arbre::HTML::ClassList do
+
+  describe ".build_from_string" do
+
+    it "should build a new list from a string of classes" do
+      list = Arbre::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/arbre/unit/html/tag_attributes_spec.rb

@@ -6,55 +6,57 @@ describe Arbre::HTML::Tag, "Attributes" do
 
   describe "attributes" do
 
-    before { tag.build :id => "my_id" }
+    before { tag.build id: "my_id" }
 
     it "should have an attributes hash" do
-      tag.attributes.should == {:id => "my_id"}
+      expect(tag.attributes).to eq({id: "my_id"})
     end
 
     it "should render the attributes to html" do
-      tag.to_s.should == <<-HTML
-<tag id="my_id"></tag>
-HTML
+      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
 
     it "should get an attribute value" do
-      tag.attr(:id).should == "my_id"
+      expect(tag.attr(:id)).to eq("my_id")
     end
 
     describe "#has_attribute?" do
       context "when the attribute exists" do
         it "should return true" do
-          tag.has_attribute?(:id).should == true
+          expect(tag.has_attribute?(:id)).to eq(true)
         end
       end
 
       context "when the attribute does not exist" do
         it "should return false" do
-          tag.has_attribute?(:class).should == false
+          expect(tag.has_attribute?(:class)).to eq(false)
         end
       end
     end
 
     it "should remove an attribute" do
-      tag.attributes.should == {:id => "my_id"}
-      tag.remove_attribute(:id).should == "my_id"
-      tag.attributes.should == {}
+      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!")
-      tag.to_s.should == <<-HTML
-<tag class="&quot;&gt;bad things!"></tag>
-HTML
+      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")
-      tag.to_s.should == <<-HTML
-<tag &gt;bad="things"></tag>
-HTML
+      expect(tag.to_s).to eq "<tag &gt;bad=\"things\"></tag>\n"
     end
   end
 end

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

@@ -5,31 +5,48 @@ describe Arbre::HTML::Tag do
   let(:tag){ Arbre::HTML::Tag.new }
 
   describe "building a new tag" do
-    before { tag.build "Hello World", :id => "my_id" }
+    before { tag.build "Hello World", id: "my_id" }
 
     it "should set the contents to a string" do
-      tag.content.should == "Hello World"
+      expect(tag.content).to eq("Hello World")
     end
 
     it "should set the hash of options to the attributes" do
-      tag.attributes.should == { :id => "my_id" }
+      expect(tag.attributes).to eq({ id: "my_id" })
     end
   end
 
   describe "creating a tag 'for' an object" do
-    let(:model_name){ mock(:singular => "resource_class")}
-    let(:resource_class){ mock(:model_name => model_name) }
-    let(:resource){ mock(:class => resource_class, :to_key => ['5'])}
+    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
+      tag.build for: resource
     end
     it "should set the id to the type and id" do
-      tag.id.should == "resource_class_5"
+      expect(tag.id).to eq("resource_class_5")
     end
 
     it "should add a class name" do
-      tag.class_list.should include("resource_class")
+      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
@@ -43,35 +60,54 @@ describe Arbre::HTML::Tag do
       end
 
       it "should set the id to the type and id" do
-        tag.id.should == "a_prefix_resource_class_5"
+        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"
-      tag.class_names.should == "hello_world"
+      expect(tag.class_names).to eq("hello_world")
     end
 
     it "should remove_class" do
       tag.add_class "hello_world"
-      tag.class_names.should == "hello_world"
+      expect(tag.class_names).to eq("hello_world")
       tag.remove_class "hello_world"
-      tag.class_names.should == ""
+      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"
-      tag.class_names.should == "hello_world"
+      expect(tag.class_names).to eq("hello_world")
     end
 
     it "should seperate classes with space" do
       tag.add_class "hello world"
-      tag.class_list.size.should == 2
+      expect(tag.class_list.size).to eq(2)
+    end
+
+    it "should create a class list from a string" do
+      tag = Arbre::HTML::Tag.new
+      tag.build(class: "first-class")
+      tag.add_class "second-class"
+      expect(tag.class_list.size).to eq(2)
     end
 
   end

data/spec/changelog_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "Changelog" do
+  subject(:changelog) do
+    path = File.join(File.dirname(__dir__), "CHANGELOG.md")
+    File.read(path)
+  end
+
+  it 'has definitions for all implicit links' do
+    implicit_link_names = changelog.scan(/\[([^\]]+)\]\[\]/).flatten.uniq
+    implicit_link_names.each do |name|
+      expect(changelog).to include("[#{name}]: https")
+    end
+  end
+
+  describe 'entry' do
+    let(:lines) { changelog.each_line }
+
+    subject(:entries) { lines.grep(/^\*/) }
+
+    it 'does not end with a punctuation' do
+      entries.each do |entry|
+        expect(entry).not_to match(/\.$/)
+      end
+    end
+  end
+end

data/spec/rails/integration/forms_spec.rb

@@ -1,20 +1,4 @@
 require 'rails/rails_spec_helper'
-require 'active_model'
-
-
-class MockPerson
-  extend ActiveModel::Naming
-
-  attr_accessor :name
-
-  def persisted?
-    false
-  end
-
-  def to_key
-    []
-  end
-end
 
 describe "Building forms" do
 
@@ -26,7 +10,7 @@ describe "Building forms" do
 
     let(:form) do
       arbre do
-        form_for MockPerson.new, :url => "/" do |f|
+        form_for MockPerson.new, url: "/" do |f|
           f.label :name
           f.text_field :name
         end
@@ -34,19 +18,19 @@ describe "Building forms" do
     end
 
     it "should build a form" do
-      html.should have_selector("form")
+      expect(html).to have_selector("form")
     end
 
     it "should include the hidden authenticity token" do
-      html.should have_selector("form input[type=hidden][name=authenticity_token]")
+      expect(html).to include '<input type="hidden" name="authenticity_token" value="AUTH_TOKEN" />'
     end
 
     it "should create a label" do
-      html.should have_selector("form label[for=mock_person_name]")
+      expect(html).to have_selector("form label[for=mock_person_name]")
     end
 
     it "should create a text field" do
-      html.should have_selector("form input[type=text]")
+      expect(html).to have_selector("form input[type=text]")
     end
 
   end
@@ -55,7 +39,7 @@ describe "Building forms" do
 
     let(:form) do
       arbre do
-        form_for MockPerson.new, :url => "/" do |f|
+        form_for MockPerson.new, url: "/" do |f|
           f.label :name
           f.text_field :name
           f.fields_for :permission do |pf|
@@ -67,15 +51,15 @@ describe "Building forms" do
     end
 
     it "should render nested label" do
-      html.should have_selector("form label[for=mock_person_permission_admin]", :text => "Admin")
+      expect(html).to have_selector("form label[for=mock_person_permission_admin]", text: "Admin")
     end
 
     it "should render nested label" do
-      html.should have_selector("form input[type=checkbox][name='mock_person[permission][admin]']")
+      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
-      html.should_not have_selector("form div.fields_for_proxy")
+      expect(html).not_to have_selector("form div.fields_for_proxy")
     end
 
   end
@@ -83,7 +67,7 @@ describe "Building forms" do
   describe "forms with other elements" do
     let(:form) do
       arbre do
-        form_for MockPerson.new, :url => "/" do |f|
+        form_for MockPerson.new, url: "/" do |f|
 
           div do
             f.label :name
@@ -95,9 +79,9 @@ describe "Building forms" do
             f.text_field :name
           end
 
-          div :class => "permissions" do
+          div class: "permissions" do
             f.fields_for :permission do |pf|
-              div :class => "permissions_label" do
+              div class: "permissions_label" do
                 pf.label :admin
               end
               pf.check_box :admin
@@ -109,11 +93,11 @@ describe "Building forms" do
     end
 
     it "should correctly nest elements" do
-      html.should have_selector("form > p > label")
+      expect(html).to have_selector("form > p > label")
     end
 
     it "should correnctly nest elements within fields for" do
-      html.should have_selector("form > div.permissions > div.permissions_label label")
+      expect(html).to have_selector("form > div.permissions > div.permissions_label label")
     end
   end