hexp 0.0.1 → 0.2.0

data/spec/unit/hexp/h_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'H notation' do
+  context 'if H is already defined' do
+    before do
+      @old_H = Object.send(:remove_const, :H)
+      @old_stderr, $stderr = $stderr, StringIO.new
+      ::H = 'foo'.freeze
+    end
+
+    after do
+      Object.send(:remove_const, :H)
+      $stderr = @old_stderr
+      ::H = @old_H
+    end
+
+    it 'should not override H' do
+      expect(H).to eq('foo')
+    end
+
+    it 'should print out a warning on STDERR' do
+      load 'hexp/h.rb'
+      expect($stderr.string).to match(/WARN/)
+    end
+
+  end
+
+  context 'if H is not set yet' do
+    before do
+      Object.send(:remove_const, :H)
+    end
+
+    it 'should set H to Hexp::Node' do
+      load 'hexp/h.rb'
+      expect(H).to eq(Hexp::Node)
+    end
+  end
+end

data/spec/unit/hexp/list_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Hexp::List do
+  it 'should be equal to an Array with the same contents' do
+    expect(Hexp::List[ H[:div] ]).to eq [ H[:div] ]
+  end
+
+  describe 'value and type equality' do
+    it 'should not be #eql? to an Array with the same contents' do
+      expect(Hexp::List[ H[:div] ]).to_not eql [ H[:div] ]
+    end
+  end
+
+  describe 'inspect' do
+    it 'should look exactly like an Array' do
+      expect(Hexp::List[ H[:div] ].inspect).to eq '[H[:div]]'
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'attr' do
+  subject    { hexp.attr(*args)      }
+  let(:hexp) { H[:div, class: 'foo'] }
+
+  context 'with a single string argument' do
+    let(:args) { ['class'] }
+
+    it 'should return the attribute value by that name' do
+      expect(subject).to eq('foo')
+    end
+  end
+
+  context 'with a single symbol argument' do
+    let(:args) { [:class] }
+
+    it 'should return the attribute value by that name' do
+      expect(subject).to eq('foo')
+    end
+  end
+
+  context 'with two argument' do
+    let(:args) { ['data-id', '7'] }
+
+    it 'should return a new Hexp::Node' do
+      expect(subject).to be_instance_of(Hexp::Node)
+    end
+
+    it 'should set the attribute value' do
+      expect(subject.attributes['data-id']).to eq('7')
+    end
+
+    it 'should leave other attributes untouched' do
+      expect(subject.attributes['class']).to eq('foo')
+    end
+
+    context 'with a nil value' do
+      let(:args) { ['class', nil] }
+
+      it 'should unset the attribute' do
+        expect(subject.attributes).to eq({})
+      end
+    end
+  end
+
+  context 'with too many arguments' do
+    let(:args) { ['class', 'baz', 'bar'] }
+
+    it 'should raise an ArgumentError' do
+      expect{ subject }.to raise_error(ArgumentError)
+    end
+  end
+
+end

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

@@ -0,0 +1,125 @@
+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
+    end
+
+    it 'should return true if the attribute is present and empty' do
+      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
+    end
+
+    it 'should work with a string argument' do
+      expect(H[:a, href: '/foo'].has_attr?('href')).to be_true
+    end
+  end
+
+  describe 'class_list' do
+    context 'for a node without a class attribute' do
+      subject(:node) { H[:div] }
+
+      it 'should return an empty string' do
+        expect(node.class_list).to eq []
+      end
+    end
+
+    context 'for a node with an empty class attribute' do
+      subject(:node) { H[:div, class: ''] }
+
+      it 'should return an empty string' do
+        expect(node.class_list).to eq []
+      end
+    end
+
+    context 'for a node with a single class' do
+      subject(:node) { H[:div, class: 'daklazz'] }
+
+      it 'should return a list with the single class' do
+        expect(node.class_list).to eq ['daklazz']
+      end
+    end
+
+    context 'for a node with multiple classes' do
+      subject(:node) { H[:div, class: 'daklazz otherklazz foo'] }
+
+      it 'should return a list with the single class' do
+        expect(node.class_list).to eq ['daklazz', 'otherklazz', 'foo']
+      end
+    end
+  end
+
+  describe 'remove_class' do
+    context 'for a node without a class list' do
+      it 'should be idempotent' do
+        expect(H[:div].remove_class('foo')).to eq H[:div]
+      end
+    end
+
+    context 'for a node with an empty class list' do
+      it 'should remove the attribute' do
+        expect(H[:div, class: ''].remove_class('foo')).to eq H[:div]
+      end
+    end
+
+    context 'for a node with one class' do
+      it 'should remove the class attribute when the class is removed' do
+        expect(H[:div, class: 'foo'].remove_class('foo')).to eq H[:div]
+      end
+
+      it 'should return the node itself when an other class is removed' do
+        expect(H[:div, class: 'foo'].remove_class('bar')).to eq H[:div, class: 'foo']
+      end
+    end
+
+    context 'with a class appearing multiple times in a class list' do
+      it 'should remove all instances of the class' do
+        expect(H[:div, class: 'foo foo'].remove_class('foo')).to eq H[:div]
+      end
+    end
+  end
+
+  describe 'set_attrs' do
+    it 'should set attributes' do
+      expect(H[:foo].set_attrs(class: 'bar')).to eq H[:foo, class: 'bar']
+    end
+
+    it 'should override attributes' do
+      expect(H[:foo, class: 'baz'].set_attrs(class: 'bar')).to eq H[:foo, class: 'bar']
+    end
+
+    it 'should merge keep both old and new attributes' do
+      expect(H[:foo, class: 'baz'].set_attrs(src: 'bar')).to eq H[:foo, class: 'baz', src: 'bar']
+    end
+  end
+
+  describe 'merge_attrs' do
+    describe 'when passing in a Hash' do
+      it 'should set attributes' do
+        expect(H[:foo].merge_attrs(class: 'bar')).to eq H[:foo, class: 'bar']
+      end
+
+      it 'should merge class lists' do
+        expect(H[:foo, class: 'baz'].merge_attrs(class: 'bar')).to eq H[:foo, class: 'baz bar']
+      end
+
+      it 'should override attributes that are not class' do
+        expect(H[:foo, src: 'baz'].set_attrs(src: 'bar')).to eq H[:foo, src: 'bar']
+      end
+
+      it 'should merge keep both old and new attributes' do
+        expect(H[:foo, class: 'baz'].merge_attrs(src: 'bar')).to eq H[:foo, class: 'baz', src: 'bar']
+      end
+    end
+
+    describe 'when passing in a Hexp::Node' do
+      it 'should take the nodes attributes to merge with' do
+        expect(H[:foo, class: 'klz1'].merge_attrs(H[:bla, class: 'klz2'])).to eq H[:foo, class: 'klz1 klz2']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Hexp::Node::Children do
+  describe 'empty?' do
+    context 'for an empty node' do
+      subject { H[:div] }
+      it { should be_empty }
+    end
+
+    context 'for a node with children' do
+      subject { H[:div, [H[:span, "hello"]]] }
+      it { should_not be_empty }
+    end
+  end
+
+  describe 'add_child' do
+    it 'should return a new node with the child added' do
+      expect(H[:div].add_child(H[:span])).to eq H[:div, H[:span]]
+    end
+  end
+
+  describe 'text' do
+    it 'should return all text nodes that are descendant of this node, combined' do
+      expect(H[:div, [
+            "Hello,",
+            H[:span, {class: 'big'}, "World!"]
+          ]
+        ].text
+      ).to eq "Hello,World!"
+    end
+  end
+
+end

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

@@ -0,0 +1,37 @@
+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
+    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
+    end
+
+    it 'should return false if the class name is not same' do
+      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
+    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
+    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
+    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
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Hexp::Node::CssSelection do
+  subject(:selection) { described_class.new(hexp, selector) }
+
+  context 'given a single tag' do
+    let(:selector) { 'span' }
+
+    context 'with a depth of 1' do
+      let(:hexp) { H[:span] }
+
+      it 'should match all nodes of that tag' do
+        expect(selection.to_a).to eq [ H[:span] ]
+      end
+    end
+
+    context 'with a depth of 2' do
+      let(:hexp) { H[:span, {id: 'span-1'}, H[:span, id: 'span-2']] }
+
+      it 'should match all nodes of that tag' do
+        expect(selection.to_a).to eq [ H[:span, id: 'span-2'], hexp ]
+      end
+    end
+  end
+
+  context 'given a tag and class' do
+    let(:selector) { 'span.foo' }
+
+    context 'with a depth of 1' do
+      context 'with a matching tag and class' do
+        let(:hexp) { H[:span, class: 'foo bar'] }
+        its(:to_a) { should eq [ hexp ] }
+      end
+
+      context 'with only a matching tag' do
+        let(:hexp) { H[:span] }
+        its(:to_a) { should eq [] }
+      end
+
+      context 'with only a matching class' do
+        let(:hexp) { H[:div, class: 'foo'] }
+        its(:to_a) { should eq [] }
+      end
+    end
+  end
+
+  context 'given a sequence of tags' do
+    let(:selector) { 'ul li' }
+
+    context 'with a minimal matching tag' do
+      let(:hexp) { H[:ul, H[:li]] }
+      its(:to_a) { should eq [ H[:li] ] }
+    end
+
+    context 'with other tags in between' do
+      let(:hexp) do
+        H[:body, [
+            H[:ul, [
+                H[:span, [
+                    H[:li, id: 'foo'],
+                    H[:li, id: 'bar']]],
+                H[:li, id: 'baz']]]]]
+      end
+      its(:to_a) { should eq %w[foo bar baz].map{|id| H[:li, id: id] } }
+    end
+  end
+
+  describe 'rewrite' do
+    let(:hexp) do
+      H[:ul, [
+          H[:li, [
+              H[:a, href: '/foo']]],
+          H[:a, href: '/moo']]]
+    end
+    let(:selector) { 'li a' }
+
+    it 'should only affect nodes that match the selection' do
+      expect(selection.rewrite {|node| node.add_class('selected')}).to eq(
+        H[:ul, [
+            H[:li, [
+                H[:a, href: '/foo', class: 'selected']]],
+            H[:a, href: '/moo']]]
+      )
+    end
+  end
+end

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

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe Hexp::Node::Normalize, '#call' do
-  subject { Hexp::Node[*node] }
+  subject(:normalized) { Hexp::Node[*node] }
 
   describe 'with a single element' do
-    let (:node) { [:div] }
+    let(:node) { [:div] }
 
     it 'should treat the first as the tag' do
-      subject.tag.should == :div
+      expect(normalized.tag).to eq :div
     end
     it 'should set an empty attribute list' do
-      subject.attributes.should == {}
+      expect(normalized.attributes).to eq Hash[]
     end
     it 'should set an empty children list' do
-      subject.children.should == Hexp::List[]
+      expect(normalized.children).to eql Hexp::List[]
     end
   end
 
   describe 'with two parameters' do
-    let (:node) { [:div, {class: 'foo'}] }
+    let(:node) { [:div, {class: 'foo'}] }
 
     it 'should treat the first as the tag' do
       subject.tag.should == :div
@@ -75,7 +75,13 @@ describe Hexp::Node::Normalize, '#call' do
         Hexp::Node[:em, {}, Hexp::List["I am in your hexpz"] ]
       ]
     end
+  end
 
+  context 'with a nil in the child list' do
+    let(:node) { [:div, [nil]] }
+    it 'should raise an exception' do
+      expect{normalized}.to raise_exception(Hexp::FormatError)
+    end
   end
 
 end

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

@@ -1,29 +1,29 @@
 require 'spec_helper'
 
 describe Hexp::Node, 'rewrite' do
-  subject { hexp.rewrite(&blk) }
+  subject(:rewriter) { Hexp::Node::Rewriter.new(hexp, block) }
+
   let :hexp do
     H[:div, [
         [:a],
         [:p],
-        [:br]
-      ]
-    ]
+        [:br]]]
   end
 
   context 'without a block' do
-    let(:blk) { nil }
+    subject { hexp.rewrite(&block) }
+    let(:block) { nil }
 
-    it 'returns an Enumerator' do
-      expect(subject).to be_instance_of(Enumerator)
+    it 'returns a Rewriter' do
+      expect(subject).to be_instance_of(Hexp::Node::Rewriter)
     end
   end
 
   context 'with a block that returns [child]' do
-    let(:blk) { proc {|child, parent| [child] } }
+    let(:block) { proc {|child, parent| [child] } }
 
-    it 'should return an identical hexp' do
-      expect(subject).to eq(hexp)
+    it 'should return an identical hexpable' do
+      expect(subject.to_hexp).to eq(hexp)
     end
   end
 
@@ -32,21 +32,22 @@ describe Hexp::Node, 'rewrite' do
       H[:span, [super()]]
     end
 
-    let :blk do
+    let :block do
       proc do |child, parent|
         @tags << [child.tag, parent.tag]
+        nil
       end
     end
 
     it 'should traverse depth-first' do
       @tags = []
-      subject
+      rewriter.to_hexp
       expect(@tags).to eq([[:a, :div], [:p, :div], [:br, :div], [:div, :span]])
     end
   end
 
   context 'when adding nodes' do
-    let :blk do
+    let :block do
       proc do |child, parent|
         raise 'got my own node back' if child.tag == :blockquote
         # wrap paragraphs in a <blockquote>
@@ -59,15 +60,11 @@ describe Hexp::Node, 'rewrite' do
     end
 
     it 'should not pass those nodes again to the block' do
-      subject.should == H[:div, [
+      rewriter.to_hexp.should == H[:div, [
           [:a],
           [:blockquote, [
-              [:p]
-            ]
-          ],
-          [:br]
-        ]
-      ]
+              [:p]]],
+          [:br]]]
     end
   end
 
@@ -76,7 +73,7 @@ describe Hexp::Node, 'rewrite' do
       H[:parent, [[:child]]]
     end
 
-    let :blk do
+    let :block do
       proc do |child|
         expect(child).to eq(H[:child])
         [child]
@@ -84,47 +81,87 @@ describe Hexp::Node, 'rewrite' do
     end
 
     it 'should receive the child node as its argument' do
-      subject
+      rewriter.to_hexp
     end
   end
 
   describe 'block response types' do
     context 'when responding with a single node' do
-      let :blk do
+      let :block do
         proc do |child|
           H[:br]
         end
       end
 
       it 'should replace the existing node' do
-        expect(subject).to eq H[:div, [ [:br] ]*3 ]
+        expect(rewriter.to_hexp).to eq H[:div, [ [:br] ]*3 ]
       end
     end
 
     context 'when responding with an array that starts with a Symbol' do
-      let :blk do
+      let :block do
         proc do |child|
           [:br, {class: 'foo'} ]
         end
       end
 
       it 'should treat it as a node and replace the existing one' do
-        expect(subject).to eq H[:div, [ [:br, {'class' => 'foo'}] ]*3 ]
+        expect(rewriter.to_hexp).to eq H[:div, [ [:br, {'class' => 'foo'}] ]*3 ]
+      end
+    end
+
+    context 'when responding with a String' do
+      let :hexp do
+        H[:div, [
+            [:p]
+          ]
+        ]
+      end
+
+      let :block do
+        proc do |child|
+          "Hello"
+        end
+      end
+
+      it 'should convert it to a text node' do
+        expect(rewriter.to_hexp).to eq H[:div, [ Hexp::TextNode.new("Hello") ] ]
       end
     end
 
+
     context 'when responding with nil' do
-      let :blk do
+      let :block do
         proc do |node|
-          [] if node.tag == :a
+          node if [:p, :br].include? node.tag
         end
       end
 
-      it 'should keep the original node' do
-        expect(subject).to eq H[:div, [ H[:p], H[:br] ]]
+      it 'should remove the original node' do
+        expect(rewriter.to_hexp).to eq H[:div, [ H[:p], H[:br] ]]
+      end
+    end
+  end
+
+  context 'when responding with something else than a Hexp, Array or String' do
+    let :block do
+      proc do |node|
+        Object.new
       end
     end
 
+    it 'should raise a FormatError' do
+      expect{rewriter.to_hexp}.to raise_exception(Hexp::FormatError)
+    end
+  end
+
+  context 'with a css selector argument' do
+    let(:selector) { 'p.foo' }
+
+    it 'should delegate to CssSelection, rather than Rewriter' do
+      expect(Hexp::Node::CssSelection).to receive(:new).with(hexp, selector).and_return(double(:rewrite => hexp))
+      hexp.rewrite(selector)
+    end
   end
 
 end