hexp 0.0.1 → 0.2.0

data/spec/shared_helper.rb

@@ -6,3 +6,9 @@ RSpec::Matchers.define :dom_eq do |other_dom|
     Hexp::Nokogiri::Equality.new(dom, other_dom).call
   end
 end
+
+RSpec.configure do |configuration|
+  configuration.mock_with :rspec do |configuration|
+    configuration.syntax = :expect
+  end
+end

data/spec/spec_helper.rb

@@ -13,14 +13,10 @@ if ENV['COVERAGE'] == 'true'
 
   SimpleCov.start do
     command_name 'spec:unit'
+    add_filter 'hexp/h.rb'
 
-    # add_filter 'config'
-
-    # add_group 'Finalizer',    'lib/data_mapper/finalizer'
-
-    minimum_coverage 98.10  # 0.10 lower under JRuby
+    minimum_coverage 98.5
   end
-
 end
 
 require 'shared_helper'

data/spec/unit/hexp/builder_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Hexp::Builder do
+  context 'with an empty block' do
+    it 'should raise an exception' do
+      expect { Hexp::Builder.new {}.to_hexp }.to raise_exception
+    end
+  end
+
+  context 'with a tag and attributes passed to the constructor' do
+    let(:builder) do
+      Hexp::Builder.new :div, class: 'acatalectic'
+    end
+    it 'should use them as the root element' do
+      expect(builder.to_hexp).to eq H[:div, class: 'acatalectic']
+    end
+  end
+
+  context 'with a block parameter' do
+    it 'should pass the builder to the block' do
+      Hexp::Builder.new do |builder|
+        expect(Hexp::Builder === builder).to be_true
+      end
+    end
+
+    it 'should evaluate the block in the caller context' do
+      this = self
+      Hexp::Builder.new do |builder|
+        expect(this).to eq self
+      end
+    end
+
+    it 'should turn calls to the build object into elements' do
+      hexp = Hexp::Builder.new do |builder|
+        builder.div class: 'jintishi' do
+          builder.br
+        end
+      end.to_hexp
+      expect(hexp).to eq(H[:div, {class: 'jintishi'}, H[:br]])
+    end
+  end
+
+  context 'without a block parameter' do
+    it 'should evaluate in the context of the builder' do
+      this = self
+      Hexp::Builder.new do
+        this.expect(::Hexp::Builder === self).to this.be_true
+      end
+    end
+
+    it 'should turn bare method calls into elements' do
+      hexp = Hexp::Builder.new do
+        span do
+          p({class: 'lyrical'}, "I'm with you in Rockland")
+        end
+      end.to_hexp
+      expect(hexp).to eq(H[:span, H[:p, {class: 'lyrical'}, "I'm with you in Rockland"]])
+    end
+  end
+
+  describe 'composing' do
+    it 'should allow inserting Hexpable values with <<' do
+      hexp = Hexp::Builder.new do
+        div do |builder|
+          builder << ::H[:span]
+        end
+      end.to_hexp
+      expect(hexp).to eq(H[:div, H[:span]])
+    end
+
+    it 'should raise exception when inserting a non-hexp' do
+      expect {
+        Hexp::Builder.new {|b| b << Object.new }
+      }.to raise_exception(Hexp::FormatError)
+    end
+  end
+
+  describe Hexp::Builder::NodeBuilder do
+    it 'lets you add CSS classes through method calls' do
+      hexp = Hexp::Builder.new do
+        div.milky.ponderous do
+          blink 'My gracious, how wondrous'
+        end
+      end.to_hexp
+      expect(hexp).to eq(H[:div, {class: 'milky ponderous'}, H[:blink, 'My gracious, how wondrous']])
+    end
+  end
+
+  it 'should add text nodes with text!' do
+    hexp = Hexp::Builder.new do
+      div do
+        text! 'Babyface, bijou, scharmninkel'
+      end
+    end.to_hexp
+    expect(hexp).to eq(H[:div, 'Babyface, bijou, scharmninkel'])
+  end
+
+  it 'should return an inspection string' do
+    expect(Hexp::Builder.new { div }.inspect).to eq "#<Hexp::Builder H[:div]>"
+  end
+end

data/spec/unit/hexp/css_selector/attribute_spec.rb

@@ -0,0 +1,137 @@
+describe Hexp::CssSelector::Attribute do
+  subject(:selector) { described_class.new(name, namespace, operator, value, flags) }
+  let(:name)      { nil }
+  let(:namespace) { nil }
+  let(:operator)  { nil }
+  let(:value)     { nil }
+  let(:flags)     { nil }
+
+  describe 'without an operator' do
+    let(:name) { 'href' }
+
+    it 'should match elements with the attribute present' do
+      expect(selector.matches? H[:a, href: 'http://foo']).to be_true
+    end
+
+    it 'should match elements with an empty attribute present' do
+      expect(selector.matches? H[:a, href: '']).to be_true
+    end
+
+    it 'should not match elements without the attribute present' do
+      expect(selector.matches? H[:a]).to be_false
+    end
+  end
+
+  describe 'with the "=" operator' do
+    let(:name)     { 'class' }
+    let(:operator) { '=' }
+    let(:value)    { 'foo' }
+
+    it "should match if the attribute's value is exactly equal to the given value" do
+      expect(selector.matches? H[:a, class: 'foo']).to be_true
+    end
+
+    it "should not match if the attribute's value contains more than the given value" do
+      expect(selector.matches? H[:a, class: 'foofoo']).to be_false
+    end
+
+    it "should not match if the attribute's value does not contain the given value" do
+      expect(selector.matches? H[:a, class: 'fo']).to be_false
+    end
+  end
+
+  describe 'the "~=" operator' do
+    let(:name)     { 'class' }
+    let(:operator) { '~=' }
+    let(:value)    { 'foo' }
+
+    it 'should match an entry in a space separated list' do
+      expect(selector.matches? H[:a, class: 'foo bla baz']).to be_true
+    end
+
+    it 'should return false if there is no entry that matches' do
+      expect(selector.matches? H[:a, class: 'bla baz']).to be_false
+    end
+
+    it 'should return false if there is no such attribute' do
+      expect(selector.matches? H[:a]).to be_false
+    end
+  end
+
+  describe 'the "|=" operator' do
+    let(:name)     { 'id' }
+    let(:operator) { '|=' }
+    let(:value)    { 'foo' }
+
+    it 'should match if the attribute starts with the value, followed by a dash' do
+      expect(selector.matches? H[:a, id: 'foo-1']).to be_true
+    end
+
+    it 'should not match if the value is not at the start' do
+      expect(selector.matches? H[:a, id: 'myfoo-1']).to be_false
+    end
+
+    it 'should not match if the value is not followed by a dash' do
+      expect(selector.matches? H[:a, id: 'foo1']).to be_false
+    end
+  end
+
+  describe 'the "^=" operator' do
+    let(:name)     { 'id' }
+    let(:operator) { '^=' }
+    let(:value)    { 'foo' }
+
+    it 'should match if the attribute is just the value' do
+      expect(selector.matches? H[:a, id: 'foo']).to be_true
+    end
+
+    it 'should match if the attribute starts with the value' do
+      expect(selector.matches? H[:a, id: 'foohi']).to be_true
+    end
+
+    it 'should not match if the value is not at the start' do
+      expect(selector.matches? H[:a, id: 'myfoo-1']).to be_false
+    end
+  end
+
+  describe 'the "$=" operator' do
+    let(:name)     { 'id' }
+    let(:operator) { '$=' }
+    let(:value)    { 'foo' }
+
+    it 'should match if the attribute is just the value' do
+      expect(selector.matches? H[:a, id: 'foo']).to be_true
+    end
+
+    it 'should match if the attribute ends starts with the value' do
+      expect(selector.matches? H[:a, id: 'hifoo']).to be_true
+    end
+
+    it 'should not match if the value is not at the end' do
+      expect(selector.matches? H[:a, id: 'foo-1']).to be_false
+    end
+  end
+
+  describe 'the "*=" operator' do
+    let(:name)     { 'id' }
+    let(:operator) { '*=' }
+    let(:value)    { 'foo' }
+
+    it 'should match if the attribute is just the value' do
+      expect(selector.matches? H[:a, id: 'foo']).to be_true
+    end
+
+    it 'should match if the attribute starts starts with the value' do
+      expect(selector.matches? H[:a, id: 'foohi']).to be_true
+    end
+
+    it 'should match if the attribute ends starts with the value' do
+      expect(selector.matches? H[:a, id: 'hifoo']).to be_true
+    end
+
+    it 'should not match if the value is not in the attribute' do
+      expect(selector.matches? H[:a, id: 'yomofohoho']).to be_false
+    end
+  end
+
+end

data/spec/unit/hexp/css_selector/class_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hexp::CssSelector::Class do
+  it 'should match elements having the giving class' do
+    expect(described_class.new('big').matches?(H[:div, class: 'big'])).to be_true
+  end
+
+  it 'should not match elements not having the given class' do
+    expect(described_class.new('big').matches?(H[:div, class: 'small'])).to be_false
+  end
+
+  it 'should work with elements with multiple classes' do
+    expect(described_class.new('foo').matches?(H[:div, class: 'foo bar'])).to be_true
+  end
+end

data/spec/unit/hexp/css_selector/comma_sequence_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Hexp::CssSelector::CommaSequence do
+  let(:comma_sequence) { Hexp::CssSelector::Parser.call(selector) }
+
+  it 'has members' do
+    described_class.new([:foo]).members == [:foo]
+  end
+
+  describe '#matches?' do
+    context do
+      let(:selector) { 'ul li, li' }
+      let(:element)  { H[:li, class: 'baz'] }
+
+      it 'should match' do
+        expect(comma_sequence.matches?(element)).to be_true
+      end
+    end
+  end
+end

data/spec/unit/hexp/css_selector/element_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Hexp::CssSelector::Element do
+  it 'should match elements with the same name' do
+    expect(described_class.new('tag').matches?(H[:tag])).to be_true
+  end
+
+  it 'should not match elements with a different name' do
+    expect(described_class.new('spane').matches?(H[:div])).to be_false
+  end
+end

data/spec/unit/hexp/css_selector/parser_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Hexp::CssSelector::Parser do
+  HC = Hexp::CssSelector # Is there really no way to include constant lookup in this namespace ?!
+
+  subject(:parse_tree) { described_class.call(selector) }
+
+
+  context 'with a single tag' do
+    let(:selector) { 'body' }
+    it {
+      should eq HC::CommaSequence[
+        HC::Sequence[
+          HC::SimpleSequence[
+            HC::Element.new('body')]]]
+    }
+  end
+
+  context 'with SASS specific syntax' do
+    let(:selector) { '&.foo' }
+    it 'should raise an exception' do
+      expect{parse_tree}.to raise_exception
+    end
+  end
+
+  context 'with an element, class and id specifier' do
+    let(:selector) { '#main a.strong' }
+    it {
+      should eq HC::CommaSequence[
+        HC::Sequence[
+          HC::SimpleSequence[
+            HC::Id.new('main')],
+          HC::SimpleSequence[
+            HC::Element.new('a'),
+            HC::Class.new('strong')]]]
+    }
+  end
+
+  context 'with an attribute selector' do
+    let(:selector) { 'div[link=href]' }
+    it {
+      should eq HC::CommaSequence[
+        HC::Sequence[
+          HC::SimpleSequence[
+            HC::Element.new('div'),
+            HC::Attribute.new('link', nil, '=', 'href', nil),
+          ]]]
+    }
+  end
+
+end

data/spec/unit/hexp/css_selector/simple_sequence_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Hexp::CssSelector::SimpleSequence do
+  context 'with a single element member' do
+    let(:sequence) { described_class[Hexp::CssSelector::Element.new('div')] }
+
+    it 'should match when the element has the same tag name' do
+      expect(sequence.matches?(H[:div])).to be_true
+    end
+
+    it 'should not match when the tag name differs' do
+      expect(sequence.matches?(H[:span])).to be_false
+    end
+  end
+
+  context 'with a single class member' do
+    let(:sequence) { described_class[Hexp::CssSelector::Class.new('mega')] }
+
+    it 'should match when the element has a class by that name' do
+      expect(sequence.matches?(H[:div, class: 'mega'])).to be_true
+    end
+
+    it 'should not match when the element has no classes' do
+      expect(sequence.matches?(H[:span])).to be_false
+    end
+
+    it 'should not match when the element has no classes by that name' do
+      expect(sequence.matches?(H[:span, class: 'megalopolis'])).to be_false
+    end
+  end
+
+  context 'with an element and class' do
+    let(:sequence) do described_class[
+        Hexp::CssSelector::Element.new('div'),
+        Hexp::CssSelector::Class.new('mega')
+      ]
+    end
+
+    it 'should match if all parts are satisfied' do
+      expect(sequence.matches?(H[:div, class: 'mega'])).to be_true
+    end
+
+    it 'should not match if one parts is not satisfied' do
+      expect(sequence.matches?(H[:div, class: 'foo'])).to be_false
+      expect(sequence.matches?(H[:span, class: 'mega'])).to be_false
+    end
+  end
+end

data/spec/unit/hexp/dsl_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Hexp::DSL do
+  let(:jotie) { 'Liefste, Hart en woorden houden voor jou stil' }
+  let(:hexpable) do
+    Class.new do
+      include Hexp::DSL
+
+      def initialize(klz, words)
+        @class, @words = klz, words
+      end
+
+      def to_hexp
+        H[:div, {class: @class}, [@words]]
+      end
+    end.new('prinses', jotie)
+  end
+
+  {
+    tag: :div,
+    attributes: {'class' => 'prinses'},
+    children: ['Liefste, Hart en woorden houden voor jou stil'],
+  }.each do |method, result|
+    it "should delegate `#{method}' to to_hexp" do
+      expect(hexpable.public_send(method)).to eq(result)
+    end
+  end
+
+  it "should delegate `to_html' to to_hexp" do
+      expect(hexpable.to_html).to match \
+        %r{<div class="prinses">Liefste, Hart en woorden houden voor jou stil</div>}
+  end
+
+  it "should delegate `attr' to to_hexp" do
+    expect(hexpable.attr('class')).to eq('prinses')
+    expect(hexpable.attr('class', 'scharminkel')).to eq(
+      H[:div, {class: 'scharminkel'}, [jotie]]
+    )
+  end
+
+  it "should delegate `select' to to_hexp" do
+    expect(hexpable.select{|el| el.text?}.to_a).to eq([jotie])
+  end
+
+  it "should delegate `class?' to to_hexp" do
+    expect(hexpable.class?(:prinses)).to be_true
+    expect(hexpable.class?(:prins)).to be_false
+  end
+
+  it "should delegate `rewrite' to to_hexp" do
+    expect(hexpable.rewrite {|el| 'De liefde speelt me parten' if el.text?}.to_hexp)
+      .to eq H[:div, {class: 'prinses'}, ['De liefde speelt me parten']]
+  end
+
+end