RubyGems - arbre2 - Versions diffs - 2.1.0 - Mend

arbre2 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (76) hide show

checksums.yaml +7 -0
data/.gitignore +30 -0
data/.ruby-gemset +1 -0
data/.ruby-version +1 -0
data/.travis.yml +6 -0
data/CHANGELOG.md +75 -0
data/Gemfile +2 -0
data/Gemfile.lock +93 -0
data/LICENSE +20 -0
data/README.md +92 -0
data/Rakefile +7 -0
data/arbre.gemspec +28 -0
data/lib/arbre/child_element_collection.rb +86 -0
data/lib/arbre/container.rb +20 -0
data/lib/arbre/context.rb +83 -0
data/lib/arbre/element/building.rb +151 -0
data/lib/arbre/element.rb +194 -0
data/lib/arbre/element_collection.rb +93 -0
data/lib/arbre/html/attributes.rb +91 -0
data/lib/arbre/html/class_list.rb +53 -0
data/lib/arbre/html/comment.rb +47 -0
data/lib/arbre/html/document.rb +93 -0
data/lib/arbre/html/html_tags.rb +67 -0
data/lib/arbre/html/querying.rb +256 -0
data/lib/arbre/html/tag.rb +317 -0
data/lib/arbre/rails/layouts.rb +126 -0
data/lib/arbre/rails/legacy_document.rb +29 -0
data/lib/arbre/rails/rendering.rb +76 -0
data/lib/arbre/rails/rspec/arbre_support.rb +61 -0
data/lib/arbre/rails/rspec.rb +2 -0
data/lib/arbre/rails/template_handler.rb +32 -0
data/lib/arbre/rails.rb +35 -0
data/lib/arbre/rspec/be_rendered_as_matcher.rb +103 -0
data/lib/arbre/rspec/be_scripted_as_matcher.rb +68 -0
data/lib/arbre/rspec/contain_script_matcher.rb +64 -0
data/lib/arbre/rspec.rb +3 -0
data/lib/arbre/text_node.rb +35 -0
data/lib/arbre/version.rb +3 -0
data/lib/arbre.rb +27 -0
data/spec/arbre/integration/html_document_spec.rb +90 -0
data/spec/arbre/integration/html_spec.rb +283 -0
data/spec/arbre/integration/querying_spec.rb +187 -0
data/spec/arbre/integration/rails_spec.rb +183 -0
data/spec/arbre/rails/rspec/arbre_support_spec.rb +75 -0
data/spec/arbre/rspec/be_rendered_as_matcher_spec.rb +80 -0
data/spec/arbre/rspec/be_scripted_as_matcher_spec.rb +61 -0
data/spec/arbre/rspec/contain_script_matcher_spec.rb +40 -0
data/spec/arbre/support/arbre_example_group.rb +0 -0
data/spec/arbre/unit/child_element_collection_spec.rb +146 -0
data/spec/arbre/unit/container_spec.rb +23 -0
data/spec/arbre/unit/context_spec.rb +95 -0
data/spec/arbre/unit/element/building_spec.rb +300 -0
data/spec/arbre/unit/element_collection_spec.rb +169 -0
data/spec/arbre/unit/element_spec.rb +297 -0
data/spec/arbre/unit/html/attributes_spec.rb +219 -0
data/spec/arbre/unit/html/class_list_spec.rb +109 -0
data/spec/arbre/unit/html/comment_spec.rb +42 -0
data/spec/arbre/unit/html/querying_spec.rb +32 -0
data/spec/arbre/unit/html/tag_spec.rb +300 -0
data/spec/arbre/unit/rails/layouts_spec.rb +127 -0
data/spec/arbre/unit/text_node_spec.rb +40 -0
data/spec/rails/app/controllers/example_controller.rb +18 -0
data/spec/rails/app/views/example/_arbre_partial.html.arb +7 -0
data/spec/rails/app/views/example/_erb_partial.html.erb +1 -0
data/spec/rails/app/views/example/arbre.html.arb +1 -0
data/spec/rails/app/views/example/arbre_partial_result.html.arb +3 -0
data/spec/rails/app/views/example/erb.html.erb +5 -0
data/spec/rails/app/views/example/erb_partial_result.html.arb +3 -0
data/spec/rails/app/views/example/partials.html.arb +11 -0
data/spec/rails/app/views/layouts/empty.html.arb +1 -0
data/spec/rails/app/views/layouts/with_title.html.arb +5 -0
data/spec/rails/config/routes.rb +4 -0
data/spec/rails_spec_helper.rb +13 -0
data/spec/spec_helper.rb +20 -0
data/spec/support/arbre_example_group.rb +19 -0
metadata +254 -0

data/spec/arbre/integration/rails_spec.rb ADDED Viewed

@@ -0,0 +1,183 @@
+require 'rails_spec_helper'
+describe Arbre::Rails, :type => :request do
+  # Describes Rails integration. Refer to spec/rails/example_app for an example application.
+  # The application offers one controller action mapped to the root path, which can take
+  # the name of a template and/or a layout to render.
+  let(:body) { response.body }
+  ######
+  # Content / layout
+    it "should render an ERB template without a layout" do
+      get '/', :template => 'erb', :layout => false
+      expect(body).to be_rendered_as('<h1>This is an ERB template</h1>', escape: false)
+    end
+    it "should render an Arbre template without a layout" do
+      get '/', :template => 'arbre', :layout => false
+      expect(body).to be_rendered_as('<h1>This is an Arbre template</h1>', escape: false)
+    end
+    it "should render an ERB template with an empty Arbre layout" do
+      get '/', :template => 'erb', :layout => 'empty'
+      expect(body).to be_rendered_as(<<-HTML, escape: false)
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+            <meta http-equiv="Author" content="Me" />
+          </head>
+          <body>
+            <h1>This is an ERB template</h1>
+          </body>
+        </html>
+      HTML
+    end
+    it "should render an ERB template with an Arbre layout that sets a title" do
+      get '/', :template => 'erb', :layout => 'with_title'
+      expect(body).to be_rendered_as(<<-HTML, escape: false)
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Application Title</title>
+            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+            <meta http-equiv="Author" content="Me" />
+          </head>
+          <body>
+            <h1>This is an ERB template</h1>
+          </body>
+        </html>
+      HTML
+    end
+    it "should allow the legacy document class to be overridden" do
+      Arbre::Rails.legacy_document = Class.new(Arbre::Html::Document) do
+        def build!
+          super
+          head do
+            text_node helpers.content_for(:head)
+            text_node helpers.content_for(:styles)
+          end
+          body do
+            div id: 'content-container' do
+              text_node helpers.content_for(:layout)
+            end
+          end
+        end
+      end
+      get '/', :template => 'erb', :layout => 'empty'
+      expect(body).to be_rendered_as(<<-HTML, escape: false)
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+            <meta http-equiv="Author" content="Me" />
+          </head>
+          <body>
+            <div id="content-container">
+             <h1>This is an ERB template</h1>
+           </div>
+          </body>
+        </html>
+      HTML
+      Arbre::Rails.legacy_document = nil
+    end
+    it "should render an Arbre template with an empty Arbre layout" do
+      get '/', :template => 'arbre', :layout => 'empty'
+      expect(body).to be_rendered_as(<<-HTML, escape: false)
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+          </head>
+          <body>
+            <h1>This is an Arbre template</h1>
+          </body>
+        </html>
+      HTML
+    end
+    it "should render an Arbre template with an Arbre layout that sets a title" do
+      get '/', :template => 'arbre', :layout => 'with_title'
+      expect(body).to be_rendered_as(<<-HTML, escape: false)
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Application Title</title>
+            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+          </head>
+          <body>
+            <h1>This is an Arbre template</h1>
+          </body>
+        </html>
+      HTML
+    end
+  ######
+  # Partial / sub-template rendering
+    it "should re-use a context when using method `partial' and the partial is also Arbre" do
+      get '/', :template => 'partials', :layout => false
+      expect(body).to be_rendered_as(%r[
+        <p>Main template: Context Object ID=(\d+)</p>
+        <div id="arbre">
+          <p>Partial: Local1=local1, Context Object ID=(\d+)</p>
+          <p>Paragraph 2</p>
+        </div>
+        <div id="arbre-using-render">
+          <p>Partial: Context Object ID=(\d+)</p>
+          <p>Paragraph 2</p>
+        </div>
+        <div id="erb">
+          <p>ERB template.</p>
+        </div>
+      ]x, escape: false)
+      # Make sure that the context is re-used between the first two, but not in the case of 'render'.
+      (ctx1_id,_), (ctx2_id,_), (ctx3_id,_) = body.scan(/Context Object ID=(\d+)/)
+      expect(ctx1_id).to eql(ctx2_id)
+      expect(ctx1_id).not_to eql(ctx3_id)
+    end
+    it "should return an empty string if an Arbre context is re-used" do
+      get '/partial', :context => true
+      expect(body).to be_rendered_as('', escape: false)
+    end
+    it "should not return an empty string if an Arbre context is not re-used" do
+      get '/partial', :context => false
+      expect(body).to be_rendered_as(%r[^<p>Partial: Context Object ID=(\d+)</p>], escape: false)
+    end
+    it "should handle an Arbre template without converting the template to a string" do
+      get '/', :template => 'arbre_partial_result', :layout => false
+      expect(body).to be_rendered_as(%r[
+        <p>Partial: Context Object ID=(\d+)</p>
+        <p>Paragraph 2</p>
+        <p>The previous element is a Arbre::Html::P</p>
+      ]x, escape: false)
+    end
+    it "should wrap any other partial in a TextNode" do
+      get '/', :template => 'erb_partial_result', :layout => false
+      expect(body).to be_rendered_as(%r[
+        <p>ERB template.</p>
+        <p>The previous element is a Arbre::TextNode</p>
+      ]x, escape: false)
+    end
+end

data/spec/arbre/rails/rspec/arbre_support_spec.rb ADDED Viewed

@@ -0,0 +1,75 @@
+require 'rails_spec_helper'
+describe Arbre::Rails::RSpec::ArbreSupport, arbre: true do
+  let(:example) { self }
+  subject { example }
+  describe '#arbre_context' do
+    let(:assigns) { double(:assigns) }
+    let(:helpers) { double(:helpers) }
+    it "should build and memoize an Arbre context" do
+      context = double(:context)
+      expect(Arbre::Context).to receive(:new).once.with(assigns, helpers).and_return(context)
+      expect(example.arbre_context).to be(context)
+    end
+    it "should be aliased as #arbre" do
+      context = double(:context)
+      expect(Arbre::Context).to receive(:new).once.with(assigns, helpers).and_return(context)
+      expect(example.arbre_context).to be(context)
+      expect(example.arbre).to be(context)
+    end
+  end
+  its(:assigns) { should eql({}) }
+  describe '#helpers' do
+    it "should build and memoize helpers" do
+      helpers = double(:helpers)
+      expect(example).to receive(:build_helpers).once.and_return(helpers)
+      expect(example.helpers).to be(helpers)
+      expect(example.helpers).to be(helpers)
+    end
+  end
+  describe '#build_helpers' do
+    let(:helpers) { example.build_helpers }
+    specify { expect(helpers).to be_a(ActionView::Base) }
+    specify { expect(helpers.controller).to be(controller) }
+    specify { expect(helpers.request).to be(request) }
+    it "should mock an asset_path helper" do
+      expect(helpers.asset_path('test')).to eql('/assets/test')
+    end
+    it "should include any ApplicationController helpers if an ApplicationController exists" do
+      if defined?(::ApplicationController)
+        prev_app_controller = ::ApplicationController
+        Object.send :remove_const, :ApplicationController
+      end
+      ::ApplicationController = Class.new(ActionController::Base)
+      app_helpers = Module.new do
+        def my_method; 'result' end
+      end
+      expect(::ApplicationController).to receive(:_helpers).and_return(app_helpers)
+      expect(helpers.my_method).to eql('result')
+      Object.send :remove_const, :ApplicationController
+      ::ApplicationController = prev_app_controller if prev_app_controller
+    end
+  end
+  describe '#controller' do
+    specify { expect(example.controller).to be_a(ActionController::Base) }
+    specify { expect(example.controller.request).to be(example.request) }
+  end
+  describe '#request' do
+    specify { expect(example.request).to be_a(ActionDispatch::Request) }
+  end
+end

data/spec/arbre/rspec/be_rendered_as_matcher_spec.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require 'spec_helper'
+describe Arbre::RSpec::BeRenderedAsMatcher do
+  it "should fail if the actual was nil" do
+    expect{ expect(nil).to be_rendered_as('<html/>') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type NilClass would be rendered differently:
+          expected: <html/> (String)
+               got: nil
+    STR
+  end
+  it "should fail if the actual's string version was not the same" do
+    expect{ expect(double(:to_s => '<html></html>'.html_safe)).to be_rendered_as('<html/>') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be rendered differently:
+          expected: <html/> (String)
+               got: <html></html>
+    STR
+  end
+  it "should fail if the actual's string version did not match the regular expression" do
+    expect{ expect(double(:to_s => '<html></html>'.html_safe)).to be_rendered_as(/regular* expression{1,2}/) }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be rendered differently:
+          expected: /regular* expression{1,2}/ (Regexp)
+               got: <html></html>
+    STR
+  end
+  it "should fail if the actual's string was not HTML-safed" do
+    expect{ expect(double(:to_s => '<html></html>')).to be_rendered_as('<html></html>') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be rendered differently:
+          expected: <html></html> (String)
+               got: &lt;html&gt;&lt;/html&gt;
+    STR
+  end
+  it "should pass if the actual's string version did match the given string" do
+    expect{ expect('<html></html>'.html_safe).to be_rendered_as('<html></html>') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version did match the given regular expression" do
+    expect{ expect('<html></html>'.html_safe).to be_rendered_as(/<html>.*?<\/html>/) }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version did match the given string, where whitespace is ignored" do
+    expect{ expect('<html>  </html>'.html_safe).to be_rendered_as('<html></html>') }
+      .not_to raise_error
+    expect{ expect("<html>\n</html>\n".html_safe).to be_rendered_as('<html>  </html>') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version did match the given regular expression, where whitespace is ignored" do
+    expect{ expect('<html>  </html>'.html_safe).to be_rendered_as(/<html>.*?<\/html>/) }
+      .not_to raise_error
+    expect{ expect("<html>\n</html>\n".html_safe).to be_rendered_as(/<html.*>  <\/html>/) }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version did match the given string, where attribute order is ignored" do
+    expect{ expect('<html lang="en" data-something="two"></html>'.html_safe).to be_rendered_as('<html data-something="two" lang="en"></html>') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version did match the given regex, where attribute order is ignored" do
+    expect{ expect('<html lang="en" data-something="two"></html>'.html_safe).to be_rendered_as(/<html data-something="two" lang="en">.*<\/html>/) }
+      .not_to raise_error
+  end
+  it "should pass if the actual's string version matched the given string, where placeholders were used" do
+    expect{ expect('<html><body></body></html>'.html_safe).to be_rendered_as('<html>(...)</html>') }
+      .not_to raise_error
+  end
+end

data/spec/arbre/rspec/be_scripted_as_matcher_spec.rb ADDED Viewed

@@ -0,0 +1,61 @@
+require 'spec_helper'
+describe Arbre::RSpec::BeScriptedAsMatcher do
+  it "should fail if the actual's content was not the same" do
+    expect{ expect(double(:content => 'alert("test");')).to be_scripted_as('alert("something else");') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be scripted differently:
+          expected: alert("something else"); (String)
+               got: alert("test");
+    STR
+  end
+  it "should fail if the actual's content did not match the regular expression" do
+    expect{ expect(double(:content => 'alert("test");')).to be_scripted_as(/regular* expression{1,2}/) }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be scripted differently:
+          expected: /regular* expression{1,2}/ (Regexp)
+               got: alert("test");
+    STR
+  end
+  it "should pass if the actual's content did match the given string" do
+    expect{ expect(double(:content => 'alert("test");')).to be_scripted_as('alert("test");') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's content did match the given regular expression" do
+    expect{ expect(double(:content => 'alert("test");')).to be_scripted_as(/alert\("\w+"\);/) }
+      .not_to raise_error
+  end
+  it "should pass if the actual's content did match the given string, where whitespace is ignored" do
+    expect{ expect(double(:content => '  alert("test");  ')).to be_scripted_as('alert("test");') }
+      .not_to raise_error
+    expect{ expect(double(:content => "alert(\"test\");\n")).to be_scripted_as('  alert("test");  ') }
+      .not_to raise_error
+  end
+  it "should fail if the whitespace difference was significant" do
+    expect{ expect(double(:content => 'alert("test   " );')).to be_scripted_as('alert("test");') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock would be scripted differently:
+          expected: alert("test"); (String)
+               got: alert("test   " );
+    STR
+  end
+  it "should pass if the actual's content did match the given regular expression, where whitespace is ignored" do
+    expect{ expect(double(:content => '  alert("test");  ')).to be_scripted_as(/alert\("\w+"\);/) }
+      .not_to raise_error
+    expect{ expect(double(:content => "alert(\"test\");\n")).to be_scripted_as(/  alert\("\w+"\);  /) }
+      .not_to raise_error
+  end
+  it "should pass if the actual's content matched the given string, where placeholders were used" do
+    expect{ expect(double(:content => 'var a=1; alert("test");')).to be_scripted_as('(...)alert("test");') }
+      .not_to raise_error
+  end
+end

data/spec/arbre/rspec/contain_script_matcher_spec.rb ADDED Viewed

@@ -0,0 +1,40 @@
+require 'spec_helper'
+describe Arbre::RSpec::ContainScriptMatcher do
+  it "should fail if the actual's content did not contain the given script" do
+    expect{ expect(double(:to_s => '<script type="javascript">alert("test");</script>')).to contain_script('alert("something else");') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock contained script:
+          expected: alert("something else"); (String)
+               got: <script type="javascript">alert("test");</script>
+    STR
+  end
+  it "should pass if the actual's content did match the given string" do
+    expect{ expect(double(:to_s => '<script type="javascript">alert("test");</script>')).to contain_script('alert("test");') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's content contained given string" do
+    expect{ expect(double(:to_s => '<body><script type="javascript">var a = 1; alert("test");</script></body>')).to contain_script('alert("test");') }
+      .not_to raise_error
+  end
+  it "should pass if the actual's content did match the given string, where whitespace is ignored" do
+    expect{ expect(double(:to_s => '<script type="javascript">  alert("test");  </script>')).to contain_script('alert("test");') }
+      .not_to raise_error
+    expect{ expect(double(:to_s => "<script type=\"javascript\">alert(\"test\");\n</script>")).to contain_script('  alert("test");  ') }
+      .not_to raise_error
+  end
+  it "should fail if the whitespace difference was significant" do
+    expect{ expect(double(:to_s => '<script type="javascript">alert("test   " );</script>')).to contain_script('alert("test");') }
+      .to raise_error(RSpec::Expectations::ExpectationNotMetError, <<-STR.gsub(/^\s{8}/, ''))
+        expected that element of type RSpec::Mocks::Mock contained script:
+          expected: alert("test"); (String)
+               got: <script type="javascript">alert("test   " );</script>
+    STR
+  end
+end

data/spec/arbre/support/arbre_example_group.rb ADDED Viewed

File without changes

data/spec/arbre/unit/child_element_collection_spec.rb ADDED Viewed

@@ -0,0 +1,146 @@
+require 'spec_helper'
+include Arbre
+describe ChildElementCollection do
+  specify { expect(ChildElementCollection).to be < ElementCollection }
+  let(:parent) { Element.new }
+  let(:collection) { ChildElementCollection.new(parent) }
+  let(:element) { Element.new }
+  let(:element1) { Element.new }
+  let(:element2) { Element.new }
+  let(:element3) { Element.new }
+  ######
+  # Parent
+    it "should store its parent" do
+      expect(collection.parent).to be(parent)
+    end
+    it "should only be eql? to another collection if the parent is the same" do
+      collection1 = ChildElementCollection.new(parent)
+      collection1 << element1
+      collection2 = ChildElementCollection.new(parent)
+      collection2 << element1
+      expect(collection1).to eql(collection2)
+      collection2 = ChildElementCollection.new(Element.new)
+      collection2 << element1
+      expect(collection1).not_to eql(collection2)
+    end
+    it "should set the parent to each child element that is added to the collection" do
+      collection << element1
+      expect(element1.parent).to be(parent)
+      collection = ChildElementCollection.new(parent)
+      collection.insert_at 0, element2
+      expect(element2.parent).to be(parent)
+    end
+    it "should remove any element that is added to the collection from its existing parent" do
+      expect(element1).to receive(:remove!)
+      expect(element2).to receive(:remove!)
+      collection << element1
+      collection.insert_at 0, element2
+    end
+    it "should unset the parent from each child element that is removed from the collection" do
+      collection << element
+      collection.remove element
+      expect(element.parent).to be_nil
+    end
+    it "should not add or set the parent of the same element twice" do
+      expect(element).to receive(:parent=).once.with(parent)
+      collection << element << element
+      expect(collection).to have(1).item
+      collection = ChildElementCollection.new(parent)
+      expect(element).to receive(:parent=).once.with(parent)
+      collection << element
+      collection.insert_at 0, element
+      expect(collection).to have(1).item
+    end
+    it "should not unset the parent if the given element was not part of the collection" do
+      element.parent = Element.new
+      collection.remove element
+      expect(element.parent).not_to be_nil
+    end
+    it "should not the parents of all elements if #clear is used" do
+      collection << element1 << element2
+      expect(element1.parent).not_to be_nil
+      expect(element2.parent).not_to be_nil
+      collection.clear
+      expect(element1.parent).to be_nil
+      expect(element2.parent).to be_nil
+    end
+  ######
+  # Inserting
+    describe '#insert_at' do
+      it "should insert the element at the given index" do
+        collection << element1 << element3
+        collection.insert_at 1, element2
+        expect(collection).to eq([element1, element2, element3])
+      end
+      it "should move, and not duplicate, an element that already existed in the collection" do
+        collection << element1 << element3 << element2
+        collection.insert_at 1, element2
+        expect(collection).to eq([element1, element2, element3])
+      end
+      it "should be able to move an element towards the back" do
+        collection << element2 << element1 << element3
+        collection.insert_at 2, element2
+        expect(collection).to eq([element1, element2, element3])
+      end
+    end
+    describe '#insert_after' do
+      it "should insert the element after the other element" do
+        collection << element1
+        collection.insert_after element1, element3
+        collection.insert_after element1, element2
+        expect(collection).to eq([element1, element2, element3])
+      end
+      it "should raise an error if the given reference element did not exist in the collection" do
+        collection << element1
+        expect(element2).to receive(:to_s).and_return('element2')
+        expect { collection.insert_after element2, element3 }.to \
+          raise_error(ArgumentError, 'existing element element2 not found')
+      end
+    end
+    describe '#insert_before' do
+      it "should insert the element after the other element" do
+        collection << element3
+        collection.insert_before element3, element1
+        collection.insert_before element3, element2
+        expect(collection).to eq([element1, element2, element3])
+      end
+      it "should raise an error if the given reference element did not exist in the collection" do
+        collection << element1
+        expect(element2).to receive(:to_s).and_return('element2')
+        expect { collection.insert_before element2, element3 }.to \
+          raise_error(ArgumentError, 'existing element element2 not found')
+      end
+    end
+end

data/spec/arbre/unit/container_spec.rb ADDED Viewed

@@ -0,0 +1,23 @@
+require 'spec_helper'
+include Arbre
+describe Container do
+  it "should render its content" do
+    container = Container.new
+    expect(container).to receive(:content).and_return('(CONTENT)')
+    expect(container.to_s).to eql('(CONTENT)')
+  end
+  it "should have an indentation level of 0 by default" do
+    expect(Container.new.indent_level).to eql(0)
+  end
+  it "should have the same indentation level as its parent" do
+    container = Container.new
+    container.parent = Element.new
+    expect(container.parent).to receive(:indent_level).and_return(5)
+    expect(container.indent_level).to eql(5)
+  end
+end