RubyGems - arbre2 - Versions diffs - 2.1.0 - Mend

arbre2 2.1.0

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