arbre2 2.1.0

data/spec/arbre/unit/element_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+include Arbre
+
+describe Element do
+
+  let(:element) { Element.new }
+
+  ######
+  # Context
+
+    describe '#arbre_context' do
+
+      it "should be a new one if none was specified" do
+        context = Element.new.arbre_context
+        expect(context).to be_a(Context)
+      end
+
+      it "should the specified one if one was specified" do
+        context = Context.new
+        expect(Element.new(context).arbre_context).to be(context)
+      end
+
+    end
+
+    describe '#assigns' do
+
+      it "should take assigns from the context" do
+        expect(element.arbre_context).to receive(:assigns).and_return(:variable => :value)
+        expect(element.assigns).to eql(:variable => :value)
+      end
+
+    end
+
+    describe '#helpers' do
+
+      it "should take helpers from the context" do
+        helpers = double()
+        expect(element.arbre_context).to receive(:helpers).and_return(helpers)
+        expect(element.helpers).to be(helpers)
+      end
+
+    end
+
+  ######
+  # Hierarchy
+
+    describe '#remove!' do
+      it "should remove itself from its parent children" do
+        element.parent = Element.new
+        expect(element.parent.children).to receive(:remove).with(element)
+        element.remove!
+      end
+    end
+
+    describe '#children' do
+
+      specify { expect(element.children).to be_a(ChildElementCollection) }
+
+      it "should be empty by default" do
+        expect(element.children).to be_empty
+      end
+
+    end
+
+    describe '#has_children?' do
+      it "should be false if the element has no children" do
+        expect(element).not_to have_children
+      end
+      it "should be true if the element has children" do
+        element << Element.new
+        expect(element).to have_children
+      end
+    end
+
+    describe '#empty?' do
+      it "should be true if the element has no children" do
+        expect(element).to be_empty
+      end
+      it "should be false if the element has children" do
+        element << Element.new
+        expect(element).not_to be_empty
+      end
+    end
+
+    describe '#<<' do
+
+      it "should add a child element" do
+        child = Element.new
+        element << child
+
+        expect(element).to have(1).child
+        expect(element.children[0]).to be(child)
+      end
+
+    end
+
+    describe '#orphan?' do
+
+      it "should be true if the element has no parent" do
+        expect(element).to be_orphan
+      end
+
+      it "should be false if the element has a parent" do
+        element.parent = Element.new
+        expect(element).not_to be_orphan
+      end
+
+    end
+
+    describe '#ancestors' do
+
+      specify { expect(element.ancestors).to be_a(ElementCollection) }
+
+      it "should be empty if the element is an orphan" do
+        expect(element.ancestors).to be_empty
+      end
+
+      it "should list all ancestors from near to far" do
+        element.parent = Element.new
+        element.parent.parent = Element.new
+        element.parent.parent.parent = Element.new
+        expect(element.ancestors.to_a).to eql([ element.parent, element.parent.parent, element.parent.parent.parent ])
+      end
+
+    end
+
+    describe '#descendants' do
+
+      specify { expect(element.descendants).to be_a(ElementCollection) }
+
+      it "should be empty if the element has no children" do
+        expect(element.descendants).to be_empty
+      end
+
+      it "should list all descendants, where each element is appended after its parent" do
+        child1, child2, grandchild11, grandchild21, grandchild22 = 5.times.collect { Element.new }
+
+        element << child1 << child2
+        child1 << grandchild11
+        child2 << grandchild21 << grandchild22
+
+        expect(element.descendants).to eq([
+          child1, grandchild11,
+          child2, grandchild21, grandchild22
+        ])
+      end
+
+    end
+
+  ######
+  # Content
+
+    describe '#content' do
+
+      it "should be the string output by #children" do
+        expect(element.children).to receive(:to_s).and_return('(CONTENT)')
+        expect(element.content).to eql('(CONTENT)')
+      end
+
+    end
+
+    describe '#content=' do
+
+      it "should clear any children and add a text node with the given string" do
+        element << Element.new << Element.new
+        element.content = "(CONTENT)"
+
+        expect(element).to have(1).child
+        expect(element.children[0]).to be_a(TextNode)
+        expect(element.content).to eql('(CONTENT)')
+      end
+
+      it "should clear any children and add a given element" do
+        element << Element.new << Element.new
+        child = Element.new
+        element.content = child
+
+        expect(element).to have(1).child
+        expect(element.children[0]).to be(child)
+      end
+
+      it "should clear any children and add a given element collection" do
+        element << Element.new << Element.new
+
+        child1 = Element.new
+        child2 = Element.new
+        children = ElementCollection.new([child1, child2])
+        element.content = children
+        expect(element.children).to eq([child1, child2])
+      end
+
+    end
+
+  ######
+  # Set operations
+
+    describe '#+' do
+
+      it "should wrap itself in a collection and add the other element" do
+        element2 = Element.new
+
+        elements = element + element2
+        expect(elements).to be_a(ElementCollection)
+        expect(elements).to have(2).items
+        expect(elements[0]).to be(element)
+        expect(elements[1]).to be(element2)
+      end
+
+      it "should wrap itself in a collection and add the other elements" do
+        element2 = Element.new
+        element3 = Element.new
+
+        elements = element + [ element2, element3 ]
+        expect(elements).to be_a(ElementCollection)
+        expect(elements).to have(3).items
+        expect(elements[0]).to be(element)
+        expect(elements[1]).to be(element2)
+        expect(elements[2]).to be(element3)
+      end
+
+    end
+
+  ######
+  # Building & rendering
+
+    it "should call any block passed into the #build method with the element as an argument, but not instance-exec'd" do
+      receiver = nil
+      received_arg = nil
+      element.build! { |arg| receiver = self; received_arg = arg }
+      expect(received_arg).to be(element)
+      expect(receiver).to be(self)
+    end
+
+    it "should render its content by default" do
+      expect(element).to receive(:content).and_return('(CONTENT)')
+      expect(element.to_s).to eql('(CONTENT)')
+    end
+
+    it "should alias to_s as to_html" do
+      expect(element).to receive(:to_s).and_return('(CONTENT)')
+      expect(element.to_html).to eql('(CONTENT)')
+    end
+
+    it "should provide a terse description using #inspect" do
+      expect(element.inspect).to match(/#<Arbre::Element:0x[0-9a-f]+>/)
+    end
+
+    it "should have an indentation level of 0 by default" do
+      expect(element.indent_level).to eql(0)
+    end
+
+    it "should have an indentation level of 1 higher than its parent, if it has a parent" do
+      element.parent = Element.new
+      expect(element.parent).to receive(:indent_level).and_return(5)
+      expect(element.indent_level).to eql(6)
+    end
+
+  ######
+  # Helpers & assigns access
+
+    it "should pass any missing method to a helper method" do
+      result = double()
+      allow(element).to receive(:helpers).and_return(double(:helpers))
+      expect(element.helpers).to receive(:my_helper).and_return(result)
+      expect(element.my_helper).to be(result)
+      expect{element.my_other_helper}.to raise_error(NoMethodError)
+    end
+
+    it "should actually define the method when it is first found on the helpers" do
+      allow(element).to receive(:helpers).and_return(double(:helpers))
+      expect(element.helpers).to receive(:my_helper)
+      element.my_helper
+
+      expect(element.method(:my_helper)).not_to be_nil
+    end
+
+    it "should respond to any helper method" do
+      result = double()
+      allow(element).to receive(:helpers).and_return(double(:helpers))
+      allow(element.helpers).to receive(:my_helper).and_return(result)
+      expect(element).to respond_to(:my_helper)
+      expect(element).not_to respond_to(:my_other_helper)
+    end
+
+    it "should not try a helper method if no helpers were found" do
+      expect{ element.my_helper }.to raise_error(NoMethodError)
+    end
+
+    it "should offer any assigns as instance variables when the element is initialized with a context" do
+      assigns = { :my_assign => :value }
+      context = Context.new(assigns, double(:helpers))
+      element = Element.new(context)
+
+      expect(element.instance_variable_get("@my_assign")).to be(:value)
+    end
+
+end

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

@@ -0,0 +1,219 @@
+require 'spec_helper'
+include Arbre::Html
+
+describe Attributes do
+
+  let(:attributes) { Attributes.new }
+
+  describe 'creation' do
+
+    it "should be able to be created using Attributes.new without arguments" do
+      attributes = Attributes.new
+      expect(attributes).to eq({})
+    end
+
+    it "should be able to be created using Attributes.new with a hash of arguments" do
+      attributes = Attributes.new(:one => '1')
+      expect(attributes).to eq({ 'one' => '1' })
+    end
+
+    it "should be able to be created using Attributes[] just like Hash[]" do
+      expect(Hash).to receive(:[]).with(:one, '1').and_return(:one => '1')
+      attributes = Attributes[:one, '1']
+      expect(attributes).to eq({ 'one' => '1' })
+    end
+
+  end
+
+  describe 'attribute accessing' do
+
+    it "should support indifferent access" do
+      attributes['one'] = 1
+      attributes[:two] = 2
+      attributes[3] = 3
+
+      expect(attributes['one']).to eql('1')
+      expect(attributes[:one]).to eql('1')
+      expect(attributes['two']).to eql('2')
+      expect(attributes[:two]).to eql('2')
+      expect(attributes[3]).to eql('3')
+      expect(attributes['3']).to eql('3')
+      expect(attributes[:'3']).to eql('3')
+    end
+
+    it "should store an attribute as a string key and value" do
+      attributes['one'] = 1
+      attributes[:two] = 2
+      attributes[3] = 3
+
+      expect(attributes).to eq({ 'one' => '1', 'two' => '2', '3' => '3' })
+    end
+
+    it "should store a 'true' value as the name of the attribute itself" do
+      attributes[:checked] = true
+      expect(attributes).to eq({ 'checked' => 'checked' })
+    end
+
+    it "should store any value as its string version" do
+      attributes[:number] = 5
+      expect(attributes).to eq({ 'number' => '5' })
+    end
+
+    it "should remove an attribute that is set to false" do
+      attributes = Attributes.new('one' => '1')
+      attributes[:one] = false
+
+      expect(attributes).to be_empty
+    end
+
+    it "should remove an attribute that is set to nil" do
+      attributes = Attributes.new('one' => '1')
+      attributes[:one] = nil
+
+      expect(attributes).to be_empty
+    end
+
+  end
+
+  describe "class attribute" do
+
+    it "should return a ClassList when the class attribute is accessed" do
+      expect(attributes[:class]).to be_a(ClassList)
+      expect(attributes[:class]).to be_empty
+      expect(attributes['class']).to be_a(ClassList)
+      expect(attributes['class']).to be_empty
+    end
+
+    it "should wrap things into a class list when the attribute is set" do
+      attributes[:class] = 'one'
+      expect(attributes[:class].to_s).to eql('one')
+
+      attributes[:class] = 'one two'
+      expect(attributes[:class].to_s).to eql('one two')
+
+      attributes[:class] = %[one two]
+      expect(attributes[:class].to_s).to eql('one two')
+      attributes[:class] << 'three four'
+      expect(attributes[:class].to_s).to eql('one two three four')
+    end
+
+    it "should not set the attribute if a nil or empty array is passed" do
+      attributes[:class] = nil
+      expect(attributes).not_to have_key(:class)
+      attributes[:class] = []
+      expect(attributes).not_to have_key(:class)
+    end
+
+  end
+
+  describe '#remove' do
+
+    it "should remove the attribute with the given name" do
+      attributes = Attributes.new(:one => '1')
+      attributes.remove 'one'
+      expect(attributes).to be_empty
+    end
+
+    it "should remove the attribute with the given name (access indifferent)" do
+      attributes = Attributes.new(:one => '1')
+      attributes.remove :one
+      expect(attributes).to be_empty
+    end
+
+  end
+
+  describe '#update' do
+
+    it "should update the attributes hash with new attributes" do
+      attributes = Attributes.new(:one => '1', :two => '2')
+
+      attributes.update 'one' => '2', :three => '3'
+      expect(attributes).to eq('one' => '2', 'two' => '2', 'three' => '3')
+    end
+
+    it "should be able to remove attributes by updating them to nil" do
+      attributes = Attributes.new(:one => '1', :two => '2')
+
+      attributes.update 'one' => '2', :two => nil, :three => '3'
+      expect(attributes).to eq('one' => '2', 'three' => '3')
+    end
+
+  end
+
+  describe 'equality' do
+
+    it "should be equal to any other hash-like construct with the same values" do
+      expect(Attributes.new(:one => '1')).to eq(Attributes.new(:one => '1'))
+      expect(Attributes.new(:one => '1')).to eq('one' => '1')
+    end
+
+    it "should be eql? only to other attribute hashes with the same values" do
+      expect(Attributes.new(:one => '1')).to eql(Attributes.new(:one => '1'))
+      expect(Attributes.new(:one => '1')).not_to eql('one' => '1')
+    end
+
+  end
+
+  describe 'enumeration' do
+
+    specify { expect(Attributes).to include(Enumerable) }
+
+    it "should enumerate through all attributes using #each" do
+      attributes = Attributes.new(:one => '1', :two => '2')
+
+      result = []
+      attributes.each { |k, v| result << [ k, v] }
+      expect(result).to eql([ ['one', '1'], ['two', '2'] ])
+    end
+
+  end
+
+  describe '#length, #size and #count' do
+
+    it "should all report the number of the attributes" do
+      expect(Attributes.new(:one => '2').length).to eql(1)
+      expect(Attributes.new(:one => '2').size).to eql(1)
+      expect(Attributes.new(:one => '2').count).to eql(1)
+    end
+
+  end
+
+  describe '#empty?' do
+
+    it "should be true if the attribute hash is empty" do
+      expect(Attributes.new).to be_empty
+    end
+
+    it "should be false if the attributes array contains elements" do
+      expect(Attributes.new(:one => '2')).not_to be_empty
+    end
+
+  end
+
+  describe '#to_s' do
+
+    it "should create a format suitable for in HTML tags" do
+      attributes = Attributes.new(:href => 'http://www.google.com', :target => :_blank)
+      expect(attributes.to_s).to eql('href="http://www.google.com" target="_blank"')
+    end
+
+    it "should escape any HTML entities" do
+      attributes = Attributes.new(:dangerous => '<>"')
+      expect(attributes.to_s).to eql('dangerous="&lt;&gt;&quot;"')
+    end
+
+    it "should be HTML safe" do
+      attributes = Attributes.new(:dangerous => '<>"')
+      expect(attributes.to_s).to be_html_safe
+    end
+
+    it "should not render an empty class attribute" do
+      attributes = Attributes.new(:class => 'test')
+      expect(attributes.to_s).to eql('class="test"')
+      attributes[:class] = nil
+      expect(attributes.to_s).to eql('')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,109 @@
+require 'spec_helper'
+include Arbre::Html
+
+describe ClassList do
+
+  describe "initializer" do
+    it "should be able to be initialized without arguments" do
+      list = ClassList.new
+      expect(list).to be_empty
+    end
+
+    it "should be able to be initialized with an array of classes" do
+      list = ClassList.new(['one', 'two'])
+      expect(list.to_a).to eql(['one', 'two'])
+    end
+
+    it "should be able to be initialized with a string containing one class" do
+      list = ClassList.new('one')
+      expect(list.to_a).to eql(['one'])
+    end
+
+    it "should be able to be initialized with a string containing multiple classes separated by a space" do
+      list = ClassList.new('one two')
+      expect(list.to_a).to eql(['one', 'two'])
+    end
+  end
+
+  describe '#classes' do
+    it "should be an alias to itself" do
+      list = ClassList.new('one two')
+      expect(list.classes).to be(list)
+    end
+  end
+
+  describe "#add" do
+
+    it "should add one class" do
+      list = ClassList.new('one')
+
+      list << 'two' << 'three'
+      list.add 'four'
+
+      expect(list.to_a).to match_array(%w[one two three four])
+    end
+
+    it "should add multiple classes in one string" do
+      list = ClassList.new('one')
+      list << 'two three'
+      list.add 'four five'
+      expect(list.to_a).to match_array(%w[one two three four five])
+    end
+
+    it "should add a class using a symbol" do
+      list = ClassList.new('one')
+      list << :two
+      expect(list.to_a).to match_array(%w[one two])
+    end
+
+  end
+
+  describe '#concat' do
+
+    it "should append all classes in the given array" do
+      list = ClassList.new('one two')
+      list.concat [ 'three', 'four five' ]
+      expect(list.to_a).to match_array(%w[one two three four five])
+    end
+
+  end
+
+  describe "#remove" do
+
+    it "should remove one class" do
+      list = ClassList.new('one two')
+      list.remove 'one'
+      expect(list.to_a).to eql(['two'])
+    end
+
+    it "should add multiple classes in one string" do
+      list = ClassList.new('one two three')
+      list.remove 'one three'
+      expect(list.to_a).to eql(['two'])
+    end
+
+  end
+
+  describe "equality" do
+
+    it "should be equal to another ClassList with the same classes" do
+      expect(ClassList.new('one two')).to eq(ClassList.new('two one'))
+    end
+
+    it "should be equal to an array with the same classes" do
+      expect(ClassList.new('one two')).to eq(['two', 'one'])
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "should output html-ready content" do
+      list = ClassList.new('one two three')
+      list << 'four'
+      expect(list.to_s).to eql('one two three four')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+include Arbre
+
+describe Html::Comment do
+
+  it "should render an empty comment" do
+    expect(arbre.comment.to_s).to eql('<!-- -->')
+  end
+
+  it "should render a single-line comment" do
+    comment = arbre.comment("This is a comment")
+    expect(comment.to_s).to eql('<!-- This is a comment -->')
+  end
+
+  it "should render a multi-line comment" do
+    comment = arbre.comment("This is a comment\ncontaining two lines")
+    expect(arbre.to_s).to eql(<<-HTML.gsub(/^ {6}/, '').chomp)
+      <!--
+        This is a comment
+        containing two lines
+      -->
+    HTML
+  end
+
+  it "should use proper indentation" do
+    arbre do
+      div do
+        comment "This is an indented comment\ncontaining two lines"
+      end
+    end
+
+    expect(arbre.to_s).to eql(<<-HTML.gsub(/^ {6}/, '').chomp)
+      <div>
+        <!--
+          This is an indented comment
+          containing two lines
+        -->
+      </div>
+    HTML
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+include Arbre
+include Arbre::Html
+
+describe Querying do
+
+  describe '#find and #find_first' do
+    it "should use a Query object" do
+      element = Element.new
+      fieldset = Element.new
+
+      query = double()
+      allow(Query).to receive(:new).with(element).and_return(query)
+      allow(query).to receive(:execute).with('fieldset#username').and_return([fieldset])
+      expect(element.find('fieldset#username')).to eql([fieldset])
+      expect(element.find_first('fieldset#username')).to be(fieldset)
+    end
+
+    it "should fail gracefully" do
+      element = Element.new
+      query = double()
+
+      allow(Query).to receive(:new).with(element).and_return(query)
+      allow(query).to receive(:execute).with('fieldset#username').and_return([])
+      expect(element.find('fieldset#username')).to eql([])
+      expect(element.find_first('fieldset#username')).to be_nil
+    end
+  end
+
+  # Other methods are integration-specced.
+
+end