arbre2 2.1.0

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

@@ -0,0 +1,300 @@
+require 'spec_helper'
+include Arbre::Html
+
+describe Tag do
+
+  let(:tag) { Arbre::Html::Tag.new }
+
+  ######
+  # Building
+
+    it "should use the first argument as content if it is given" do
+      tag.build! "Content"
+      expect(tag.content).to eql('Content')
+    end
+
+    it "should accept attributes" do
+      tag.build! 'id' => 'my-tag'
+      expect(tag.content).to eql('')
+      expect(tag.id).to eql('my-tag')
+    end
+
+    it "should accept content and attributes" do
+      tag.build! "Content", 'id' => 'my-tag'
+      expect(tag.content).to eql('Content')
+      expect(tag.id).to eql('my-tag')
+    end
+
+    it "should accept symbolic keyword arguments as attributes as well" do
+      tag.build! "Content", 'id' => 'my-tag', :class => 'custom'
+      expect(tag.content).to eql('Content')
+      expect(tag.id).to eql('my-tag')
+      expect(tag.classes.to_a).to eql(['custom'])
+    end
+
+    it "should require #tag_name to be implemented" do
+      expect{ tag.tag_name }.to raise_error(NotImplementedError)
+    end
+
+  ######
+  # DSL
+
+    describe '.tag' do
+      it "should define the method tag_name on the class" do
+        klass = Class.new(Arbre::Html::Tag) { tag :span }
+        expect(klass.new.tag_name).to eql('span')
+      end
+
+      it "should use the same tag name for derived classes" do
+        superclass = Class.new(Arbre::Html::Tag) { tag :span }
+        subclass   = Class.new(superclass)
+        expect(subclass.new.tag_name).to eql('span')
+      end
+    end
+
+    describe '.id' do
+      it "should add the given ID to the tag" do
+        klass = Class.new(Arbre::Html::Div) { id 'my-div' }
+        expect(klass.new.tag_id).to eql('my-div')
+        expect(klass.new.build!).to be_rendered_as('<div id="my-div"></div>')
+      end
+
+      it "should also add the ID to subclasses" do
+        superclass = Class.new(Arbre::Html::Div) { id 'my-div' }
+        expect(Class.new(superclass).new.tag_id).to eql('my-div')
+      end
+
+      it "should be able to be overridden in the build method" do
+        klass = Class.new(Arbre::Html::Div) do
+          id 'my-div'
+          def build!
+            self.id = 'overridden'
+            super
+          end
+        end
+        expect(klass.new.build!).to be_rendered_as('<div id="overridden"></div>')
+      end
+    end
+
+    describe '.classes' do
+      it "should add the given classes to the tag" do
+        klass = Class.new(Arbre::Html::Div) { classes 'time-input' }
+        expect(klass.new.tag_classes).to eql(%w[time-input])
+        expect(klass.new.build!).to be_rendered_as('<div class="time-input"></div>')
+      end
+
+      it "should flatten all given classes and allow space separated classes" do
+        klass = Class.new(Arbre::Html::Div) { classes 'one two', 'three', %w[four five] }
+        expect(klass.new.build!).to be_rendered_as('<div class="one two three four five"></div>')
+      end
+
+      it "should also add the classes to subclasses" do
+        superclass = Class.new(Arbre::Html::Div) { classes 'time-input' }
+        expect(Class.new(superclass).new.tag_classes).to eql(%w[time-input])
+      end
+
+      it "should combine classes with any given to the build! method" do
+        klass = Class.new(Arbre::Html::Div) { classes 'one two' }
+        expect(klass.new.build!(:class => 'three')).to be_rendered_as('<div class="one two three"></div>')
+      end
+    end
+
+  ######
+  # Attributes
+
+    specify { expect(tag.attributes).to be_a(Attributes) }
+
+    it "should allow setting an attribute through #set_attribute" do
+      tag.set_attribute :style, 'display: none;'
+      tag.set_attribute 'placeholder', '(test)'
+      expect(tag.attributes).to eq('style' => 'display: none;', 'placeholder' => '(test)')
+    end
+
+    it "should allow getting an attribute through #get_attribute" do
+      tag.set_attribute :style, 'display: none;'
+      expect(tag.get_attribute(:style)).to eql('display: none;')
+      expect(tag.get_attribute('style')).to eql('display: none;')
+    end
+
+    it "should allow setting an attribute through an indexer" do
+      tag[:style] = 'display: none;'
+      tag['placeholder'] = '(test)'
+      expect(tag.attributes).to eq('style' => 'display: none;', 'placeholder' => '(test)')
+    end
+
+    it "should allow getting an attribute through an indexer" do
+      tag[:style] = 'display: none;'
+      expect(tag[:style]).to eql('display: none;')
+      expect(tag['style']).to eql('display: none;')
+    end
+
+    it "should check whether an attribute is set through has_attribute?" do
+      tag[:style] = 'display: none;'
+      expect(tag).to have_attribute(:style)
+      expect(tag).to have_attribute('style')
+      expect(tag).not_to have_attribute(:placeholder)
+    end
+
+    describe "attribute accessors" do
+
+      let(:tag_class) do
+        Class.new(Input) do
+          attribute :value
+          attribute :autocomplete, boolean: true
+        end
+      end
+      let(:tag) { tag_class.new }
+
+      it "should allow access to the :value attribute through a method" do
+        tag.value = 'Test'
+        expect(tag[:value]).to eql('Test')
+
+        tag[:value] = 'Test'
+        expect(tag.value).to eql('Test')
+      end
+
+      it "should allow an attribute to be removed if set to nil" do
+        tag[:value] = 'Test'
+        tag.value = nil
+        expect(tag).not_to have_attribute(:value)
+      end
+
+      it "should allow access to the boolean attribute :autocomplete through a method" do
+        tag.autocomplete = true
+        expect(tag.autocomplete).to be_true
+        expect(tag[:autocomplete]).to eql('autocomplete')
+
+        tag.autocomplete = double(:something_trueish)
+        expect(tag.autocomplete).to be_true
+        expect(tag[:autocomplete]).to eql('autocomplete')
+
+        tag.autocomplete = false
+        expect(tag.autocomplete).to be_false
+        expect(tag[:autocomplete]).to be_nil
+      end
+
+      it "should use the value= method when passing in a value attribute to build!" do
+        allow(tag.attributes).to receive(:[]=)
+
+        value1 = double(:value); other1 = double(:other)
+        expect(tag).to receive(:value=).with(value1)
+        expect(tag.attributes).to receive(:[]=).with(:other, other1)
+        tag.build! value: value1, other: other1
+
+        value2 = double(:value); other2 = double(:other)
+        expect(tag).to receive(:value=).with(value2)
+        expect(tag.attributes).to receive(:[]=).with('other', other2)
+        tag.build! 'value' => value2, 'other' => other2
+      end
+
+      it "should not accidentally set the content this way" do
+        content = 'My Content'
+        expect(tag).not_to receive(:content=)
+        tag.build! content: content
+        expect(tag.attributes[:content]).to eql('My Content')
+      end
+
+      it "should not accidentally invoke a helper method" do
+        helpers = double(:value= => nil)
+        allow(tag).to receive(:helpers).and_return(helpers)
+        expect(helpers).not_to receive(:value=)
+
+        tag.build! value: 'My Value'
+        expect(tag.attributes[:value]).to eql('My Value')
+      end
+
+    end
+
+  ######
+  # ID & classes
+
+    describe '#generate_id' do
+      it "should generate an ID for the tag using its object_id" do
+        tag.generate_id!
+        expect(tag.id).to eql(tag.object_id.to_s)
+        expect(tag[:id]).to eql(tag.object_id.to_s)
+      end
+    end
+
+    describe '#classes' do
+      it "should be the same as the :class attribute" do
+        expect(tag.classes).to be(tag[:class])
+      end
+    end
+
+    describe '#classes=' do
+      it "should replace the class attribute" do
+        expect(tag.attributes).to receive(:[]=).with(:class, 'one')
+        tag.classes = 'one'
+      end
+    end
+
+    describe '#add_class' do
+      it "should add classes" do
+        tag.add_class 'one'
+        expect(tag.classes.to_a).to eql(['one'])
+        tag.add_class 'two three'
+        expect(tag.classes.to_a).to eql(['one', 'two', 'three'])
+      end
+    end
+
+    describe '#remove_class' do
+      it "should remove classes" do
+        tag.classes = 'one two three'
+        expect(tag.classes.to_a).to eql(['one', 'two', 'three'])
+        tag.remove_class 'two three'
+        expect(tag.classes.to_a).to eql(['one'])
+      end
+    end
+
+    describe '#has_class?' do
+      it "should check whether the given class is present" do
+        tag.classes = 'one two three'
+        expect(tag).to have_class('one')
+        expect(tag).not_to have_class('four')
+      end
+
+      it "should check whether *all* given classes is present" do
+        tag.classes = 'one two three'
+        expect(tag).to have_class('one two')
+        expect(tag).not_to have_class('two four')
+      end
+    end
+
+  ## Rendering is exemplified in the integration HTML spec.
+
+  ######
+  # Inspection
+
+    it "should provide a terse description when using #inspect" do
+      table = Arbre::Html::Table.new
+      expect(table.inspect).to eql('<table>')
+
+      table.id = 'test'
+      expect(table.inspect).to eql('<table#test>')
+
+      table.classes << 'one' << 'two'
+      expect(table.inspect).to eql('<table#test.one.two>')
+
+      table.id = nil
+      expect(table.inspect).to eql('<table.one.two>')
+
+      input = Arbre::Html::Input.new
+      input.type = 'text'
+      expect(input.inspect).to eql('<input[type=text]>')
+    end
+
+    it "should append the class name if this is different from the tag name" do
+      klass = Class.new(Html::Tag) do
+        def tag_name
+          'table'
+        end
+        def self.name
+          'Datagrid'
+        end
+      end
+
+      expect(klass.new.inspect).to eql('<table(Datagrid)>')
+    end
+
+end

data/spec/arbre/unit/rails/layouts_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+require 'arbre/rails/layouts'
+Arbre::Context.send :include, Arbre::Rails::Layouts::ContextMethods
+
+describe Arbre::Rails::Layouts do
+
+  # Layouts are also integration-specced in integration/rails_spec.rb.
+  let(:controller) { double() }
+
+  before do
+    allow(helpers).to receive(:controller).and_return(controller)
+    allow(helpers).to receive(:request).and_return(double(:xhr? => false))
+    controller.singleton_class.send :include, Arbre::Rails::Layouts::ControllerMethods
+  end
+
+  describe '#layout' do
+
+    context "not having specified a document (i.e. a non-Arbre content template)" do
+      it "should use the current legacy document" do
+        legacy_document_class = Class.new(Arbre::Html::Document)
+        expect(Arbre::Rails).to receive(:legacy_document).and_return(legacy_document_class)
+
+        arbre.layout
+        expect(arbre.children.first).to be_a(legacy_document_class)
+      end
+
+      it "should run a given layout block on it" do
+        legacy_document_class = Class.new(Arbre::Html::Document)
+        expect(Arbre::Rails).to receive(:legacy_document).and_return(legacy_document_class)
+
+        receiver = nil
+        layout_block = proc { receiver = self }
+
+        arbre.layout &layout_block
+        expect(receiver).to be(arbre.children.first)
+      end
+    end
+
+    context "having specified a document but not a content block" do
+      it "should use the document class and arguments" do
+        document_class = Class.new(Arbre::Html::Document)
+        expect_any_instance_of(document_class).to receive(:build!).with(:one, :two)
+
+        arbre.document document_class, :one, :two
+        arbre.layout
+        expect(arbre.children.first).to be_a(document_class)
+      end
+
+      it "should run a given layout block on it" do
+        document_class = Class.new(Arbre::Html::Document)
+
+        receiver = nil
+        layout_block = proc { receiver = self }
+
+        arbre.document document_class
+        arbre.layout &layout_block
+        expect(receiver).to be(arbre.children.first)
+      end
+    end
+
+    context "having specified a document and a content block" do
+
+      it "should use the document class, arguments and content block" do
+        document_class = Class.new(Arbre::Html::Document)
+
+        called = false
+        block = proc { called = true }
+        expect_any_instance_of(document_class).to receive(:build!).with(:one, :two) do |&blk|
+          blk.call
+        end
+
+        arbre.document document_class, :one, :two, &block
+        arbre.layout
+        expect(arbre.children.first).to be_a(document_class)
+        expect(called).to be_true
+      end
+
+      it "should execute the content block on the document if it was not called from its build! method" do
+        document_class = Class.new(Arbre::Html::Document)
+
+        called = false
+        receiver = nil
+        block = proc { called = true; receiver = self }
+        expect_any_instance_of(document_class).to receive(:build!).with(:one, :two)
+
+        arbre.document document_class, :one, :two, &block
+        arbre.layout
+        expect(arbre.children.first).to be_a(document_class)
+        expect(called).to be_true
+        expect(receiver).to be(arbre.children.first)
+      end
+
+      it "should run a given layout block on it, but after the content block" do
+        document_class = Class.new(Arbre::Html::Document)
+        expect_any_instance_of(document_class).to receive(:build!)
+
+        called = []; receivers = []
+        content_block = proc { called << :content; receivers << self }
+        layout_block = proc { called << :layout; receivers << self }
+
+        arbre.document document_class, &content_block
+        arbre.layout &layout_block
+        expect(called).to eql([ :content, :layout ])
+        expect(receivers[0]).to be(arbre.children.first)
+        expect(receivers[1]).to be(arbre.children.first)
+      end
+
+    end
+
+    it "should not call a layout block if this is an AJAX request" do
+      expect(helpers.request).to receive(:xhr?).and_return(true)
+
+      document_class = Class.new(Arbre::Html::Document)
+
+      called = []
+      content_block = proc { called << :content }
+      layout_block = proc { called << :layout }
+
+      arbre.document document_class, &content_block
+      arbre.layout &layout_block
+      expect(called).to eql([ :content ])
+    end
+
+  end
+
+end

data/spec/arbre/unit/text_node_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+include Arbre
+
+describe TextNode do
+
+  it "should accept only a string in its build method" do
+    node = arbre.append(TextNode, 'Test')
+    expect(node.text).to eql('Test')
+  end
+
+  it "should be buildable using :text_node" do
+    node = arbre.text_node('Test')
+    expect(node).to be_a(TextNode)
+    expect(node.text).to eql('Test')
+  end
+
+  it "should be able to be created from a string" do
+    node = TextNode.from_string('Test')
+    expect(node.text).to eql('Test')
+  end
+
+  it "should render its text only" do
+    node = TextNode.new
+    expect(node).to receive(:text).and_return('Test')
+    expect(node.to_s).to eql('Test')
+  end
+
+  it "should always have an empty child collection" do
+    node = TextNode.new
+    expect(node.children).to be_empty
+  end
+
+  it "should be disallowed to add any children" do
+    node = TextNode.new
+    expect{ node.children << Element.new }.to raise_error(NotImplementedError)
+    expect{ node.children.add Element.new }.to raise_error(NotImplementedError)
+    expect{ node.children.concat [ Element.new ] }.to raise_error(NotImplementedError)
+  end
+
+end

data/spec/rails/app/controllers/example_controller.rb

@@ -0,0 +1,18 @@
+class ExampleController < ActionController::Base
+
+  def show
+    layout = params[:layout] == 'false' ? false : params[:layout]
+    render params[:template], :layout => layout
+  end
+
+  def partial
+    reuse_context = params[:context] != 'false'
+
+    if reuse_context
+      render :partial => 'arbre_partial', locals: { :arbre_context => Arbre::Context.new }
+    else
+      render :partial => 'arbre_partial'
+    end
+  end
+
+end

data/spec/rails/app/views/example/_arbre_partial.html.arb

@@ -0,0 +1,7 @@
+if defined?(local1)
+  para "Partial: Local1=#{local1}, Context Object ID=#{arbre_context.object_id}"
+  para "Paragraph 2"
+else
+  para "Partial: Context Object ID=#{arbre_context.object_id}"
+  para "Paragraph 2"
+end

data/spec/rails/app/views/example/_erb_partial.html.erb

@@ -0,0 +1 @@
+<p>ERB template.</p>

data/spec/rails/app/views/example/arbre.html.arb

@@ -0,0 +1 @@
+h1 "This is an Arbre template"

data/spec/rails/app/views/example/arbre_partial_result.html.arb

@@ -0,0 +1,3 @@
+render :partial => 'arbre_partial'
+
+para "The previous element is a #{current_element.children.first.class}"

data/spec/rails/app/views/example/erb.html.erb

@@ -0,0 +1,5 @@
+<% content_for(:head) do %>
+  <meta http-equiv="Author" content="Me" />
+<% end %>
+
+<h1>This is an ERB template</h1>

data/spec/rails/app/views/example/erb_partial_result.html.arb

@@ -0,0 +1,3 @@
+render :partial => 'erb_partial'
+
+para "The previous element is a #{current_element.children.first.class}"

data/spec/rails/app/views/example/partials.html.arb

@@ -0,0 +1,11 @@
+para "Main template: Context Object ID=#{arbre_context.object_id}"
+
+div id: 'arbre' do
+  partial 'arbre_partial', local1: 'local1'
+end
+div id: 'arbre-using-render' do
+  render partial: 'arbre_partial'
+end
+div id: 'erb' do
+  partial 'erb_partial'
+end

data/spec/rails/app/views/layouts/empty.html.arb

@@ -0,0 +1 @@
+layout

data/spec/rails/app/views/layouts/with_title.html.arb

@@ -0,0 +1,5 @@
+layout do
+
+  self.title = "Application Title"
+
+end

data/spec/rails/config/routes.rb

@@ -0,0 +1,4 @@
+Combustion::Application.routes.draw do
+  get '/' => 'example#show'
+  get '/partial' => 'example#partial'
+end

data/spec/rails_spec_helper.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+require 'combustion'
+require 'bundler/setup'
+require 'arbre/rails'
+
+Combustion.path = 'spec/rails'
+Combustion.initialize! :action_controller, :action_view do
+  config.middleware.use 'Rack::Lint'
+end
+
+require 'rspec/rails'
+require 'arbre/rails/rspec'

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec'
+end
+
+require 'arbre'
+require 'arbre/rspec'
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec do |config|
+    config.syntax = [ :should, :expect ]
+  end
+
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}

data/spec/support/arbre_example_group.rb

@@ -0,0 +1,19 @@
+module ArbreExampleGroup
+
+  def arbre(&block)
+    @context ||= Arbre::Context.new(assigns, helpers)
+    @context.instance_exec &block if block_given?
+    @context
+  end
+
+  def assigns
+    @assigns ||= {}
+  end
+
+  def helpers
+    @helpers ||= {}
+  end
+
+end
+
+RSpec.configure { |c| c.include ArbreExampleGroup }