arbre 1.0.1 → 1.0.2

data/spec/arbre/unit/component_spec.rb

@@ -20,21 +20,21 @@ describe Arbre::Component do
   let(:component){ component_class.new }
 
   it "should be a subclass of an html div" do
-    Arbre::Component.ancestors.should include(Arbre::HTML::Div)
+    expect(Arbre::Component.ancestors).to include(Arbre::HTML::Div)
   end
 
   it "should render to a div, even as a subclass" do
-    component.tag_name.should == 'div'
+    expect(component.tag_name).to eq('div')
   end
 
   it "should add a class by default" do
-    component.class_list.should include("mock_component")
+    expect(component.class_list).to include("mock_component")
   end
 
   it "should render the object using the builder method name" do
-    comp = arbre {
+    comp = expect(arbre {
       mock_component
-    }.to_s.should == <<-HTML
+    }.to_s).to eq <<-HTML
 <div class="mock_component">
   <h2>Hello World</h2>
 </div>

data/spec/arbre/unit/context_spec.rb

@@ -10,26 +10,26 @@ describe Arbre::Context do
   end
 
   it "should not increment the indent_level" do
-    context.indent_level.should == -1
+    expect(context.indent_level).to eq(-1)
   end
 
   it "should return a bytesize" do
-    context.bytesize.should == 25
+    expect(context.bytesize).to eq(25)
   end
 
   it "should return a length" do
-    context.length.should == 25
+    expect(context.length).to eq(25)
   end
 
   it "should delegate missing methods to the html string" do
-    context.should respond_to(:index)
-    context.index('<').should == 0
+    expect(context).to respond_to(:index)
+    expect(context.index('<')).to eq(0)
   end
 
   it "should use a cached version of the HTML for method delegation" do
-    context.should_receive(:to_s).once.and_return("<h1>札幌市北区</h1>")
-    context.index('<').should == 0
-    context.index('<').should == 0
+    expect(context).to receive(:to_s).once.and_return("<h1>札幌市北区</h1>")
+    expect(context.index('<')).to eq(0)
+    expect(context.index('<')).to eq(0)
   end
 
 end

data/spec/arbre/unit/element_finder_methods_spec.rb

@@ -7,9 +7,9 @@ describe Arbre::Element, "Finder Methods" do
   describe "finding elements by tag name" do
 
     it "should return 0 when no elements exist" do
-      arbre {
+      expect(arbre {
         div
-      }.get_elements_by_tag_name("li").size.should == 0
+      }.get_elements_by_tag_name("li").size).to eq(0)
     end
 
     it "should return a child element" do
@@ -19,8 +19,8 @@ describe Arbre::Element, "Finder Methods" do
         ul
       end
       elements = html.get_elements_by_tag_name("li")
-      elements.size.should == 1
-      elements[0].should be_instance_of(Arbre::HTML::Li)
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
     end
 
     it "should return multple child elements" do
@@ -31,9 +31,9 @@ describe Arbre::Element, "Finder Methods" do
         li
       end
       elements = html.get_elements_by_tag_name("li")
-      elements.size.should == 2
-      elements[0].should be_instance_of(Arbre::HTML::Li)
-      elements[1].should be_instance_of(Arbre::HTML::Li)
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
+      expect(elements[1]).to be_instance_of(Arbre::HTML::Li)
     end
 
     it "should return children's child elements" do
@@ -44,10 +44,10 @@ describe Arbre::Element, "Finder Methods" do
         end
       end
       elements = html.get_elements_by_tag_name("li")
-      elements.size.should == 2
-      elements[0].should be_instance_of(Arbre::HTML::Li)
-      elements[1].should be_instance_of(Arbre::HTML::Li)
-      elements[1].parent.should == elements[0]
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
+      expect(elements[1]).to be_instance_of(Arbre::HTML::Li)
+      expect(elements[1].parent).to eq(elements[0])
     end
   end
 
@@ -56,9 +56,15 @@ describe Arbre::Element, "Finder Methods" do
   describe "finding an element by a class name" do
 
     it "should return 0 when no elements exist" do
-      arbre {
+      expect(arbre {
         div
-      }.get_elements_by_class_name("my_class").size.should == 0
+      }.get_elements_by_class_name("my_class").size).to eq(0)
+    end
+
+    it "should allow text nodes on tree" do
+      expect(arbre {
+        text_node "text"
+      }.get_elements_by_class_name("my_class").size).to eq(0)
     end
 
     it "should return a child element" do
@@ -67,8 +73,8 @@ describe Arbre::Element, "Finder Methods" do
         div :class => "my_class"
       end
       elements = html.get_elements_by_class_name("my_class")
-      elements.size.should == 1
-      elements[0].should be_instance_of(Arbre::HTML::Div)
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
     end
 
     it "should return multple child elements" do
@@ -78,9 +84,9 @@ describe Arbre::Element, "Finder Methods" do
         div :class => "my_class"
       end
       elements = html.get_elements_by_class_name("my_class")
-      elements.size.should == 2
-      elements[0].should be_instance_of(Arbre::HTML::Div)
-      elements[1].should be_instance_of(Arbre::HTML::Div)
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
+      expect(elements[1]).to be_instance_of(Arbre::HTML::Div)
     end
 
     it "should return elements that match one of several classes" do
@@ -91,11 +97,20 @@ describe Arbre::Element, "Finder Methods" do
 
       end
       elements = html.get_elements_by_class_name("this_class")
-      elements.size.should == 1
-      elements[0].should be_instance_of(Arbre::HTML::Div)
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
     end
 
-    # TODO: find children's children by class name
+    it "should return a grandchild element" do
+      html = arbre do
+        div :class => "some_class" do
+          div :class => "my_class"
+        end
+      end
+      elements = html.get_elements_by_class_name("my_class")
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
+    end
 
   end
 end

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"
       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(: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
 
@@ -169,17 +175,17 @@ describe Arbre::Element do
     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
       $, = "_"
-      collection.to_s.should == "hello world"
+      expect(collection.to_s).to eq("hello world")
     end
 
     it "should render collection when is not set the default separator" do
-      collection.to_s.should == "hello world"
+      expect(collection.to_s).to eq("hello world")
     end
 
   end
@@ -192,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
 
@@ -209,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
 
@@ -227,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
 
@@ -243,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
 
@@ -257,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

@@ -6,9 +6,9 @@ describe Arbre::HTML::ClassList do
 
     it "should build a new list from a string of classes" do
       list = Arbre::HTML::ClassList.build_from_string("first second")
-      list.size.should == 2
+      expect(list.size).to eq(2)
 
-      list.to_a.sort.should == %w{first second}
+      expect(list.to_a.sort).to eq(%w{first second})
     end
 
   end

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

@@ -9,52 +9,54 @@ describe Arbre::HTML::Tag, "Attributes" do
     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