arbre 0.0.1 → 1.0.0.rc1

data/lib/arbre/rails/rendering.rb

@@ -0,0 +1,17 @@
+module Arbre
+  module Rails
+    module Rendering
+
+      def render(*args)
+        rendered = helpers.render(*args)
+        case rendered
+        when Arbre::Context
+          current_arbre_element.add_child rendered
+        else
+          text_node rendered
+        end
+      end
+
+    end
+  end
+end

data/lib/arbre/rails/template_handler.rb

@@ -0,0 +1,15 @@
+module Arbre
+  module Rails
+
+    class TemplateHandler
+
+      def call(template)
+        "Arbre::Context.new(assigns, self){ #{template.source} }"
+      end
+
+    end
+
+  end
+end
+
+ActionView::Template.register_template_handler :arb, Arbre::Rails::TemplateHandler.new

data/lib/arbre/version.rb

@@ -1,3 +1,3 @@
 module Arbre
-  VERSION = "0.0.1"
+  VERSION = "1.0.0.rc1"
 end

data/spec/arbre/integration/html_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe Arbre do
+
+  let(:helpers){ nil }
+  let(:assigns){ {} }
+
+  it "should render a single element" do
+    arbre {
+      span "Hello World"
+    }.to_s.should == "<span>Hello World</span>\n"
+  end
+
+  it "should render a child element" do
+    arbre {
+      span do
+        span "Hello World"
+      end
+    }.to_s.should == <<-HTML
+<span>
+  <span>Hello World</span>
+</span>
+HTML
+  end
+
+  it "should render an unordered list" do
+    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
+  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 add children and nested" do
+    arbre {
+      div do
+        ul
+        li do
+          li
+        end
+      end
+    }.to_s.should == <<-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 {
+      div do |d|
+        d.ul do
+          li
+        end
+      end
+    }.to_s.should == <<-HTML
+<div>
+  <ul>
+    <li></li>
+  </ul>
+</div>
+HTML
+  end
+
+
+  it "should move content tags between parents" do
+    arbre {
+      div do
+        span(ul(li))
+      end
+    }.to_s.should == <<-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 {
+      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
+  end
+
+  it "should have the parent set on it" do
+    arbre {
+      item = nil
+      list = ul do
+        li "Hello"
+        item = li "World"
+      end
+      item.parent.should == list
+    }
+  end
+
+  it "should set a string content return value with no children" do
+    arbre {
+      li do
+        "Hello World"
+      end
+    }.to_s.should == <<-HTML
+<li>Hello World</li>
+HTML
+  end
+
+  it "should turn string return values into text nodes" do
+    arbre {
+      list = li do
+        "Hello World"
+      end
+      node = list.children.first
+      node.class.should == Arbre::HTML::TextNode
+    }
+  end
+
+  it "should not render blank arrays" do
+    arbre {
+      tbody do
+        []
+      end
+    }.to_s.should == <<-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"
+    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"
+    end
+
+    it "should self-close link tags" do
+      arbre {
+        link :rel => "stylesheet"
+      }.to_s.should == "<link rel=\"stylesheet\"/>\n"
+    end
+
+  end
+
+  describe "html safe" do
+
+    it "should escape the contents" do
+      arbre {
+        span("<br />")
+      }.to_s.should == <<-HTML
+<span>&lt;br /&gt;</span>
+HTML
+    end
+
+    it "should return html safe strings" do
+      arbre {
+        span("<br />")
+      }.to_s.should be_html_safe
+    end
+
+    it "should not escape html passed in" do
+      arbre {
+        span(span("<br />"))
+      }.to_s.should == <<-HTML
+<span>
+  <span>&lt;br /&gt;</span>
+</span>
+HTML
+    end
+
+    it "should escape string contents when passed in block" do
+      arbre {
+        span {
+          span {
+            "<br />"
+          }
+        }
+      }.to_s.should == <<-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
+    end
+
+  end
+
+end

data/spec/arbre/unit/component.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+# A mock subclass to play with
+class MockComponent < Arbre::Component; end
+
+describe Arbre::Component do
+
+  let(:component_class){ MockComponent }
+  let(:component){ component_class.new }
+
+  it "should be a subclass of an html div" do
+    Arbre::Component.ancestors.should include(Arbre::HTML::Div)
+  end
+
+  it "should render to a div, even as a subclass" do
+    component.tag_name.should == 'div'
+  end
+
+  it "should add a class by default" do
+    component.class_list.should include("mock_component")
+  end
+
+end

data/spec/arbre/unit/context_spec.rb

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

data/spec/arbre/unit/element_finder_methods_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Arbre::Element, "Finder Methods" do
+  let(:assigns){ {} }
+  let(:helpers){ {} }
+
+  describe "finding elements by tag name" do
+
+    it "should return 0 when no elements exist" do
+      arbre {
+        div
+      }.get_elements_by_tag_name("li").size.should == 0
+    end
+
+    it "should return a child element" do
+      html = arbre do
+        ul
+        li
+        ul
+      end
+      elements = html.get_elements_by_tag_name("li")
+      elements.size.should == 1
+      elements[0].should be_instance_of(Arbre::HTML::Li)
+    end
+
+    it "should return multple child elements" do
+      html = arbre do
+        ul
+        li
+        ul
+        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)
+    end
+
+    it "should return children's child elements" do
+      html = arbre do
+        ul
+        li do
+          li
+        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]
+    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
+      arbre {
+        div
+      }.get_elements_by_class_name("my_class").size.should == 0
+    end
+
+    it "should return a child element" do
+      html = arbre do
+        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)
+    end
+
+    it "should return multple child elements" do
+      html = arbre do
+        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)
+    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"
+
+      end
+      elements = html.get_elements_by_class_name("this_class")
+      elements.size.should == 1
+      elements[0].should be_instance_of(Arbre::HTML::Div)
+    end
+
+    # TODO: find children's children by class name
+
+  end
+end

data/spec/arbre/unit/element_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe Arbre::Element do
+
+  let(:element){ Arbre::Element.new }
+
+  context "when initialized" do
+
+    it "should have no children" do
+      element.children.should be_empty
+    end
+
+    it "should have no parent" do
+      element.parent.should be_nil
+    end
+
+    it "should respond to the HTML builder methods" do
+      element.should 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"
+    end
+
+    it "should have an empty hash with no local assigns" do
+      element.assigns.should == {}
+    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){ 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"
+    end
+
+    it "should raise a NoMethodError if not found" do
+      lambda {
+        element.a_method_that_doesnt_exist
+      }.should raise_error(NoMethodError)
+    end
+
+  end
+
+  describe "passing in assigns" do
+    let(:post){ stub }
+    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
+    end
+
+  end
+
+  describe "adding a child" do
+
+    let(:child){ Arbre::Element.new }
+
+    before do
+      element.add_child child
+    end
+
+    it "should add the child to the parent" do
+      element.children.first.should == child
+    end
+
+    it "should set the parent of the child" do
+      child.parent.should == element
+    end
+
+    context "when the child is nil" do
+
+      let(:child){ nil }
+
+      it "should not add the child" do
+        element.children.should be_empty
+      end
+
+    end
+
+    context "when the child is a string" 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"
+      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
+        element.children.size.should == 1
+      end
+
+      it "should add the string as a child" do
+        element.children.first.to_s.should == "Goodbye"
+      end
+
+      it "should html escape the string" do
+        string = "Goodbye <br />"
+        element.content = string
+        element.content.to_s.should == "Goodbye &lt;br /&gt;"
+      end
+    end
+
+    context "when an element" do
+      let(:content_element){ Arbre::Element.new }
+
+      before do
+        element.content = content_element
+      end
+
+      it "should set the content tag" do
+        element.children.first.should == content_element
+      end
+
+      it "should set the tags parent" do
+        content_element.parent.should == element
+      end
+    end
+
+    context "when an array of tags" do
+      let(:first){ Arbre::Element.new }
+      let(:second){ Arbre::Element.new }
+
+      before do
+        element.content = [first, second]
+      end
+
+      it "should set the content tag" do
+        element.children.first.should == first
+      end
+
+      it "should set the tags parent" do
+        element.children.first.parent.should == element
+      end
+    end
+
+  end
+
+  describe "rendering to html" do
+
+    it "should render the children collection" do
+      element.children.should_receive(:to_s).and_return("content")
+      element.to_s.should == "content"
+    end
+
+  end
+
+  describe "adding elements together" do
+
+    context "when both elements are tags" do
+      let(:first){ Arbre::Element.new }
+      let(:second){ Arbre::Element.new }
+      let(:collection){ first + second }
+
+      it "should return an instance of Collection" do
+        collection.should 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
+      end
+    end
+
+    context "when the left is a collection and the right is a tag" do
+      let(:first){ Arbre::Element.new }
+      let(:second){ Arbre::Element.new }
+      let(:third){ Arbre::Element.new }
+      let(:collection){ Arbre::ElementCollection.new([first, second]) + third}
+
+      it "should return an instance of Collection" do
+        collection.should 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
+      end
+    end
+
+    context "when the right is a collection and the left is a tag" do
+      let(:first){ Arbre::Element.new }
+      let(:second){ Arbre::Element.new }
+      let(:third){ Arbre::Element.new }
+      let(:collection){ first + Arbre::ElementCollection.new([second,third]) }
+
+      it "should return an instance of Collection" do
+        collection.should 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
+      end
+    end
+
+    context "when the left is a tag and the right is a string" do
+      let(:element){ Arbre::Element.new }
+      let(:collection){ element + "Hello World"}
+
+      it "should return an instance of Collection" do
+        collection.should 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)
+      end
+    end
+
+    context "when the left is a string and the right is a tag" do
+      let(:collection){ "hello World" + Arbre::Element.new}
+
+      it "should return a string" do
+        collection.strip.chomp.should == "hello World"
+      end
+    end
+  end
+
+end