arbre 1.2.1 → 1.3.0

data/Rakefile

@@ -1,21 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-
-import 'tasks/lint.rake'
-import 'tasks/release.rake'
-
-task default: [:spec, :lint]
-
-task :console do
-  require 'irb'
-  require 'irb/completion'
-
-  require 'pry'
-  require 'arbre'
-
-  ARGV.clear
-  IRB.start
-end

data/arbre.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "arbre/version"
-
-Gem::Specification.new do |s|
-  s.name        = "arbre"
-  s.version     = Arbre::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Greg Bell"]
-  s.email       = ["gregdbell@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{An Object Oriented DOM Tree in Ruby}
-  s.description = %q{An Object Oriented DOM Tree in Ruby}
-  s.license     = "MIT"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = '>= 2.3'
-
-  s.add_dependency("activesupport", ">= 3.0.0")
-end

data/spec/arbre/integration/html_spec.rb

@@ -1,249 +0,0 @@
-require 'spec_helper'
-
-describe Arbre do
-
-  let(:helpers){ nil }
-  let(:assigns){ {} }
-
-  it "should render a single element" do
-    expect(arbre {
-      span "Hello World"
-    }.to_s).to eq("<span>Hello World</span>\n")
-  end
-
-  it "should render a child element" do
-    expect(arbre {
-      span do
-        span "Hello World"
-      end
-    }.to_s).to eq <<~HTML
-      <span>
-        <span>Hello World</span>
-      </span>
-    HTML
-  end
-
-  it "should render an unordered list" do
-    expect(arbre {
-      ul do
-        li "First"
-        li "Second"
-        li "Third"
-      end
-    }.to_s).to eq <<~HTML
-      <ul>
-        <li>First</li>
-        <li>Second</li>
-        <li>Third</li>
-      </ul>
-    HTML
-  end
-
-  it "should allow local variables inside the tags" do
-    expect(arbre {
-      first = "First"
-      second = "Second"
-      ul do
-        li first
-        li second
-      end
-    }.to_s).to eq <<~HTML
-      <ul>
-        <li>First</li>
-        <li>Second</li>
-      </ul>
-    HTML
-  end
-
-  it "should add children and nested" do
-    expect(arbre {
-      div do
-        ul
-        li do
-          li
-        end
-      end
-    }.to_s).to eq <<~HTML
-      <div>
-        <ul></ul>
-        <li>
-          <li></li>
-        </li>
-      </div>
-    HTML
-  end
-
-
-  it "should pass the element in to the block if asked for" do
-    expect(arbre {
-      div do |d|
-        d.ul do
-          li
-        end
-      end
-    }.to_s).to eq <<~HTML
-      <div>
-        <ul>
-          <li></li>
-        </ul>
-      </div>
-    HTML
-  end
-
-
-  it "should move content tags between parents" do
-    expect(arbre {
-      div do
-        span(ul(li))
-      end
-    }.to_s).to eq <<~HTML
-      <div>
-        <span>
-          <ul>
-            <li></li>
-          </ul>
-        </span>
-      </div>
-    HTML
-  end
-
-  it "should add content to the parent if the element is passed into block" do
-    expect(arbre {
-      div do |d|
-        d.id = "my-tag"
-        ul do
-          li
-        end
-      end
-    }.to_s).to eq <<~HTML
-      <div id="my-tag">
-        <ul>
-          <li></li>
-        </ul>
-      </div>
-    HTML
-  end
-
-  it "should have the parent set on it" do
-    list, item = nil
-    arbre {
-      list = ul do
-        li "Hello"
-        item = li "World"
-      end
-    }
-    expect(item.parent).to eq list
-  end
-
-  it "should set a string content return value with no children" do
-    expect(arbre {
-      li do
-        "Hello World"
-      end
-    }.to_s).to eq <<~HTML
-      <li>Hello World</li>
-    HTML
-  end
-
-  it "should turn string return values into text nodes" do
-    node = nil
-    arbre {
-      list = li do
-        "Hello World"
-      end
-      node = list.children.first
-    }
-    expect(node).to be_a Arbre::HTML::TextNode
-  end
-
-  it "should not render blank arrays" do
-    expect(arbre {
-      tbody do
-        []
-      end
-    }.to_s).to eq <<~HTML
-      <tbody></tbody>
-    HTML
-  end
-
-  describe "self-closing nodes" do
-
-    it "should not self-close script tags" do
-      expect(arbre {
-        script type: 'text/javascript'
-      }.to_s).to eq("<script type=\"text/javascript\"></script>\n")
-    end
-
-    it "should self-close meta tags" do
-      expect(arbre {
-        meta content: "text/html; charset=utf-8"
-      }.to_s).to eq("<meta content=\"text/html; charset=utf-8\"/>\n")
-    end
-
-    it "should self-close link tags" do
-      expect(arbre {
-        link rel: "stylesheet"
-      }.to_s).to eq("<link rel=\"stylesheet\"/>\n")
-    end
-
-    Arbre::HTML::Tag::SELF_CLOSING_ELEMENTS.each do |tag|
-      it "should self-close #{tag} tags" do
-        expect(arbre {
-          send(tag)
-        }.to_s).to eq("<#{tag}/>\n")
-      end
-    end
-
-  end
-
-  describe "html safe" do
-
-    it "should escape the contents" do
-      expect(arbre {
-        span("<br />")
-      }.to_s).to eq <<~HTML
-        <span>&lt;br /&gt;</span>
-      HTML
-    end
-
-    it "should return html safe strings" do
-      expect(arbre {
-        span("<br />")
-      }.to_s).to be_html_safe
-    end
-
-    it "should not escape html passed in" do
-      expect(arbre {
-        span(span("<br />"))
-      }.to_s).to eq <<~HTML
-        <span>
-          <span>&lt;br /&gt;</span>
-        </span>
-      HTML
-    end
-
-    it "should escape string contents when passed in block" do
-      expect(arbre {
-        span {
-          span {
-            "<br />"
-          }
-        }
-      }.to_s).to eq <<~HTML
-        <span>
-          <span>&lt;br /&gt;</span>
-        </span>
-      HTML
-    end
-
-    it "should escape the contents of attributes" do
-      expect(arbre {
-        span(class: "<br />")
-      }.to_s).to eq <<~HTML
-        <span class="&lt;br /&gt;"></span>
-      HTML
-    end
-
-  end
-
-end

data/spec/arbre/unit/component_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-# A mock subclass to play with
-class MockComponent < Arbre::Component
-
-  builder_method :mock_component
-
-  def build
-    h2 "Hello World"
-  end
-
-end
-
-describe Arbre::Component do
-
-  let(:assigns) { {} }
-  let(:helpers) { nil }
-
-  let(:component_class){ MockComponent }
-  let(:component){ component_class.new }
-
-  it "should be a subclass of an html div" do
-    expect(Arbre::Component.ancestors).to include(Arbre::HTML::Div)
-  end
-
-  it "should render to a div, even as a subclass" do
-    expect(component.tag_name).to eq('div')
-  end
-
-  it "should add a class by default" do
-    expect(component.class_list).to include("mock_component")
-  end
-
-  it "should render the object using the builder method name" do
-    comp = expect(arbre {
-      mock_component
-    }.to_s).to eq <<~HTML
-      <div class="mock_component">
-        <h2>Hello World</h2>
-      </div>
-      HTML
-  end
-
-end

data/spec/arbre/unit/context_spec.rb

@@ -1,35 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe Arbre::Context do
-
-  let(:context) do
-    Arbre::Context.new do
-      h1 "札幌市北区" # Add some HTML to the context
-    end
-  end
-
-  it "should not increment the indent_level" do
-    expect(context.indent_level).to eq(-1)
-  end
-
-  it "should return a bytesize" do
-    expect(context.bytesize).to eq(25)
-  end
-
-  it "should return a length" do
-    expect(context.length).to eq(25)
-  end
-
-  it "should delegate missing methods to the html string" do
-    expect(context).to respond_to(:index)
-    expect(context.index('<')).to eq(0)
-  end
-
-  it "should use a cached version of the HTML for method delegation" do
-    expect(context).to receive(:to_s).once.and_return("<h1>札幌市北区</h1>")
-    expect(context.index('<')).to eq(0)
-    expect(context.index('<')).to eq(0)
-  end
-
-end

data/spec/arbre/unit/element_finder_methods_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-describe Arbre::Element, "Finder Methods" do
-  let(:assigns){ {} }
-  let(:helpers){ {} }
-
-  describe "finding elements by tag name" do
-
-    it "should return 0 when no elements exist" do
-      expect(arbre {
-        div
-      }.get_elements_by_tag_name("li").size).to eq(0)
-    end
-
-    it "should return a child element" do
-      html = arbre do
-        ul
-        li
-        ul
-      end
-      elements = html.get_elements_by_tag_name("li")
-      expect(elements.size).to eq(1)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
-    end
-
-    it "should return multple child elements" do
-      html = arbre do
-        ul
-        li
-        ul
-        li
-      end
-      elements = html.get_elements_by_tag_name("li")
-      expect(elements.size).to eq(2)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
-      expect(elements[1]).to be_instance_of(Arbre::HTML::Li)
-    end
-
-    it "should return children's child elements" do
-      html = arbre do
-        ul
-        li do
-          li
-        end
-      end
-      elements = html.get_elements_by_tag_name("li")
-      expect(elements.size).to eq(2)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Li)
-      expect(elements[1]).to be_instance_of(Arbre::HTML::Li)
-      expect(elements[1].parent).to eq(elements[0])
-    end
-  end
-
-  #TODO: describe "finding an element by id"
-
-  describe "finding an element by a class name" do
-
-    it "should return 0 when no elements exist" do
-      expect(arbre {
-        div
-      }.get_elements_by_class_name("my_class").size).to eq(0)
-    end
-
-    it "should allow text nodes on tree" do
-      expect(arbre {
-        text_node "text"
-      }.get_elements_by_class_name("my_class").size).to eq(0)
-    end
-
-    it "should return a child element" do
-      html = arbre do
-        div class: "some_class"
-        div class: "my_class"
-      end
-      elements = html.get_elements_by_class_name("my_class")
-      expect(elements.size).to eq(1)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
-    end
-
-    it "should return multple child elements" do
-      html = arbre do
-        div class: "some_class"
-        div class: "my_class"
-        div class: "my_class"
-      end
-      elements = html.get_elements_by_class_name("my_class")
-      expect(elements.size).to eq(2)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
-      expect(elements[1]).to be_instance_of(Arbre::HTML::Div)
-    end
-
-    it "should return elements that match one of several classes" do
-      html = arbre do
-        div class: "some_class this_class"
-        div class: "some_class"
-        div class: "other_class"
-
-      end
-      elements = html.get_elements_by_class_name("this_class")
-      expect(elements.size).to eq(1)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
-    end
-
-    it "should return a grandchild element" do
-      html = arbre do
-        div class: "some_class" do
-          div class: "my_class"
-        end
-      end
-      elements = html.get_elements_by_class_name("my_class")
-      expect(elements.size).to eq(1)
-      expect(elements[0]).to be_instance_of(Arbre::HTML::Div)
-    end
-
-  end
-end