arbre 1.0.0.rc4 → 1.2.1

data/spec/arbre/integration/html_spec.rb

@@ -6,184 +6,192 @@ describe Arbre do
   let(:assigns){ {} }
 
   it "should render a single element" do
-    arbre {
+    expect(arbre {
       span "Hello World"
-    }.to_s.should == "<span>Hello World</span>\n"
+    }.to_s).to eq("<span>Hello World</span>\n")
   end
 
   it "should render a child element" do
-    arbre {
+    expect(arbre {
       span do
         span "Hello World"
       end
-    }.to_s.should == <<-HTML
-<span>
-  <span>Hello World</span>
-</span>
-HTML
+    }.to_s).to eq <<~HTML
+      <span>
+        <span>Hello World</span>
+      </span>
+    HTML
   end
 
   it "should render an unordered list" do
-    arbre {
+    expect(arbre {
       ul do
         li "First"
         li "Second"
         li "Third"
       end
-    }.to_s.should == <<-HTML
-<ul>
-  <li>First</li>
-  <li>Second</li>
-  <li>Third</li>
-</ul>
-HTML
+    }.to_s).to eq <<~HTML
+      <ul>
+        <li>First</li>
+        <li>Second</li>
+        <li>Third</li>
+      </ul>
+    HTML
   end
 
-   it "should allow local variables inside the tags" do
-     arbre {
-       first = "First"
-       second = "Second"
-       ul do
-         li first
-         li second
-       end
-     }.to_s.should == <<-HTML
-<ul>
-  <li>First</li>
-  <li>Second</li>
-</ul>
-HTML
-   end
-
+  it "should allow local variables inside the tags" do
+    expect(arbre {
+      first = "First"
+      second = "Second"
+      ul do
+        li first
+        li second
+      end
+    }.to_s).to eq <<~HTML
+      <ul>
+        <li>First</li>
+        <li>Second</li>
+      </ul>
+    HTML
+  end
 
   it "should add children and nested" do
-    arbre {
+    expect(arbre {
       div do
         ul
         li do
           li
         end
       end
-    }.to_s.should == <<-HTML
-<div>
-  <ul></ul>
-  <li>
-    <li></li>
-  </li>
-</div>
-HTML
+    }.to_s).to eq <<~HTML
+      <div>
+        <ul></ul>
+        <li>
+          <li></li>
+        </li>
+      </div>
+    HTML
   end
 
 
   it "should pass the element in to the block if asked for" do
-    arbre {
+    expect(arbre {
       div do |d|
         d.ul do
           li
         end
       end
-    }.to_s.should == <<-HTML
-<div>
-  <ul>
-    <li></li>
-  </ul>
-</div>
-HTML
+    }.to_s).to eq <<~HTML
+      <div>
+        <ul>
+          <li></li>
+        </ul>
+      </div>
+    HTML
   end
 
 
   it "should move content tags between parents" do
-    arbre {
+    expect(arbre {
       div do
         span(ul(li))
       end
-    }.to_s.should == <<-HTML
-<div>
-  <span>
-    <ul>
-      <li></li>
-    </ul>
-  </span>
-</div>
-HTML
+    }.to_s).to eq <<~HTML
+      <div>
+        <span>
+          <ul>
+            <li></li>
+          </ul>
+        </span>
+      </div>
+    HTML
   end
 
   it "should add content to the parent if the element is passed into block" do
-    arbre {
+    expect(arbre {
       div do |d|
         d.id = "my-tag"
         ul do
           li
         end
       end
-    }.to_s.should == <<-HTML
-<div id="my-tag">
-  <ul>
-    <li></li>
-  </ul>
-</div>
-HTML
+    }.to_s).to eq <<~HTML
+      <div id="my-tag">
+        <ul>
+          <li></li>
+        </ul>
+      </div>
+    HTML
   end
 
   it "should have the parent set on it" do
+    list, item = nil
     arbre {
-      item = nil
       list = ul do
         li "Hello"
         item = li "World"
       end
-      item.parent.should == list
     }
+    expect(item.parent).to eq list
   end
 
   it "should set a string content return value with no children" do
-    arbre {
+    expect(arbre {
       li do
         "Hello World"
       end
-    }.to_s.should == <<-HTML
-<li>Hello World</li>
-HTML
+    }.to_s).to eq <<~HTML
+      <li>Hello World</li>
+    HTML
   end
 
   it "should turn string return values into text nodes" do
+    node = nil
     arbre {
       list = li do
         "Hello World"
       end
       node = list.children.first
-      node.class.should == Arbre::HTML::TextNode
     }
+    expect(node).to be_a Arbre::HTML::TextNode
   end
 
   it "should not render blank arrays" do
-    arbre {
+    expect(arbre {
       tbody do
         []
       end
-    }.to_s.should == <<-HTML
-<tbody></tbody>
-HTML
+    }.to_s).to eq <<~HTML
+      <tbody></tbody>
+    HTML
   end
 
   describe "self-closing nodes" do
 
     it "should not self-close script tags" do
-      arbre {
-        script :type => 'text/javascript'
-      }.to_s.should == "<script type=\"text/javascript\"></script>\n"
+      expect(arbre {
+        script type: 'text/javascript'
+      }.to_s).to eq("<script type=\"text/javascript\"></script>\n")
     end
 
     it "should self-close meta tags" do
-      arbre {
-        meta :content => "text/html; charset=utf-8"
-      }.to_s.should == "<meta content=\"text/html; charset=utf-8\"/>\n"
+      expect(arbre {
+        meta content: "text/html; charset=utf-8"
+      }.to_s).to eq("<meta content=\"text/html; charset=utf-8\"/>\n")
     end
 
     it "should self-close link tags" do
-      arbre {
-        link :rel => "stylesheet"
-      }.to_s.should == "<link rel=\"stylesheet\"/>\n"
+      expect(arbre {
+        link rel: "stylesheet"
+      }.to_s).to eq("<link rel=\"stylesheet\"/>\n")
+    end
+
+    Arbre::HTML::Tag::SELF_CLOSING_ELEMENTS.each do |tag|
+      it "should self-close #{tag} tags" do
+        expect(arbre {
+          send(tag)
+        }.to_s).to eq("<#{tag}/>\n")
+      end
     end
 
   end
@@ -191,49 +199,49 @@ HTML
   describe "html safe" do
 
     it "should escape the contents" do
-      arbre {
+      expect(arbre {
         span("<br />")
-      }.to_s.should == <<-HTML
-<span>&lt;br /&gt;</span>
-HTML
+      }.to_s).to eq <<~HTML
+        <span>&lt;br /&gt;</span>
+      HTML
     end
 
     it "should return html safe strings" do
-      arbre {
+      expect(arbre {
         span("<br />")
-      }.to_s.should be_html_safe
+      }.to_s).to be_html_safe
     end
 
     it "should not escape html passed in" do
-      arbre {
+      expect(arbre {
         span(span("<br />"))
-      }.to_s.should == <<-HTML
-<span>
-  <span>&lt;br /&gt;</span>
-</span>
-HTML
+      }.to_s).to eq <<~HTML
+        <span>
+          <span>&lt;br /&gt;</span>
+        </span>
+      HTML
     end
 
     it "should escape string contents when passed in block" do
-      arbre {
+      expect(arbre {
         span {
           span {
             "<br />"
           }
         }
-      }.to_s.should == <<-HTML
-<span>
-  <span>&lt;br /&gt;</span>
-</span>
-HTML
+      }.to_s).to eq <<~HTML
+        <span>
+          <span>&lt;br /&gt;</span>
+        </span>
+      HTML
     end
 
     it "should escape the contents of attributes" do
-      arbre {
-        span(:class => "<br />")
-      }.to_s.should == <<-HTML
-<span class="&lt;br /&gt;"></span>
-HTML
+      expect(arbre {
+        span(class: "<br />")
+      }.to_s).to eq <<~HTML
+        <span class="&lt;br /&gt;"></span>
+      HTML
     end
 
   end

data/spec/arbre/unit/component_spec.rb

@@ -20,25 +20,25 @@ 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
-<div class="mock_component">
-  <h2>Hello World</h2>
-</div>
-HTML
+    }.to_s).to eq <<~HTML
+      <div class="mock_component">
+        <h2>Hello World</h2>
+      </div>
+      HTML
   end
 
 end

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,46 +56,61 @@ 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
       html = arbre do
-        div :class => "some_class"
-        div :class => "my_class"
+        div class: "some_class"
+        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
       html = arbre do
-        div :class => "some_class"
-        div :class => "my_class"
-        div :class => "my_class"
+        div class: "some_class"
+        div class: "my_class"
+        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
       html = arbre do
-        div :class => "some_class this_class"
-        div :class => "some_class"
-        div :class => "other_class"
+        div class: "some_class this_class"
+        div class: "some_class"
+        div class: "other_class"
 
       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