hexp 0.3.3 → 0.4.0.beta1

data/lib/hexp/version.rb

@@ -1,3 +1,3 @@
 module Hexp
-  VERSION = '0.3.3'
+  VERSION = '0.4.0.beta1'
 end

data/spec/integration/literal_syntax_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe 'Constructing literal hexps' do
   it do
-    H[:p].should == Hexp::Node.new(:p, {}, [])
+    expect(H[:p]).to eql Hexp::Node.new(:p, {}, [])
   end
 
   it do
-    H[:p, "foo"].should == Hexp::Node.new(:p, {}, ["foo"])
+    expect(H[:p, "foo"]).to eql Hexp::Node.new(:p, {}, ["foo"])
   end
 
 end

data/spec/shared_helper.rb

@@ -1,5 +1,5 @@
 require 'hexp'
-require 'devtools/spec_helper'
+require 'rspec/its'
 
 RSpec::Matchers.define :dom_eq do |other_dom|
   match do |dom|

data/spec/unit/hexp/builder_spec.rb

@@ -19,7 +19,7 @@ describe Hexp::Builder do
   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
+        expect(Hexp::Builder === builder).to be true
       end
     end
 
@@ -44,7 +44,7 @@ describe Hexp::Builder 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
+        this.expect(::Hexp::Builder === self).to this.be true
       end
     end
 

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

@@ -12,15 +12,15 @@ describe Hexp::CssSelector::Attribute do
     let(:name) { 'href' }
 
     it 'should match elements with the attribute present' do
-      expect(selector.matches? H[:a, href: 'http://foo']).to be_true
+      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
+      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
+      expect(selector.matches? H[:a]).to be false
     end
   end
 
@@ -30,15 +30,15 @@ describe Hexp::CssSelector::Attribute do
     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
+      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
+      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
+      expect(selector.matches? H[:a, class: 'fo']).to be false
     end
   end
 
@@ -48,15 +48,15 @@ describe Hexp::CssSelector::Attribute do
     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
+      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
+      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
+      expect(selector.matches? H[:a]).to be false
     end
   end
 
@@ -66,15 +66,15 @@ describe Hexp::CssSelector::Attribute do
     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
+      expect(selector.matches? H[:a, id: 'foo-1']).to be_truthy
     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
+      expect(selector.matches? H[:a, id: 'myfoo-1']).to be_falsey
     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
+      expect(selector.matches? H[:a, id: 'foo1']).to be_falsey
     end
   end
 
@@ -84,15 +84,15 @@ describe Hexp::CssSelector::Attribute do
     let(:value)    { 'foo' }
 
     it 'should match if the attribute is just the value' do
-      expect(selector.matches? H[:a, id: 'foo']).to be_true
+      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
+      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
+      expect(selector.matches? H[:a, id: 'myfoo-1']).to be false
     end
   end
 
@@ -102,15 +102,15 @@ describe Hexp::CssSelector::Attribute do
     let(:value)    { 'foo' }
 
     it 'should match if the attribute is just the value' do
-      expect(selector.matches? H[:a, id: 'foo']).to be_true
+      expect(selector.matches? H[:a, id: 'foo']).to be_truthy
     end
 
     it 'should match if the attribute ends starts with the value' do
-      expect(selector.matches? H[:a, id: 'hifoo']).to be_true
+      expect(selector.matches? H[:a, id: 'hifoo']).to be_truthy
     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
+      expect(selector.matches? H[:a, id: 'foo-1']).to be_falsey
     end
   end
 
@@ -120,19 +120,19 @@ describe Hexp::CssSelector::Attribute do
     let(:value)    { 'foo' }
 
     it 'should match if the attribute is just the value' do
-      expect(selector.matches? H[:a, id: 'foo']).to be_true
+      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
+      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
+      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
+      expect(selector.matches? H[:a, id: 'yomofohoho']).to be false
     end
   end
 
@@ -140,11 +140,11 @@ describe Hexp::CssSelector::Attribute do
     subject(:selector) { Hexp::CssSelector::Parser.new('[src$="foo/bar.js"]').parse }
 
     it 'should match correctly' do
-      expect(selector.matches? H[:script, src: "/tmp/foo/bar.js"]).to be_true
+      expect(selector.matches? H[:script, src: "/tmp/foo/bar.js"]).to be true
     end
 
     it 'should only match at the end' do
-      expect(selector.matches? H[:script, src: "/tmp/foo/bar.jsx"]).to be_false
+      expect(selector.matches? H[:script, src: "/tmp/foo/bar.jsx"]).to be false
     end
   end
 end

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

@@ -2,14 +2,14 @@ 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
+    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
+    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
+    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

@@ -13,7 +13,7 @@ describe Hexp::CssSelector::CommaSequence do
       let(:element)  { H[:li, class: 'baz'] }
 
       it 'should match' do
-        expect(comma_sequence.matches?(element)).to be_true
+        expect(comma_sequence.matches?(element)).to be true
       end
     end
   end

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

@@ -2,10 +2,10 @@ 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
+    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
+    expect(described_class.new('spane').matches?(H[:div])).to be false
   end
 end

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

@@ -5,11 +5,11 @@ describe Hexp::CssSelector::SimpleSequence 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
+      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
+      expect(sequence.matches?(H[:span])).to be false
     end
   end
 
@@ -17,15 +17,15 @@ describe Hexp::CssSelector::SimpleSequence 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
+      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
+      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
+      expect(sequence.matches?(H[:span, class: 'megalopolis'])).to be false
     end
   end
 
@@ -37,12 +37,12 @@ describe Hexp::CssSelector::SimpleSequence do
     end
 
     it 'should match if all parts are satisfied' do
-      expect(sequence.matches?(H[:div, class: 'mega'])).to be_true
+      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
+      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/css_selector/universal_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe  Hexp::CssSelector::Universal do
   it 'should match everything' do
-    expect(subject.matches? H[:section]).to be_true
+    expect(subject.matches? H[:section]).to be true
   end
 end

data/spec/unit/hexp/dsl_spec.rb

@@ -28,7 +28,7 @@ describe Hexp::DSL do
 
   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>}
+        %r{<div class='prinses'>Liefste, Hart en woorden houden voor jou stil</div>}
   end
 
   it "should delegate `attr' to to_hexp" do
@@ -43,8 +43,8 @@ describe Hexp::DSL do
   end
 
   it "should delegate `class?' to to_hexp" do
-    expect(hexpable.class?(:prinses)).to be_true
-    expect(hexpable.class?(:prins)).to be_false
+    expect(hexpable.class?(:prinses)).to be true
+    expect(hexpable.class?(:prins)).to be false
   end
 
   it "should delegate `rewrite' to to_hexp" do

data/spec/unit/hexp/h_spec.rb

@@ -30,9 +30,9 @@ describe 'H notation' do
       Object.send(:remove_const, :H)
     end
 
-    it 'should set H to Hexp::Node' do
+    it 'should define H' do
       load 'hexp/h.rb'
-      expect(H).to eq(Hexp::Node)
+      expect(H).to be_a Module
     end
   end
 end

data/spec/unit/hexp/node/attributes_spec.rb

@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Hexp::Node::Attributes do
   describe 'attr?' do
     it 'should return true if the attribute is present' do
-      expect(H[:a, href: '/foo'].has_attr?(:href)).to be_true
+      expect(H[:a, href: '/foo'].has_attr?(:href)).to be true
     end
 
     it 'should return true if the attribute is present and empty' do
-      expect(H[:a, href: ''].has_attr?(:href)).to be_true
+      expect(H[:a, href: ''].has_attr?(:href)).to be true
     end
 
     it 'should return false if the attribute is not present' do
-      expect(H[:a].has_attr?(:href)).to be_false
+      expect(H[:a].has_attr?(:href)).to be false
     end
 
     it 'should work with a string argument' do
-      expect(H[:a, href: '/foo'].has_attr?('href')).to be_true
+      expect(H[:a, href: '/foo'].has_attr?('href')).to be true
     end
   end
 

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

@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Hexp::Node, 'class?' do
   context 'with no class attribute set' do
     it 'should return false' do
-      expect(H[:p].class?('strong')).to be_false
+      expect(H[:p].class?('strong')).to be_falsey
     end
   end
 
   context 'with a single class set' do
     it 'should return true if the class name is the same' do
-      expect(H[:p, class: 'strong'].class?('strong')).to be_true
+      expect(H[:p, class: 'strong'].class?('strong')).to be true
     end
 
     it 'should return false if the class name is not same' do
-      expect(H[:p, class: 'strong'].class?('foo')).to be_false
+      expect(H[:p, class: 'strong'].class?('foo')).to be false
     end
 
     it 'should return false if the class name is a partial match' do
-      expect(H[:p, class: 'strong'].class?('stron')).to be_false
+      expect(H[:p, class: 'strong'].class?('stron')).to be false
     end
   end
 
   context 'with multiple classes set' do
     it 'should return true if the class name is part of the class list' do
-      expect(H[:p, class: 'banner strong'].class?('strong')).to be_true
+      expect(H[:p, class: 'banner strong'].class?('strong')).to be true
     end
 
     it 'should return false if the class name is not in the class list' do
-      expect(H[:p, class: 'banner strong'].class?('foo')).to be_false
+      expect(H[:p, class: 'banner strong'].class?('foo')).to be false
     end
 
     it 'should return false if the class name is a partial match' do
-      expect(H[:p, class: 'banner strong'].class?('er str')).to be_false
+      expect(H[:p, class: 'banner strong'].class?('er str')).to be false
     end
   end
 end

data/spec/unit/hexp/node/normalize_spec.rb

@@ -21,13 +21,13 @@ describe Hexp::Node::Normalize, '#call' do
     let(:node) { [:div, {class: 'foo'}] }
 
     it 'should treat the first as the tag' do
-      subject.tag.should == :div
+      expect(subject.tag).to be :div
     end
     it 'should treat the second as the attribute list, if it is a Hash' do
-      subject.attributes.should == {'class' => 'foo'}
+      expect(subject.attributes).to eql('class' => 'foo')
     end
     it 'should treat the second as a list of children, if it is an Array' do
-      subject.children.should == Hexp::List[]
+      expect(subject.children).to eql Hexp::List[]
     end
   end
 
@@ -35,7 +35,7 @@ describe Hexp::Node::Normalize, '#call' do
     let(:node) { [:div, "this is text in the div"] }
 
     it 'should set is as the single child' do
-      subject.children.should == Hexp::List["this is text in the div"]
+      expect(subject.children).to eql Hexp::List["this is text in the div"]
     end
   end
 
@@ -50,7 +50,7 @@ describe Hexp::Node::Normalize, '#call' do
     }
 
     it 'must normalize them recursively' do
-      subject.children.should == Hexp::List[
+      expect(subject.children).to eql Hexp::List[
         Hexp::Node[:h1, {},                  Hexp::List["Big Title"]   ],
         Hexp::Node[:p,  {class: 'greeting'}, Hexp::List["hello world"] ],
         "Some loose text"
@@ -71,7 +71,7 @@ describe Hexp::Node::Normalize, '#call' do
     }
 
     it 'must expand that object' do
-      subject.children.should == Hexp::List[
+      expect(subject.children).to eql Hexp::List[
         Hexp::Node[:em, {}, Hexp::List["I am in your hexpz"] ]
       ]
     end
@@ -84,4 +84,12 @@ describe Hexp::Node::Normalize, '#call' do
     end
   end
 
+  context 'with multiple children not wrapped in an error' do
+    let(:node) { [:div, {foo: 'bar'}, "hello", [:p], [:span, "foo"]] }
+
+    it 'should work fine' do
+      expect(normalized).to eql Hexp::Node[:div, {"foo"=>"bar"}, Hexp::List["hello", Hexp::Node[:p], Hexp::Node[:span, Hexp::List["foo"]]]]
+    end
+  end
+
 end