arbre2 2.1.0

data/spec/arbre/unit/context_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+include Arbre
+
+describe Context do
+
+  ######
+  # Attributes
+
+    it "should not allow a parent to be set" do
+      expect{ Context.new.parent = Element.new }.to raise_error(NotImplementedError)
+    end
+
+    it "should always have an indentation level of -1" do
+      context = Context.new
+      expect(context.indent_level).to eql(-1)
+    end
+
+    describe '#assigns' do
+      it "should be its own assigns" do
+        expect(Context.new.assigns).to eql({})
+        expect(Context.new(:one => :two).assigns).to eql(:one => :two)
+      end
+      it "should have symbolic keys only" do
+        expect(Context.new('one' => :two).assigns).to eql(:one => :two)
+      end
+    end
+
+    describe '#helpers' do
+      it "should be its own helpers" do
+        expect(Context.new.helpers).to eql(nil)
+        helpers = double()
+        expect(Context.new({}, helpers).helpers).to be(helpers)
+      end
+    end
+
+  ######
+  # Element & flow stack
+
+    let(:context) { Context.new }
+
+    it "should have the context itself as the current element" do
+      expect(context.current_element).to be(context)
+    end
+
+    it "should have :append as the current flow" do
+      expect(context.current_flow).to be(:append)
+    end
+
+    it "should change the current element and flow temporarily using #with_current" do
+      element1 = Element.new
+      element2 = Element.new
+
+      expect(context.current_element).to be(context)
+      expect(context.current_flow).to be(:append)
+      context.with_current element: element1, flow: :prepend do
+        expect(context.current_element).to be(element1)
+        expect(context.current_flow).to be(:prepend)
+        context.with_current element: element2, flow: [ :after, element1 ] do
+          expect(context.current_element).to be(element2)
+          expect(context.current_flow).to eql([ :after, element1 ])
+        end
+        expect(context.current_element).to be(element1)
+        expect(context.current_flow).to be(:prepend)
+      end
+      expect(context.current_element).to be(context)
+      expect(context.current_flow).to be(:append)
+    end
+
+    it "should replace the original element if an error occurs" do
+      begin
+        context.with_current(element: Element.new, flow: :prepend) { raise 'test' }
+      rescue
+        expect(context.current_element).to be(context)
+        expect(context.current_flow).to be(:append)
+      end
+    end
+
+    describe '#replace_current_flow' do
+      # Note - this method is for internal purposes only.
+
+      it "should replace the current flow" do
+        element = Element.new
+
+        expect(context.current_flow).to be(:append)
+        context.with_current element: element, flow: :prepend do
+          expect(context.current_flow).to be(:prepend)
+          context.replace_current_flow [ :after, element ]
+          expect(context.current_flow).to eql([:after, element])
+        end
+        expect(context.current_flow).to be(:append)
+      end
+
+    end
+
+end

data/spec/arbre/unit/element/building_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+include Arbre
+
+describe Element::Building do
+
+  # Note - builder methods are specced in integration/element_building_spec.rb.
+
+  let(:element_class) { Class.new(Element) }
+  let(:element) { element_class.new(arbre) }
+
+  ######
+  # Build & insert element
+
+    describe '#build' do
+
+      it "should create an element from the given class and build it using the given arguments and block" do
+        block = proc {}
+
+        expect(element_class).to receive(:new).with(arbre).and_return(element)
+        expect(element).to receive(:build!).with(:arg1, :arg2) do |&blk|
+          expect(blk).to be(block)
+          expect(element.current_element).to be(element)
+        end
+
+        result = arbre.build(element_class, :arg1, :arg2, &block)
+        expect(result).to be(element)
+      end
+
+    end
+
+    describe '#insert' do
+
+      it "should create an element from the given class, insert it, and build it using the given arguments and block" do
+        block = proc {}
+        parent = Element.new
+
+        expect(element_class).to receive(:new).with(arbre).and_return(element)
+        expect(element).to receive(:build!).with(:arg1, :arg2) do |&blk|
+          # Note: the parent should be known when the build method is called!
+          expect(element.parent).to be(parent)
+          expect(blk).to be(block)
+          expect(element.current_element).to be(element)
+        end
+
+        result = arbre.within(parent) { arbre.insert(element_class, :arg1, :arg2, &block) }
+        expect(result).to be(element)
+        expect(parent.children).to eq([element])
+      end
+
+    end
+
+  ######
+  # Within
+
+    describe '#append_within' do
+      it "should call within_element on to arbre_context" do
+        block = proc{}
+        element = Element.new
+        expect(arbre).to receive(:with_current).with(element: element, flow: :append) do |&blk|
+          expect(blk).to be(block)
+        end
+
+        Element.new(arbre).instance_exec do
+          append_within element, &block
+        end
+      end
+
+      it "should resolve any string into an element using 'find'" do
+        block = proc{}
+        element = Element.new
+        expect(arbre).to receive(:with_current).with(element: element, flow: :append)
+
+        context_element = Element.new(arbre)
+        expect(context_element).to receive(:find).with('fieldset#username').and_return([element])
+        context_element.instance_exec do
+          within 'fieldset#username', &block
+        end
+      end
+    end
+
+    describe '#prepend_within' do
+      it "should call within and with_flow(:prepend) on the context" do
+        block = proc {}
+        element = Element.new
+        expect(arbre).to receive(:with_current).with(element: element, flow: :prepend) do |&blk|
+          expect(blk).to be(block)
+        end
+
+        Element.new(arbre).instance_exec do
+          prepend_within element, &block
+        end
+      end
+
+      it "should resolve any string into an element using 'find'" do
+        block = proc{}
+        element = Element.new
+        expect(arbre).to receive(:with_current).with(element: element, flow: :prepend)
+
+        context_element = Element.new(arbre)
+        expect(context_element).to receive(:find).with('fieldset#username').and_return([element])
+        context_element.instance_exec do
+          prepend_within 'fieldset#username', &block
+        end
+      end
+    end
+
+  ######
+  # Append / prepend
+
+    describe '#append' do
+
+      it "should insert an element of the given class using the :append flow" do
+        block = proc {}
+        expect(arbre).to receive(:insert).with(element_class, :one, :two) do |&blk|
+          expect(blk).to be(block)
+          expect(arbre.current_flow).to be(:append)
+        end
+
+        arbre.append element_class, :one, :two, &block
+      end
+
+      it "should run the given block :append flow if no block is given" do
+        block = proc do
+          expect(arbre.current_flow).to be(:append)
+        end
+
+        arbre.append &block
+      end
+
+    end
+
+    describe '#prepend' do
+
+      it "should insert an element of the given class using the :prepend flow" do
+        block = proc {}
+        expect(arbre).to receive(:insert).with(element_class, :one, :two) do |&blk|
+          expect(blk).to be(block)
+          expect(arbre.current_flow).to be(:prepend)
+        end
+
+        arbre.prepend element_class, :one, :two, &block
+      end
+
+      it "should run the given block :prepend flow if no block is given" do
+        block = proc do
+          expect(arbre.current_flow).to be(:prepend)
+        end
+
+        arbre.prepend &block
+      end
+
+    end
+
+  ######
+  # After / before
+
+    describe '#after' do
+      let(:parent) { Element.new }
+      let(:element) { Element.new }
+      before { parent << element }
+
+      it "should insert an element of the given class using the :after flow" do
+        block = proc {}
+        expect(arbre).to receive(:insert).with(element_class, :one, :two) do |&blk|
+          expect(blk).to be(block)
+          expect(arbre.current_element).to be(parent)
+          expect(arbre.current_flow).to eql([:after, element])
+        end
+
+        arbre.after element, element_class, :one, :two, &block
+      end
+
+      it "should run the given block :after flow if no block is given" do
+        block = proc do
+          expect(arbre.current_flow).to eql([:after, element])
+        end
+
+        arbre.after element, &block
+      end
+
+    end
+
+    describe '#before' do
+      let(:parent) { Element.new }
+      let(:element) { Element.new }
+      before { parent << element }
+
+      it "should insert an element of the given class using the :before flow" do
+        block = proc {}
+        expect(arbre).to receive(:insert).with(element_class, :one, :two) do |&blk|
+          expect(blk).to be(block)
+          expect(arbre.current_element).to be(parent)
+          expect(arbre.current_flow).to eql([:before, element])
+        end
+
+        arbre.before element, element_class, :one, :two, &block
+      end
+
+      it "should run the given block :before flow if no block is given" do
+        block = proc do
+          expect(arbre.current_flow).to eql([:before, element])
+        end
+
+        arbre.before element, &block
+      end
+
+    end
+
+  ######
+  # Insert child
+
+    describe '#insert_child' do
+
+      let(:element) { Element.new(arbre) }
+      let(:existing) { Element.new(arbre) }
+      let(:child) { Element.new(arbre) }
+
+      context "flow :append" do
+        before { allow(arbre).to receive(:current_flow).and_return(:append) }
+
+        it "should add the child to the element" do
+          expect(element.children).to receive(:<<).with(child)
+          element.insert_child child
+        end
+      end
+
+      context "flow :prepend" do
+        before { allow(arbre).to receive(:current_flow).and_return(:prepend) }
+
+        it "should insert the child at the beginning of the element's children" do
+          expect(element.children).to receive(:insert_at).with(0, child)
+          element.insert_child child
+        end
+
+        it "should change the flow after inserting the first element" do
+          expect(element.children).to receive(:insert_at).with(0, child)
+          expect(arbre).to receive(:replace_current_flow).with([ :after, child ])
+          element.insert_child child
+        end
+      end
+
+      context "flow :after" do
+        before { allow(arbre).to receive(:current_flow).and_return([:after, existing]) }
+
+        it "should insert the child after the existing child" do
+          expect(element.children).to receive(:insert_after).with(existing, child)
+          element.insert_child child
+        end
+
+        it "should change the flow after inserting the first element" do
+          expect(element.children).to receive(:insert_after).with(existing, child)
+          expect(arbre).to receive(:replace_current_flow).with([ :after, child ])
+          element.insert_child child
+        end
+      end
+
+      context "flow :before" do
+        before { allow(arbre).to receive(:current_flow).and_return([:before, existing]) }
+
+        it "should insert the child before the existing child" do
+          expect(element.children).to receive(:insert_before).with(existing, child)
+          element.insert_child child
+        end
+      end
+
+    end
+
+
+  ######
+  # Support
+
+    describe '#temporary' do
+      it "should build an element with the given block and return it" do
+        block = proc {}
+        expect(arbre).to receive(:build).with(Element) do |&blk|
+          expect(blk).to be(block)
+          element
+        end
+        expect(arbre.temporary(&block)).to be(element)
+        expect(element).to be_orphan
+      end
+    end
+
+    it "should delegate #current_element to the context" do
+      current_element = Element.new
+      expect(arbre).to receive(:current_element).and_return(current_element)
+
+      element = Element.new(arbre)
+      expect(element.current_element).to be(current_element)
+    end
+
+    it "should delegate #current_flow to the context" do
+      current_flow = double(:flow)
+      expect(arbre).to receive(:current_flow).and_return(current_flow)
+
+      element = Element.new(arbre)
+      expect(element.current_flow).to be(current_flow)
+    end
+
+end

data/spec/arbre/unit/element_collection_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+include Arbre
+
+describe ElementCollection do
+
+  ######
+  # Collection stuff
+
+    let(:element1) { Element.new }
+    let(:element2) { Element.new }
+    let(:element3) { Element.new }
+
+    it "should initialize as an empty collection by default" do
+      elements = ElementCollection.new
+      expect(elements).to be_empty
+    end
+
+    it "should behave like an array" do
+      elements = ElementCollection.new([element1])
+      expect(elements).to have(1).item
+      expect(elements[0]).to be(element1)
+
+      elements << element2
+      expect(elements).to have(2).item
+      expect(elements[0]).to be(element1)
+      expect(elements[1]).to be(element2)
+
+      elements = ElementCollection.new
+      elements.concat [ element1, element2 ]
+      expect(elements).to have(2).item
+      expect(elements[0]).to be(element1)
+      expect(elements[1]).to be(element2)
+
+      elements.clear
+      expect(elements).to be_empty
+    end
+
+    it "should wrap any enumerable indexing result in another element collection" do
+      collection = ElementCollection.new([element1, element2, element3])
+
+      expect(collection[0]).to be_a(Element)
+
+      expect(collection[0..1]).to be_a(ElementCollection)
+      expect(collection[0..1]).to have(2).items
+      expect(collection[0..1][0]).to be(element1)
+      expect(collection[0..1][1]).to be(element2)
+
+      expect(collection[0, 1]).to be_a(ElementCollection)
+      expect(collection[0, 1]).to have(1).items
+      expect(collection[0, 1][0]).to be(element1)
+    end
+
+    it "should equate to an array" do
+      expect(ElementCollection.new([element1, element2])).to eq([element1, element2])
+      expect(ElementCollection.new([element1, element2])).not_to eq([element2, element1])
+      expect(ElementCollection.new([element1, element2])).not_to eq([element1])
+    end
+
+    it "should equate to another collection with the same elements" do
+      collection = ElementCollection.new([element1, element2])
+      expect(collection).to eq(ElementCollection.new([element1, element2]))
+      expect(collection).not_to eq(ElementCollection.new([element2, element1]))
+      expect(collection).not_to eq(ElementCollection.new([element1]))
+    end
+
+    it "should not be eql? an array" do
+      expect(ElementCollection.new([element1, element2])).not_to eql([element1, element2])
+    end
+
+    it "should be eql? to another collection with the same elements" do
+      collection = ElementCollection.new([element1, element2])
+      expect(collection).to eq(ElementCollection.new([element1, element2]))
+      expect(collection).not_to eq(ElementCollection.new([element2, element1]))
+      expect(collection).not_to eq(ElementCollection.new([element1]))
+    end
+
+    it "should rename 'delete' to 'remove'" do
+      elements = ElementCollection.new([element1, element2])
+      elements.remove element2
+      expect(elements).to eq([element1])
+    end
+
+    describe '#+' do
+
+      it "should combine itself with another collection" do
+        collection1 = ElementCollection.new([element1, element2])
+        collection2 = ElementCollection.new([element2, element3])
+        expect(collection1 + collection2).to be_a(ElementCollection)
+        expect(collection1 + collection2).to eq([element1, element2, element3])
+      end
+
+      it "should combine itself with an array" do
+        collection = ElementCollection.new([element1, element2])
+        expect(collection + [element2, element3]).to be_a(ElementCollection)
+        expect(collection + [element2, element3]).to eq([element1, element2, element3])
+      end
+
+    end
+
+    describe '#-' do
+
+      it "should subtract another collection from itself" do
+        collection1 = ElementCollection.new([element1, element2])
+        collection2 = ElementCollection.new([element2, element3])
+        expect(collection1 - collection2).to be_a(ElementCollection)
+        expect(collection1 - collection2).to eq([element1])
+      end
+
+      it "should combine itself with an array" do
+        collection = ElementCollection.new([element1, element2])
+        expect(collection - [element2, element3]).to be_a(ElementCollection)
+        expect(collection - [element2, element3]).to eq([element1])
+      end
+
+    end
+
+    describe '#&' do
+
+      it "should intersect itself with another collection" do
+        collection1 = ElementCollection.new([element1, element2])
+        collection2 = ElementCollection.new([element2, element3])
+        expect(collection1 & collection2).to be_a(ElementCollection)
+        expect(collection1 & collection2).to eq([element2])
+      end
+
+      it "should intersect itself with an array" do
+        collection = ElementCollection.new([element1, element2])
+        expect(collection & [element2, element3]).to be_a(ElementCollection)
+        expect(collection & [element2, element3]).to eq([element2])
+      end
+
+    end
+
+    it "should not add the same element more than once" do
+      collection = ElementCollection.new
+      element = Element.new
+      collection << element << element
+      expect(collection).to have(1).element
+    end
+
+    specify "#to_a should create a copy of the elements and #to_ary not" do
+      collection = ElementCollection.new([element1, element2])
+      expect(collection.to_ary).to be(collection.to_ary)
+      expect(collection.to_a).not_to be(collection.to_a)
+      expect(collection.to_a).to eql(collection.to_a)
+    end
+
+  ######
+  # Rendering
+
+    describe '#to_s' do
+
+      let(:collection) { ElementCollection.new([element1, element2]) }
+
+      it "should join all elements' to_s result with a return" do
+        expect(element1).to receive(:to_s).and_return('(ELEMENT1)')
+        expect(element2).to receive(:to_s).and_return('(ELEMENT2)')
+        expect(collection.to_s).to eql("(ELEMENT1)\n(ELEMENT2)")
+      end
+
+      it "should be HTML-safe" do
+        expect(element1).to receive(:to_s).and_return('<span>')
+        expect(element2).to receive(:to_s).and_return('<span>'.html_safe)
+        expect(collection.to_s).to eql("&lt;span&gt;\n<span>")
+      end
+
+    end
+
+end