arbo 1.2.0

data/spec/arbo/integration/html_spec.rb

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

data/spec/arbo/unit/component_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+# A mock subclass to play with
+class MockComponent < Arbo::Component
+
+  builder_method :mock_component
+
+  def build
+    h2 "Hello World"
+  end
+
+end
+
+describe Arbo::Component do
+
+  let(:assigns) { {} }
+  let(:helpers) { nil }
+
+  let(:component_class){ MockComponent }
+  let(:component){ component_class.new }
+
+  it "should be a subclass of an html div" do
+    expect(Arbo::Component.ancestors).to include(Arbo::HTML::Div)
+  end
+
+  it "should render to a div, even as a subclass" do
+    expect(component.tag_name).to eq('div')
+  end
+
+  it "should add a class by default" do
+    expect(component.class_list).to include("mock_component")
+  end
+
+  it "should render (to_s) the object using the builder method name" do
+    comp = expect(arbo {
+      mock_component
+    }.to_s).to eq <<-HTML
+<div class="mock_component">
+  <h2>Hello World</h2>
+</div>
+HTML
+  end
+
+  it "should render (render_in) the object using the builder method name" do
+    context = arbo { mock_component }
+    output_buffer = context.render_in(context)
+
+    expect(output_buffer).to eq <<-HTML
+<div class="mock_component">
+  <h2>Hello World</h2>
+</div>
+HTML
+  end
+end

data/spec/arbo/unit/context_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Arbo::Context do
+
+  let(:context) do
+    Arbo::Context.new do
+      h1 "札幌市北区" # Add some HTML to the context
+    end
+  end
+
+  it "should not increment the indent_level" do
+    expect(context.indent_level).to eq(-1)
+  end
+
+  it "should return a bytesize" do
+    expect(context.bytesize).to eq(25)
+  end
+
+  it "should return a length" do
+    expect(context.length).to eq(25)
+  end
+
+  it "should delegate missing methods to the html string" do
+    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
+    expect(context).to receive(:render_in).once.and_return("<h1>札幌市北区</h1>")
+    expect(context.index('<')).to eq(0)
+    expect(context.index('<')).to eq(0)
+  end
+
+end

data/spec/arbo/unit/element_finder_methods_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Arbo::Element, "Finder Methods" do
+  let(:assigns){ {} }
+  let(:helpers){ {} }
+
+  describe "finding elements by tag name" do
+
+    it "should return 0 when no elements exist" do
+      expect(arbo {
+        div
+      }.get_elements_by_tag_name("li").size).to eq(0)
+    end
+
+    it "should return a child element" do
+      html = arbo do
+        ul
+        li
+        ul
+      end
+      elements = html.get_elements_by_tag_name("li")
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Li)
+    end
+
+    it "should return multple child elements" do
+      html = arbo do
+        ul
+        li
+        ul
+        li
+      end
+      elements = html.get_elements_by_tag_name("li")
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Li)
+      expect(elements[1]).to be_instance_of(Arbo::HTML::Li)
+    end
+
+    it "should return children's child elements" do
+      html = arbo do
+        ul
+        li do
+          li
+        end
+      end
+      elements = html.get_elements_by_tag_name("li")
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Li)
+      expect(elements[1]).to be_instance_of(Arbo::HTML::Li)
+      expect(elements[1].parent).to eq(elements[0])
+    end
+  end
+
+  #TODO: describe "finding an element by id"
+
+  describe "finding an element by a class name" do
+
+    it "should return 0 when no elements exist" do
+      expect(arbo {
+        div
+      }.get_elements_by_class_name("my_class").size).to eq(0)
+    end
+
+    it "should allow text nodes on tree" do
+      expect(arbo {
+        text_node "text"
+      }.get_elements_by_class_name("my_class").size).to eq(0)
+    end
+
+    it "should return a child element" do
+      html = arbo do
+        div class: "some_class"
+        div class: "my_class"
+      end
+      elements = html.get_elements_by_class_name("my_class")
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Div)
+    end
+
+    it "should return multple child elements" do
+      html = arbo do
+        div class: "some_class"
+        div class: "my_class"
+        div class: "my_class"
+      end
+      elements = html.get_elements_by_class_name("my_class")
+      expect(elements.size).to eq(2)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Div)
+      expect(elements[1]).to be_instance_of(Arbo::HTML::Div)
+    end
+
+    it "should return elements that match one of several classes" do
+      html = arbo do
+        div class: "some_class this_class"
+        div class: "some_class"
+        div class: "other_class"
+
+      end
+      elements = html.get_elements_by_class_name("this_class")
+      expect(elements.size).to eq(1)
+      expect(elements[0]).to be_instance_of(Arbo::HTML::Div)
+    end
+
+    it "should return a grandchild element" do
+      html = arbo 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(Arbo::HTML::Div)
+    end
+
+  end
+end