xpath 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce787a09ca48f5c96580cbced2533d00b741a0e3
-  data.tar.gz: c4310006453b0029c593077b225d36e79dfd35af
+  metadata.gz: ae41f677ac864edf9c7689365012dc5f73731f61
+  data.tar.gz: 63f10b70109aa842ac464b8491071a286b583f4c
 SHA512:
-  metadata.gz: 83b64861c13aecd52661c7cbc598f90c4a17aeb71c86936f0bec36d97ffe4248fc8302cad434742b95074b6aded1de563c33a3f82df12e4baf42d10c42d132ac
-  data.tar.gz: bc2e7c29f1240475904601bc7f8ad2ecda2978536b97e1ab407bc855ec16b7f64b48cc49400a501833bb8ac643bcc8b1e2052d4a05974c3df7ca0355ac26fe4e
+  metadata.gz: 7683342805b10e97fcb6593148c0beedb6ad43b7087915697b4a87b4127d88d1669e9e3d6a630a019a500c2203eff4a8b6c702e8bedb313ee41ca1ad726be446
+  data.tar.gz: 4d9146f6cd818e364b94b95f219d40a70571c33a01faa58af9feccb7d3f40d7f0e1b0d9093ef1aec4aae2429859001fa15e341a032a4248575804886e0fd8344

data/lib/xpath.rb

@@ -5,7 +5,6 @@ require 'xpath/expression'
 require 'xpath/literal'
 require 'xpath/union'
 require 'xpath/renderer'
-require 'xpath/html'
 
 module XPath
   extend XPath::DSL

data/lib/xpath/dsl.rb

@@ -68,7 +68,7 @@ module XPath
 
     METHODS = [
       # node set
-      :count, :id, :local_name, :namespace_uri, :name,
+      :count, :id, :local_name, :namespace_uri,
       # string
       :string, :concat, :starts_with, :contains, :substring_before,
       :substring_after, :substring, :string_length, :normalize_space,
@@ -86,8 +86,13 @@ module XPath
       end
     end
 
+    def qname
+      method(:name)
+    end
+
     alias_method :inverse, :not
     alias_method :~, :not
+    alias_method :!, :not
     alias_method :normalize, :normalize_space
     alias_method :n, :normalize_space
 
@@ -95,6 +100,7 @@ module XPath
       [:equals, :"=", :==],
       [:or, :or, :|],
       [:and, :and, :&],
+      [:not_equals, :!=, :!=],
       [:lte, :<=, :<=],
       [:lt, :<, :<],
       [:gte, :>=, :>=],
@@ -128,6 +134,10 @@ module XPath
 
     alias_method :self_axis, :self
 
+    def contains_word(word)
+      function(:concat, " ", current.normalize_space, " ").contains(" #{word} ")
+    end
+
     def one_of(*expressions)
       expressions.map do |e|
         current.equals(e)

data/lib/xpath/version.rb

@@ -1,3 +1,3 @@
 module XPath
-  VERSION = '2.1.0'
+  VERSION = '3.0.0'
 end

data/spec/fixtures/simple.html

@@ -17,7 +17,7 @@
 
     <div id="woo" title="wooDiv" data="id">
       <ul><li>A list</li></ul>
-      <p title="gorilla">Bax</p>
+      <p class="cat fish dog" title="gorilla">Bax</p>
       <p>Bax</p>
       <p id="wooDiv">Blah</p>
     </div>
@@ -26,7 +26,7 @@
 
     <div id="preference">
       <p id="is-fuzzy">allamas</p>
-      <p id="is-exact">llama</p>
+      <p class="fish" id="is-exact">llama</p>
     </div>
 
     <p id="whitespace">
@@ -37,7 +37,7 @@
     </p>
 
     <div id="moar">
-      <p id="impchay">chimp</p>
+      <p class="catfish" id="impchay">chimp</p>
       <div id="elephantay">elephant</div>
       <p id="amingoflay">flamingo</p>
     </div>

data/spec/union_spec.rb

@@ -9,7 +9,7 @@ describe XPath::Union do
       @expr1 = XPath.generate { |x| x.descendant(:p) }
       @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = XPath::Union.new(@expr1, @expr2)
-      @collection.expressions.should == [@expr1, @expr2]
+      @collection.expressions.should eq [@expr1, @expr2]
     end
   end
 
@@ -20,7 +20,7 @@ describe XPath::Union do
       @collection = XPath::Union.new(@expr1, @expr2)
       exprs = []
       @collection.each { |expr| exprs << expr }
-      exprs.should == [@expr1, @expr2]
+      exprs.should eq [@expr1, @expr2]
     end
   end
 
@@ -29,7 +29,7 @@ describe XPath::Union do
       @expr1 = XPath.generate { |x| x.descendant(:p) }
       @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = XPath::Union.new(@expr1, @expr2)
-      @collection.map { |expr| expr.expression }.should == [:descendant, :descendant]
+      @collection.map { |expr| expr.expression }.should eq [:descendant, :descendant]
     end
   end
 
@@ -39,9 +39,9 @@ describe XPath::Union do
       @expr2 = XPath.generate { |x| x.descendant(:div).where(x.attr(:id) == 'foo') }
       @collection = XPath::Union.new(@expr1, @expr2)
       @results = doc.xpath(@collection.to_xpath)
-      @results[0][:title].should == 'fooDiv'
-      @results[1].text.should == 'Blah'
-      @results[2].text.should == 'Bax'
+      @results[0][:title].should eq 'fooDiv'
+      @results[1].text.should eq 'Blah'
+      @results[2].text.should eq 'Bax'
     end
   end
 
@@ -54,9 +54,9 @@ describe XPath::Union do
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
       @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
-      @results[0][:title].should == 'fooDiv'
+      @results[0][:title].should eq 'fooDiv'
       @results = doc.xpath(@xpath2)
-      @results[0][:id].should == 'fooDiv'
+      @results[0][:id].should eq 'fooDiv'
     end
   end
 

data/spec/xpath_spec.rb

@@ -20,14 +20,14 @@ describe XPath do
 
   it "should work as a mixin" do
     xpath = Thingy.new.foo_div.to_xpath
-    doc.xpath(xpath).first[:title].should == 'fooDiv'
+    doc.xpath(xpath).first[:title].should eq 'fooDiv'
   end
 
   describe '#descendant' do
     it "should find nodes that are nested below the current node" do
       @results = xpath { |x| x.descendant(:p) }
-      @results[0].text.should == "Blah"
-      @results[1].text.should == "Bax"
+      @results[0].text.should eq "Blah"
+      @results[1].text.should eq "Bax"
     end
 
     it "should not find nodes outside the context" do
@@ -40,22 +40,22 @@ describe XPath do
 
     it "should find multiple kinds of nodes" do
       @results = xpath { |x| x.descendant(:p, :ul) }
-      @results[0].text.should == 'Blah'
-      @results[3].text.should == 'A list'
+      @results[0].text.should eq 'Blah'
+      @results[3].text.should eq 'A list'
     end
 
     it "should find all nodes when no arguments given" do
       @results = xpath { |x| x.descendant[x.attr(:id) == 'foo'].descendant }
-      @results[0].text.should == 'Blah'
-      @results[4].text.should == 'A list'
+      @results[0].text.should eq 'Blah'
+      @results[4].text.should eq 'A list'
     end
   end
 
   describe '#child' do
     it "should find nodes that are nested directly below the current node" do
       @results = xpath { |x| x.descendant(:div).child(:p) }
-      @results[0].text.should == "Blah"
-      @results[1].text.should == "Bax"
+      @results[0].text.should eq "Blah"
+      @results[1].text.should eq "Bax"
     end
 
     it "should not find nodes that are nested further down below the current node" do
@@ -65,46 +65,46 @@ describe XPath do
 
     it "should find multiple kinds of nodes" do
       @results = xpath { |x| x.descendant(:div).child(:p, :ul) }
-      @results[0].text.should == 'Blah'
-      @results[3].text.should == 'A list'
+      @results[0].text.should eq 'Blah'
+      @results[3].text.should eq 'A list'
     end
 
     it "should find all nodes when no arguments given" do
       @results = xpath { |x| x.descendant[x.attr(:id) == 'foo'].child }
-      @results[0].text.should == 'Blah'
-      @results[3].text.should == 'A list'
+      @results[0].text.should eq 'Blah'
+      @results[3].text.should eq 'A list'
     end
   end
 
   describe '#axis' do
     it "should find nodes given the xpath axis" do
       @results = xpath { |x| x.axis(:descendant, :p) }
-      @results[0].text.should == "Blah"
+      @results[0].text.should eq "Blah"
     end
 
     it "should find nodes given the xpath axis without a specific tag" do
       @results = xpath { |x| x.descendant(:div)[x.attr(:id) == 'foo'].axis(:descendant) }
-      @results[0][:id].should == "fooDiv"
+      @results[0][:id].should eq "fooDiv"
     end
   end
 
   describe '#next_sibling' do
     it "should find nodes which are immediate siblings of the current node" do
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling(:p) }.first.text.should == 'Bax'
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling(:ul, :p) }.first.text.should == 'Bax'
-      xpath { |x| x.descendant(:p)[x.attr(:title) == 'monkey'].next_sibling(:ul, :p) }.first.text.should == 'A list'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling(:p) }.first.text.should eq 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling(:ul, :p) }.first.text.should eq 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:title) == 'monkey'].next_sibling(:ul, :p) }.first.text.should eq 'A list'
       xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling(:ul, :li) }.first.should be_nil
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling }.first.text.should == 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'fooDiv'].next_sibling }.first.text.should eq 'Bax'
     end
   end
 
   describe '#previous_sibling' do
     it "should find nodes which are exactly preceding the current node" do
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling(:p) }.first.text.should == 'Bax'
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling(:ul, :p) }.first.text.should == 'Bax'
-      xpath { |x| x.descendant(:p)[x.attr(:title) == 'gorilla'].previous_sibling(:ul, :p) }.first.text.should == 'A list'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling(:p) }.first.text.should eq 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling(:ul, :p) }.first.text.should eq 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:title) == 'gorilla'].previous_sibling(:ul, :p) }.first.text.should eq 'A list'
       xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling(:ul, :li) }.first.should be_nil
-      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling }.first.text.should == 'Bax'
+      xpath { |x| x.descendant(:p)[x.attr(:id) == 'wooDiv'].previous_sibling }.first.text.should eq 'Bax'
     end
   end
 
@@ -114,7 +114,7 @@ describe XPath do
         foo_div = x.anywhere(:div).where(x.attr(:id) == 'foo')
         x.descendant(:p).where(x.attr(:id) == foo_div.attr(:title))
       end
-      @results[0].text.should == "Blah"
+      @results[0].text.should eq "Blah"
     end
 
     it "should find multiple kinds of nodes regardless of the context" do
@@ -123,10 +123,10 @@ describe XPath do
         context.anywhere(:p, :ul)
       end
 
-      @results[0].text.should == 'Blah'
-      @results[3].text.should == 'A list'
-      @results[4].text.should == 'A list'
-      @results[6].text.should == 'Bax'
+      @results[0].text.should eq 'Blah'
+      @results[3].text.should eq 'A list'
+      @results[4].text.should eq 'A list'
+      @results[6].text.should eq 'Bax'
     end
 
     it "should find all nodes when no arguments given regardless of the context" do
@@ -134,13 +134,13 @@ describe XPath do
         context=x.descendant(:div).where(x.attr(:id)=='woo')
         context.anywhere
       end
-      @results[0].name.should == 'html'
-      @results[1].name.should == 'head'
-      @results[2].name.should == 'body'
-      @results[6].text.should == 'Blah'
-      @results[10].text.should == 'A list'
-      @results[13].text.should == 'A list'
-      @results[15].text.should == 'Bax'
+      @results[0].name.should eq 'html'
+      @results[1].name.should eq 'head'
+      @results[2].name.should eq 'body'
+      @results[6].text.should eq 'Blah'
+      @results[10].text.should eq 'A list'
+      @results[13].text.should eq 'A list'
+      @results[15].text.should eq 'Bax'
     end
 
   end
@@ -150,7 +150,7 @@ describe XPath do
       @results = xpath do |x|
         x.descendant(:div).where(x.attr(:title).contains('ooD'))
       end
-      @results[0][:id].should == "foo"
+      @results[0][:id].should eq "foo"
     end
 
     it "should find nodes that contain the given expression" do
@@ -158,7 +158,18 @@ describe XPath do
         expression = x.anywhere(:div).where(x.attr(:title) == 'fooDiv').attr(:id)
         x.descendant(:div).where(x.attr(:title).contains(expression))
       end
-      @results[0][:id].should == "foo"
+      @results[0][:id].should eq "foo"
+    end
+  end
+
+  describe "#contains_word" do
+    it "should find nodes that contain the given word in its entirety" do
+      @results = xpath do |x|
+        x.descendant.where(x.attr(:class).contains_word('fish'))
+      end
+      @results[0].text.should eq "Bax"
+      @results[1].text.should eq "llama"
+      @results.length.should eq 2
     end
   end
 
@@ -167,9 +178,9 @@ describe XPath do
       @results = xpath do |x|
         x.descendant(:*).where(x.attr(:id).starts_with('foo'))
       end
-      @results.size.should == 2
-      @results[0][:id].should == "foo"
-      @results[1][:id].should == "fooDiv"
+      @results.size.should eq 2
+      @results[0][:id].should eq "foo"
+      @results[1][:id].should eq "fooDiv"
     end
 
     it "should find nodes that contain the given expression" do
@@ -177,17 +188,17 @@ describe XPath do
         expression = x.anywhere(:div).where(x.attr(:title) == 'fooDiv').attr(:id)
         x.descendant(:div).where(x.attr(:title).starts_with(expression))
       end
-      @results[0][:id].should == "foo"
+      @results[0][:id].should eq "foo"
     end
   end
 
   describe '#text' do
     it "should select a node's text" do
       @results = xpath { |x| x.descendant(:p).where(x.text == 'Bax') }
-      @results[0].text.should == 'Bax'
-      @results[1][:title].should == 'monkey'
+      @results[0].text.should eq 'Bax'
+      @results[1][:title].should eq 'monkey'
       @results = xpath { |x| x.descendant(:div).where(x.descendant(:p).text == 'Bax') }
-      @results[0][:title].should == 'fooDiv'
+      @results[0][:title].should eq 'fooDiv'
     end
   end
 
@@ -195,14 +206,14 @@ describe XPath do
     context "when called with one argument" do
       it "should select the part of a string after the specified character" do
         @results = xpath { |x| x.descendant(:span).where(x.attr(:id) == "substring").text.substring(7) }
-        @results.should == "there"
+        @results.should eq "there"
       end
     end
 
     context "when called with two arguments" do
       it "should select the part of a string after the specified character, up to the given length" do
         @results = xpath { |x| x.descendant(:span).where(x.attr(:id) == "substring").text.substring(2, 4) }
-        @results.should == "ello"
+        @results.should eq "ello"
       end
     end
   end
@@ -210,63 +221,78 @@ describe XPath do
   describe '#function' do
     it "should call the given xpath function" do
       @results = xpath { |x| x.function(:boolean, x.function(:true) == x.function(:false)) }
-      @results.should == false
+      @results.should eq false
     end
   end
 
   describe '#method' do
     it "should call the given xpath function with the current node as the first argument" do
       @results = xpath { |x| x.descendant(:span).where(x.attr(:id) == "string-length").text.method(:"string-length") }
-      @results.should == 11
+      @results.should eq 11
     end
   end
 
   describe '#string_length' do
     it "should return the length of a string" do
       @results = xpath { |x| x.descendant(:span).where(x.attr(:id) == "string-length").text.string_length }
-      @results.should == 11
+      @results.should eq 11
     end
   end
 
   describe '#where' do
     it "should limit the expression to find only certain nodes" do
-      xpath { |x| x.descendant(:div).where(:"@id = 'foo'") }.first[:title].should == "fooDiv"
+      xpath { |x| x.descendant(:div).where(:"@id = 'foo'") }.first[:title].should eq "fooDiv"
     end
 
     it "should be aliased as []" do
-      xpath { |x| x.descendant(:div)[:"@id = 'foo'"] }.first[:title].should == "fooDiv"
+      xpath { |x| x.descendant(:div)[:"@id = 'foo'"] }.first[:title].should eq "fooDiv"
     end
   end
 
   describe '#inverse' do
     it "should invert the expression" do
-      xpath { |x| x.descendant(:p).where(x.attr(:id).equals('fooDiv').inverse) }.first.text.should == 'Bax'
+      xpath { |x| x.descendant(:p).where(x.attr(:id).equals('fooDiv').inverse) }.first.text.should eq 'Bax'
     end
 
     it "should be aliased as the unary tilde" do
-      xpath { |x| x.descendant(:p).where(~x.attr(:id).equals('fooDiv')) }.first.text.should == 'Bax'
+      xpath { |x| x.descendant(:p).where(~x.attr(:id).equals('fooDiv')) }.first.text.should eq 'Bax'
+    end
+
+    it "should be aliased as the unary bang" do
+      xpath { |x| x.descendant(:p).where(!x.attr(:id).equals('fooDiv')) }.first.text.should eq 'Bax'
     end
   end
 
   describe '#equals' do
     it "should limit the expression to find only certain nodes" do
-      xpath { |x| x.descendant(:div).where(x.attr(:id).equals('foo')) }.first[:title].should == "fooDiv"
+      xpath { |x| x.descendant(:div).where(x.attr(:id).equals('foo')) }.first[:title].should eq "fooDiv"
     end
 
     it "should be aliased as ==" do
-      xpath { |x| x.descendant(:div).where(x.attr(:id) == 'foo') }.first[:title].should == "fooDiv"
+      xpath { |x| x.descendant(:div).where(x.attr(:id) == 'foo') }.first[:title].should eq "fooDiv"
     end
   end
 
+  describe '#not_equals' do
+    it "should match only when not equal" do
+      xpath { |x| x.descendant(:div).where(x.attr(:id).not_equals('bar')) }.first[:title].should eq "fooDiv"
+    end
+
+    it "should be aliased as !=" do
+      xpath { |x| x.descendant(:div).where(x.attr(:id) != 'bar') }.first[:title].should eq "fooDiv"
+    end
+  end
+
+
   describe '#is' do
     it "uses equality when :exact given" do
-      xpath(:exact) { |x| x.descendant(:div).where(x.attr(:id).is('foo')) }.first[:title].should == "fooDiv"
+      xpath(:exact) { |x| x.descendant(:div).where(x.attr(:id).is('foo')) }.first[:title].should eq "fooDiv"
       xpath(:exact) { |x| x.descendant(:div).where(x.attr(:id).is('oo')) }.first.should be_nil
     end
 
     it "uses substring matching otherwise" do
-      xpath { |x| x.descendant(:div).where(x.attr(:id).is('foo')) }.first[:title].should == "fooDiv"
-      xpath { |x| x.descendant(:div).where(x.attr(:id).is('oo')) }.first[:title].should == "fooDiv"
+      xpath { |x| x.descendant(:div).where(x.attr(:id).is('foo')) }.first[:title].should eq "fooDiv"
+      xpath { |x| x.descendant(:div).where(x.attr(:id).is('oo')) }.first[:title].should eq "fooDiv"
     end
   end
 
@@ -276,9 +302,9 @@ describe XPath do
         p = x.anywhere(:div).where(x.attr(:id) == 'foo').attr(:title)
         x.descendant(:*).where(x.attr(:id).one_of('foo', p, 'baz'))
       end
-      @results[0][:title].should == "fooDiv"
-      @results[1].text.should == "Blah"
-      @results[2][:title].should == "bazDiv"
+      @results[0][:title].should eq "fooDiv"
+      @results[1].text.should eq "Blah"
+      @results[2][:title].should eq "bazDiv"
     end
   end
 
@@ -287,14 +313,14 @@ describe XPath do
       @results = xpath do |x|
         x.descendant(:*).where(x.contains('Bax').and(x.attr(:title).equals('monkey')))
       end
-      @results[0][:title].should == "monkey"
+      @results[0][:title].should eq "monkey"
     end
 
     it "should be aliased as ampersand (&)" do
       @results = xpath do |x|
         x.descendant(:*).where(x.contains('Bax') & x.attr(:title).equals('monkey'))
       end
-      @results[0][:title].should == "monkey"
+      @results[0][:title].should eq "monkey"
     end
   end
 
@@ -303,57 +329,57 @@ describe XPath do
       @results = xpath do |x|
         x.descendant(:*).where(x.attr(:id).equals('foo').or(x.attr(:id).equals('fooDiv')))
       end
-      @results[0][:title].should == "fooDiv"
-      @results[1].text.should == "Blah"
+      @results[0][:title].should eq "fooDiv"
+      @results[1].text.should eq "Blah"
     end
 
     it "should be aliased as pipe (|)" do
       @results = xpath do |x|
         x.descendant(:*).where(x.attr(:id).equals('foo') | x.attr(:id).equals('fooDiv'))
       end
-      @results[0][:title].should == "fooDiv"
-      @results[1].text.should == "Blah"
+      @results[0][:title].should eq "fooDiv"
+      @results[1].text.should eq "Blah"
     end
   end
 
   describe '#attr' do
     it "should be an attribute" do
       @results = xpath { |x| x.descendant(:div).where(x.attr(:id)) }
-      @results[0][:title].should == "barDiv"
-      @results[1][:title].should == "fooDiv"
+      @results[0][:title].should eq "barDiv"
+      @results[1][:title].should eq "fooDiv"
     end
   end
 
   describe '#css' do
     it "should find nodes by the given CSS selector" do
       @results = xpath { |x| x.css('#preference p') }
-      @results[0].text.should == 'allamas'
-      @results[1].text.should == 'llama'
+      @results[0].text.should eq 'allamas'
+      @results[1].text.should eq 'llama'
     end
 
     it "should respect previous expression" do
       @results = xpath { |x| x.descendant[x.attr(:id) == 'moar'].css('p') }
-      @results[0].text.should == 'chimp'
-      @results[1].text.should == 'flamingo'
+      @results[0].text.should eq 'chimp'
+      @results[1].text.should eq 'flamingo'
     end
 
     it "should be composable" do
       @results = xpath { |x| x.css('#moar').descendant(:p) }
-      @results[0].text.should == 'chimp'
-      @results[1].text.should == 'flamingo'
+      @results[0].text.should eq 'chimp'
+      @results[1].text.should eq 'flamingo'
     end
 
     it "should allow comma separated selectors" do
       @results = xpath { |x| x.descendant[x.attr(:id) == 'moar'].css('div, p') }
-      @results[0].text.should == 'chimp'
-      @results[1].text.should == 'elephant'
-      @results[2].text.should == 'flamingo'
+      @results[0].text.should eq 'chimp'
+      @results[1].text.should eq 'elephant'
+      @results[2].text.should eq 'flamingo'
     end
   end
 
-  describe '#name' do
+  describe '#qname' do
     it "should match the node's name" do
-      xpath { |x| x.descendant(:*).where(x.name == 'ul') }.first.text.should == "A list"
+      xpath { |x| x.descendant(:*).where(x.qname == 'ul') }.first.text.should eq "A list"
     end
   end
 
@@ -365,9 +391,9 @@ describe XPath do
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
       @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
-      @results[0][:title].should == 'fooDiv'
+      @results[0][:title].should eq 'fooDiv'
       @results = doc.xpath(@xpath2)
-      @results[0][:id].should == 'fooDiv'
+      @results[0][:id].should eq 'fooDiv'
     end
 
     it "should be aliased as +" do
@@ -377,119 +403,119 @@ describe XPath do
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
       @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
-      @results[0][:title].should == 'fooDiv'
+      @results[0][:title].should eq 'fooDiv'
       @results = doc.xpath(@xpath2)
-      @results[0][:id].should == 'fooDiv'
+      @results[0][:id].should eq 'fooDiv'
     end
   end
 
   describe "#last" do
     it "returns the number of elements in the context" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() == XPath.last()] }
-      @results[0].text.should == "Bax"
-      @results[1].text.should == "Blah"
-      @results[2].text.should == "llama"
+      @results[0].text.should eq "Bax"
+      @results[1].text.should eq "Blah"
+      @results[2].text.should eq "llama"
     end
   end
 
   describe "#position" do
     it "returns the position of elements in the context" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() == 2] }
-      @results[0].text.should == "Bax"
-      @results[1].text.should == "Bax"
+      @results[0].text.should eq "Bax"
+      @results[1].text.should eq "Bax"
     end
   end
 
   describe "#count" do
     it "counts the number of occurrences" do
       @results = xpath { |x| x.descendant(:div)[x.descendant(:p).count == 2] }
-      @results[0][:id].should == "preference"
+      @results[0][:id].should eq "preference"
     end
   end
 
   describe "#lte" do
     it "checks lesser than or equal" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() <= 2] }
-      @results[0].text.should == "Blah"
-      @results[1].text.should == "Bax"
-      @results[2][:title].should == "gorilla"
-      @results[3].text.should == "Bax"
+      @results[0].text.should eq "Blah"
+      @results[1].text.should eq "Bax"
+      @results[2][:title].should eq "gorilla"
+      @results[3].text.should eq "Bax"
     end
   end
 
   describe "#lt" do
     it "checks lesser than" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() < 2] }
-      @results[0].text.should == "Blah"
-      @results[1][:title].should == "gorilla"
+      @results[0].text.should eq "Blah"
+      @results[1][:title].should eq "gorilla"
     end
   end
 
   describe "#gte" do
     it "checks greater than or equal" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() >= 2] }
-      @results[0].text.should == "Bax"
-      @results[1][:title].should == "monkey"
-      @results[2].text.should == "Bax"
-      @results[3].text.should == "Blah"
+      @results[0].text.should eq "Bax"
+      @results[1][:title].should eq "monkey"
+      @results[2].text.should eq "Bax"
+      @results[3].text.should eq "Blah"
     end
   end
 
   describe "#gt" do
     it "checks greater than" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() > 2] }
-      @results[0][:title].should == "monkey"
-      @results[1].text.should == "Blah"
+      @results[0][:title].should eq "monkey"
+      @results[1].text.should eq "Blah"
     end
   end
 
   describe "#plus" do
     it "adds stuff" do
       @results = xpath { |x| x.descendant(:p)[XPath.position().plus(1) == 2] }
-      @results[0][:id].should == "fooDiv"
-      @results[1][:title].should == "gorilla"
+      @results[0][:id].should eq "fooDiv"
+      @results[1][:title].should eq "gorilla"
     end
   end
 
   describe "#minus" do
     it "subtracts stuff" do
       @results = xpath { |x| x.descendant(:p)[XPath.position().minus(1) == 0] }
-      @results[0][:id].should == "fooDiv"
-      @results[1][:title].should == "gorilla"
+      @results[0][:id].should eq "fooDiv"
+      @results[1][:title].should eq "gorilla"
     end
   end
 
   describe "#multiply" do
     it "multiplies stuff" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() * 3 == 3] }
-      @results[0][:id].should == "fooDiv"
-      @results[1][:title].should == "gorilla"
+      @results[0][:id].should eq "fooDiv"
+      @results[1][:title].should eq "gorilla"
     end
   end
 
   describe "#divide" do
     it "divides stuff" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() / 2 == 1] }
-      @results[0].text.should == "Bax"
-      @results[1].text.should == "Bax"
+      @results[0].text.should eq "Bax"
+      @results[1].text.should eq "Bax"
     end
   end
 
   describe "#mod" do
     it "take modulo" do
       @results = xpath { |x| x.descendant(:p)[XPath.position() % 2 == 1] }
-      @results[0].text.should == "Blah"
-      @results[1][:title].should == "monkey"
-      @results[2][:title].should == "gorilla"
+      @results[0].text.should eq "Blah"
+      @results[1][:title].should eq "monkey"
+      @results[2][:title].should eq "gorilla"
     end
   end
 
   describe "#ancestor" do
     it "finds ancestor nodes" do
       @results = xpath { |x| x.descendant(:p)[1].ancestor }
-      @results[0].node_name.should == "html"
-      @results[1].node_name.should == "body"
-      @results[2][:id].should == "foo"
+      @results[0].node_name.should eq "html"
+      @results[1].node_name.should eq "body"
+      @results[2][:id].should eq "foo"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xpath
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Jonas Nicklas
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain:
 - gem-public_cert.pem
-date: 2017-05-25 00:00:00.000000000 Z
+date: 2017-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -92,7 +92,6 @@ files:
 - lib/xpath.rb
 - lib/xpath/dsl.rb
 - lib/xpath/expression.rb
-- lib/xpath/html.rb
 - lib/xpath/literal.rb
 - lib/xpath/renderer.rb
 - lib/xpath/union.rb
@@ -100,7 +99,6 @@ files:
 - spec/fixtures/form.html
 - spec/fixtures/simple.html
 - spec/fixtures/stuff.html
-- spec/html_spec.rb
 - spec/spec_helper.rb
 - spec/union_spec.rb
 - spec/xpath_spec.rb
@@ -116,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -124,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Generate XPath expressions from Ruby

data/lib/xpath/html.rb

@@ -1,175 +0,0 @@
-module XPath
-  module HTML
-    include XPath::DSL
-    extend self
-
-    # Match an `a` link element.
-    #
-    # @param [String] locator
-    #   Text, id, title, or image alt attribute of the link
-    #
-    def link(locator)
-      locator = locator.to_s
-      link = descendant(:a)[attr(:href)]
-      link[attr(:id).equals(locator) | string.n.is(locator) | attr(:title).is(locator) | descendant(:img)[attr(:alt).is(locator)]]
-    end
-
-    # Match a `submit`, `image`, or `button` element.
-    #
-    # @param [String] locator
-    #   Value, title, id, or image alt attribute of the button
-    #
-    def button(locator)
-      locator = locator.to_s
-      button = descendant(:input)[attr(:type).one_of('submit', 'reset', 'image', 'button')][attr(:id).equals(locator) | attr(:value).is(locator) | attr(:title).is(locator)]
-      button += descendant(:button)[attr(:id).equals(locator) | attr(:value).is(locator) | string.n.is(locator) | attr(:title).is(locator)]
-      button += descendant(:input)[attr(:type).equals('image')][attr(:alt).is(locator)]
-    end
-
-
-    # Match anything returned by either {#link} or {#button}.
-    #
-    # @param [String] locator
-    #   Text, id, title, or image alt attribute of the link or button
-    #
-    def link_or_button(locator)
-      link(locator) + button(locator)
-    end
-
-
-    # Match any `fieldset` element.
-    #
-    # @param [String] locator
-    #   Legend or id of the fieldset
-    #
-    def fieldset(locator)
-      locator = locator.to_s
-      descendant(:fieldset)[attr(:id).equals(locator) | child(:legend)[string.n.is(locator)]]
-    end
-
-
-    # Match any `input`, `textarea`, or `select` element that doesn't have a
-    # type of `submit`, `image`, or `hidden`.
-    #
-    # @param [String] locator
-    #   Label, id, or name of field to match
-    #
-    def field(locator)
-      locator = locator.to_s
-      xpath = descendant(:input, :textarea, :select)[~attr(:type).one_of('submit', 'image', 'hidden')]
-      xpath = locate_field(xpath, locator)
-      xpath
-    end
-
-
-    # Match any `input` or `textarea` element that can be filled with text.
-    # This excludes any inputs with a type of `submit`, `image`, `radio`,
-    # `checkbox`, `hidden`, or `file`.
-    #
-    # @param [String] locator
-    #   Label, id, or name of field to match
-    #
-    def fillable_field(locator)
-      locator = locator.to_s
-      xpath = descendant(:input, :textarea)[~attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
-      xpath = locate_field(xpath, locator)
-      xpath
-    end
-
-
-    # Match any `select` element.
-    #
-    # @param [String] locator
-    #   Label, id, or name of the field to match
-    #
-    def select(locator)
-      locator = locator.to_s
-      locate_field(descendant(:select), locator)
-    end
-
-
-    # Match any `input` element of type `checkbox`.
-    #
-    # @param [String] locator
-    #   Label, id, or name of the checkbox to match
-    #
-    def checkbox(locator)
-      locator = locator.to_s
-      locate_field(descendant(:input)[attr(:type).equals('checkbox')], locator)
-    end
-
-
-    # Match any `input` element of type `radio`.
-    #
-    # @param [String] locator
-    #   Label, id, or name of the radio button to match
-    #
-    def radio_button(locator)
-      locator = locator.to_s
-      locate_field(descendant(:input)[attr(:type).equals('radio')], locator)
-    end
-
-
-    # Match any `input` element of type `file`.
-    #
-    # @param [String] locator
-    #   Label, id, or name of the file field to match
-    #
-    def file_field(locator)
-      locator = locator.to_s
-      locate_field(descendant(:input)[attr(:type).equals('file')], locator)
-    end
-
-
-    # Match an `optgroup` element.
-    #
-    # @param [String] name
-    #   Label for the option group
-    #
-    def optgroup(locator)
-      locator = locator.to_s
-      descendant(:optgroup)[attr(:label).is(locator)]
-    end
-
-
-    # Match an `option` element.
-    #
-    # @param [String] name
-    #   Visible text of the option
-    #
-    def option(locator)
-      locator = locator.to_s
-      descendant(:option)[string.n.is(locator)]
-    end
-
-
-    # Match any `table` element.
-    #
-    # @param [String] locator
-    #   Caption or id of the table to match
-    # @option options [Array] :rows
-    #   Content of each cell in each row to match
-    #
-    def table(locator)
-      locator = locator.to_s
-      descendant(:table)[attr(:id).equals(locator) | descendant(:caption).is(locator)]
-    end
-
-    # Match any 'dd' element.
-    #
-    # @param [String] locator
-    #   Id of the 'dd' element or text from preciding 'dt' element content
-    def definition_description(locator)
-      locator = locator.to_s
-      descendant(:dd)[attr(:id).equals(locator) | previous_sibling(:dt)[string.n.equals(locator)] ]
-    end
-
-  protected
-
-    def locate_field(xpath, locator)
-      locate_field = xpath[attr(:id).equals(locator) | attr(:name).equals(locator) | attr(:placeholder).equals(locator) | attr(:id).equals(anywhere(:label)[string.n.is(locator)].attr(:for))]
-      locate_field += descendant(:label)[string.n.is(locator)].descendant(xpath)
-      locate_field
-    end
-  end
-end

data/spec/html_spec.rb

@@ -1,308 +0,0 @@
-require 'spec_helper'
-require 'nokogiri'
-
-describe XPath::HTML do
-  let(:template) { 'form' }
-  let(:template_path) { File.read(File.expand_path("fixtures/#{template}.html", File.dirname(__FILE__))) }
-  let(:doc) { Nokogiri::HTML(template_path) }
-  let(:type) { |example| example.metadata[:type] }
-
-  def get(*args)
-    all(*args).first
-  end
-
-  def all(*args)
-    doc.xpath(XPath::HTML.send(subject, *args).to_xpath(type)).map { |node| node[:data] }
-  end
-
-  describe '#link' do
-    subject { :link }
-
-    it("finds links by id")                                { get('some-id').should == 'link-id' }
-    it("finds links by content")                           { get('An awesome link').should == 'link-text' }
-    it("finds links by content regardless of whitespace")  { get('My whitespaced link').should == 'link-whitespace' }
-    it("finds links with child tags by content")           { get('An emphatic link').should == 'link-children' }
-    it("finds links by the content of their child tags")   { get('emphatic').should == 'link-children' }
-    it("finds links by approximate content")               { get('awesome').should == 'link-text' }
-    it("finds links by title")                             { get('My title').should == 'link-title' }
-    it("finds links by approximate title")                 { get('title').should == 'link-title' }
-    it("finds links by image's alt attribute")             { get('Alt link').should == 'link-img' }
-    it("finds links by image's approximate alt attribute") { get('Alt').should == 'link-img' }
-    it("does not find links without href attriutes")       { get('Wrong Link').should be_nil }
-    it("casts to string")                                  { get(:'some-id').should == 'link-id' }
-
-    context "with exact match", :type => :exact do
-      it("finds links by content")                                   { get('An awesome link').should == 'link-text' }
-      it("does not find links by approximate content")               { get('awesome').should be_nil }
-      it("finds links by title")                                     { get('My title').should == 'link-title' }
-      it("does not find links by approximate title")                 { get('title').should be_nil }
-      it("finds links by image's alt attribute")                     { get('Alt link').should == 'link-img' }
-      it("does not find links by image's approximate alt attribute") { get('Alt').should be_nil }
-    end
-  end
-
-  describe '#button' do
-    subject { :button }
-
-    context "with submit type" do
-      it("finds buttons by id")                { get('submit-with-id').should == 'id-submit' }
-      it("finds buttons by value")             { get('submit-with-value').should == 'value-submit' }
-      it("finds buttons by approximate value") { get('mit-with-val').should == 'value-submit' }
-      it("finds buttons by title")             { get('My submit title').should == 'title-submit' }
-      it("finds buttons by approximate title") { get('submit title').should == 'title-submit' }
-
-      context "with exact match", :type => :exact do
-        it("finds buttons by value")                     { get('submit-with-value').should == 'value-submit' }
-        it("does not find buttons by approximate value") { get('mit-with-val').should be_nil }
-        it("finds buttons by title")                     { get('My submit title').should == 'title-submit' }
-        it("does not find buttons by approximate title") { get('submit title').should be_nil }
-      end
-    end
-
-    context "with reset type" do
-      it("finds buttons by id")                { get('reset-with-id').should == 'id-reset' }
-      it("finds buttons by value")             { get('reset-with-value').should == 'value-reset' }
-      it("finds buttons by approximate value") { get('set-with-val').should == 'value-reset' }
-      it("finds buttons by title")             { get('My reset title').should == 'title-reset' }
-      it("finds buttons by approximate title") { get('reset title').should == 'title-reset' }
-
-      context "with exact match", :type => :exact do
-        it("finds buttons by value")                     { get('reset-with-value').should == 'value-reset' }
-        it("does not find buttons by approximate value") { get('set-with-val').should be_nil }
-        it("finds buttons by title")                     { get('My reset title').should == 'title-reset' }
-        it("does not find buttons by approximate title") { get('reset title').should be_nil }
-      end
-    end
-
-    context "with button type" do
-      it("finds buttons by id")                { get('button-with-id').should == 'id-button' }
-      it("finds buttons by value")             { get('button-with-value').should == 'value-button' }
-      it("finds buttons by approximate value") { get('ton-with-val').should == 'value-button' }
-      it("finds buttons by title")             { get('My button title').should == 'title-button' }
-      it("finds buttons by approximate title") { get('button title').should == 'title-button' }
-
-      context "with exact match", :type => :exact do
-        it("finds buttons by value")                     { get('button-with-value').should == 'value-button' }
-        it("does not find buttons by approximate value") { get('ton-with-val').should be_nil }
-        it("finds buttons by title")                     { get('My button title').should == 'title-button' }
-        it("does not find buttons by approximate title") { get('button title').should be_nil }
-      end
-    end
-
-    context "with image type" do
-      it("finds buttons by id")                        { get('imgbut-with-id').should == 'id-imgbut' }
-      it("finds buttons by value")                     { get('imgbut-with-value').should == 'value-imgbut' }
-      it("finds buttons by approximate value")         { get('gbut-with-val').should == 'value-imgbut' }
-      it("finds buttons by alt attribute")             { get('imgbut-with-alt').should == 'alt-imgbut' }
-      it("finds buttons by approximate alt attribute") { get('mgbut-with-al').should == 'alt-imgbut' }
-      it("finds buttons by title")                     { get('My imgbut title').should == 'title-imgbut' }
-      it("finds buttons by approximate title")         { get('imgbut title').should == 'title-imgbut' }
-
-      context "with exact match", :type => :exact do
-        it("finds buttons by value")                             { get('imgbut-with-value').should == 'value-imgbut' }
-        it("does not find buttons by approximate value")         { get('gbut-with-val').should be_nil }
-        it("finds buttons by alt attribute")                     { get('imgbut-with-alt').should == 'alt-imgbut' }
-        it("does not find buttons by approximate alt attribute") { get('mgbut-with-al').should be_nil }
-        it("finds buttons by title")                             { get('My imgbut title').should == 'title-imgbut' }
-        it("does not find buttons by approximate title")         { get('imgbut title').should be_nil }
-      end
-    end
-
-    context "with button tag" do
-      it("finds buttons by id")                       { get('btag-with-id').should == 'id-btag' }
-      it("finds buttons by value")                    { get('btag-with-value').should == 'value-btag' }
-      it("finds buttons by approximate value")        { get('tag-with-val').should == 'value-btag' }
-      it("finds buttons by text")                     { get('btag-with-text').should == 'text-btag' }
-      it("finds buttons by text ignoring whitespace") { get('My whitespaced button').should == 'btag-with-whitespace' }
-      it("finds buttons by approximate text ")        { get('tag-with-tex').should == 'text-btag' }
-      it("finds buttons with child tags by text")     { get('An emphatic button').should == 'btag-with-children' }
-      it("finds buttons by text of their children")   { get('emphatic').should == 'btag-with-children' }
-      it("finds buttons by title")                    { get('My btag title').should == 'title-btag' }
-      it("finds buttons by approximate title")        { get('btag title').should == 'title-btag' }
-
-      context "with exact match", :type => :exact do
-        it("finds buttons by value")                     { get('btag-with-value').should == 'value-btag' }
-        it("does not find buttons by approximate value") { get('tag-with-val').should be_nil }
-        it("finds buttons by text")                      { get('btag-with-text').should == 'text-btag' }
-        it("does not find buttons by approximate text ") { get('tag-with-tex').should be_nil }
-        it("finds buttons by title")                     { get('My btag title').should == 'title-btag' }
-        it("does not find buttons by approximate title") { get('btag title').should be_nil }
-      end
-    end
-
-    context "with unkown type" do
-      it("does not find the button") { get('schmoo button').should be_nil }
-    end
-
-    it("casts to string") { get(:'tag-with-tex').should == 'text-btag' }
-  end
-
-  describe '#fieldset' do
-    subject { :fieldset }
-
-    it("finds fieldsets by id")                  { get('some-fieldset-id').should == 'fieldset-id' }
-    it("finds fieldsets by legend")              { get('Some Legend').should == 'fieldset-legend' }
-    it("finds fieldsets by legend child tags")   { get('Span Legend').should == 'fieldset-legend-span' }
-    it("accepts approximate legends")            { get('Legend').should == 'fieldset-legend' }
-    it("finds nested fieldsets by legend")       { get('Inner legend').should == 'fieldset-inner' }
-    it("casts to string")                        { get(:'Inner legend').should == 'fieldset-inner' }
-
-    context "with exact match", :type => :exact do
-      it("finds fieldsets by legend")            { get('Some Legend').should == 'fieldset-legend' }
-      it("does not find by approximate legends") { get('Legend').should be_nil }
-    end
-  end
-
-  describe '#field' do
-    subject { :field }
-
-    context "by id" do
-      it("finds inputs with no type")       { get('input-with-id').should == 'input-with-id-data' }
-      it("finds inputs with text type")     { get('input-text-with-id').should == 'input-text-with-id-data' }
-      it("finds inputs with password type") { get('input-password-with-id').should == 'input-password-with-id-data' }
-      it("finds inputs with custom type")   { get('input-custom-with-id').should == 'input-custom-with-id-data' }
-      it("finds textareas")                 { get('textarea-with-id').should == 'textarea-with-id-data' }
-      it("finds select boxes")              { get('select-with-id').should == 'select-with-id-data' }
-      it("does not find submit buttons")    { get('input-submit-with-id').should be_nil }
-      it("does not find image buttons")     { get('input-image-with-id').should be_nil }
-      it("does not find hidden fields")     { get('input-hidden-with-id').should be_nil }
-    end
-
-    context "by name" do
-      it("finds inputs with no type")       { get('input-with-name').should == 'input-with-name-data' }
-      it("finds inputs with text type")     { get('input-text-with-name').should == 'input-text-with-name-data' }
-      it("finds inputs with password type") { get('input-password-with-name').should == 'input-password-with-name-data' }
-      it("finds inputs with custom type")   { get('input-custom-with-name').should == 'input-custom-with-name-data' }
-      it("finds textareas")                 { get('textarea-with-name').should == 'textarea-with-name-data' }
-      it("finds select boxes")              { get('select-with-name').should == 'select-with-name-data' }
-      it("does not find submit buttons")    { get('input-submit-with-name').should be_nil }
-      it("does not find image buttons")     { get('input-image-with-name').should be_nil }
-      it("does not find hidden fields")     { get('input-hidden-with-name').should be_nil }
-    end
-
-    context "by placeholder" do
-      it("finds inputs with no type")       { get('input-with-placeholder').should == 'input-with-placeholder-data' }
-      it("finds inputs with text type")     { get('input-text-with-placeholder').should == 'input-text-with-placeholder-data' }
-      it("finds inputs with password type") { get('input-password-with-placeholder').should == 'input-password-with-placeholder-data' }
-      it("finds inputs with custom type")   { get('input-custom-with-placeholder').should == 'input-custom-with-placeholder-data' }
-      it("finds textareas")                 { get('textarea-with-placeholder').should == 'textarea-with-placeholder-data' }
-      it("does not find hidden fields")     { get('input-hidden-with-placeholder').should be_nil }
-    end
-
-    context "by referenced label" do
-      it("finds inputs with no type")       { get('Input with label').should == 'input-with-label-data' }
-      it("finds inputs with text type")     { get('Input text with label').should == 'input-text-with-label-data' }
-      it("finds inputs with password type") { get('Input password with label').should == 'input-password-with-label-data' }
-      it("finds inputs with custom type")   { get('Input custom with label').should == 'input-custom-with-label-data' }
-      it("finds textareas")                 { get('Textarea with label').should == 'textarea-with-label-data' }
-      it("finds select boxes")              { get('Select with label').should == 'select-with-label-data' }
-      it("does not find submit buttons")    { get('Input submit with label').should be_nil }
-      it("does not find image buttons")     { get('Input image with label').should be_nil }
-      it("does not find hidden fields")     { get('Input hidden with label').should be_nil }
-    end
-
-    context "by parent label" do
-      it("finds inputs with no type")       { get('Input with parent label').should == 'input-with-parent-label-data' }
-      it("finds inputs with text type")     { get('Input text with parent label').should == 'input-text-with-parent-label-data' }
-      it("finds inputs with password type") { get('Input password with parent label').should == 'input-password-with-parent-label-data' }
-      it("finds inputs with custom type")   { get('Input custom with parent label').should == 'input-custom-with-parent-label-data' }
-      it("finds textareas")                 { get('Textarea with parent label').should == 'textarea-with-parent-label-data' }
-      it("finds select boxes")              { get('Select with parent label').should == 'select-with-parent-label-data' }
-      it("does not find submit buttons")    { get('Input submit with parent label').should be_nil }
-      it("does not find image buttons")     { get('Input image with parent label').should be_nil }
-      it("does not find hidden fields")     { get('Input hidden with parent label').should be_nil }
-    end
-
-    it("casts to string") { get(:'select-with-id').should == 'select-with-id-data' }
-  end
-
-  describe '#fillable_field' do
-    subject{ :fillable_field }
-    context "by parent label" do
-      it("finds inputs with text type")                    { get('Label text').should == 'id-text' }
-      it("finds inputs where label has problem chars")     { get("Label text's got an apostrophe").should == 'id-problem-text' }
-    end
-
-  end
-
-  describe '#select' do
-    subject{ :select }
-    it("finds selects by id")             { get('select-with-id').should == 'select-with-id-data' }
-    it("finds selects by name")           { get('select-with-name').should == 'select-with-name-data' }
-    it("finds selects by label")          { get('Select with label').should == 'select-with-label-data' }
-    it("finds selects by parent label")   { get('Select with parent label').should == 'select-with-parent-label-data' }
-    it("casts to string")                 { get(:'Select with parent label').should == 'select-with-parent-label-data' }
-  end
-
-  describe '#checkbox' do
-    subject{ :checkbox }
-    it("finds checkboxes by id")           { get('input-checkbox-with-id').should == 'input-checkbox-with-id-data' }
-    it("finds checkboxes by name")         { get('input-checkbox-with-name').should == 'input-checkbox-with-name-data' }
-    it("finds checkboxes by label")        { get('Input checkbox with label').should == 'input-checkbox-with-label-data' }
-    it("finds checkboxes by parent label") { get('Input checkbox with parent label').should == 'input-checkbox-with-parent-label-data' }
-    it("casts to string")                  { get(:'Input checkbox with parent label').should == 'input-checkbox-with-parent-label-data' }
-  end
-
-  describe '#radio_button' do
-    subject{ :radio_button }
-    it("finds radio buttons by id")           { get('input-radio-with-id').should == 'input-radio-with-id-data' }
-    it("finds radio buttons by name")         { get('input-radio-with-name').should == 'input-radio-with-name-data' }
-    it("finds radio buttons by label")        { get('Input radio with label').should == 'input-radio-with-label-data' }
-    it("finds radio buttons by parent label") { get('Input radio with parent label').should == 'input-radio-with-parent-label-data' }
-    it("casts to string")                     { get(:'Input radio with parent label').should == 'input-radio-with-parent-label-data' }
-  end
-
-  describe '#file_field' do
-    subject{ :file_field }
-    it("finds file fields by id")           { get('input-file-with-id').should == 'input-file-with-id-data' }
-    it("finds file fields by name")         { get('input-file-with-name').should == 'input-file-with-name-data' }
-    it("finds file fields by label")        { get('Input file with label').should == 'input-file-with-label-data' }
-    it("finds file fields by parent label") { get('Input file with parent label').should == 'input-file-with-parent-label-data' }
-    it("casts to string")                   { get(:'Input file with parent label').should == 'input-file-with-parent-label-data' }
-  end
-
-  describe "#optgroup" do
-    subject { :optgroup }
-    it("finds optgroups by label")             { get('Group A').should == 'optgroup-a' }
-    it("finds optgroups by approximate label") { get('oup A').should == 'optgroup-a' }
-    it("casts to string")                      { get(:'Group A').should == 'optgroup-a' }
-
-    context "with exact match", :type => :exact do
-      it("finds by label")                     { get('Group A').should == 'optgroup-a' }
-      it("does not find by approximate label") { get('oup A').should be_nil }
-    end
-  end
-
-  describe '#option' do
-    subject{ :option }
-    it("finds by text")             { get('Option with text').should == 'option-with-text-data' }
-    it("finds by approximate text") { get('Option with').should == 'option-with-text-data' }
-    it("casts to string")           { get(:'Option with text').should == 'option-with-text-data' }
-
-    context "with exact match", :type => :exact do
-      it("finds by text")                     { get('Option with text').should == 'option-with-text-data' }
-      it("does not find by approximate text") { get('Option with').should be_nil }
-    end
-  end
-
-  describe "#table" do
-    subject {:table}
-    it("finds by id")                  { get('table-with-id').should == 'table-with-id-data' }
-    it("finds by caption")             { get('Table with caption').should == 'table-with-caption-data' }
-    it("finds by approximate caption") { get('Table with').should == 'table-with-caption-data' }
-    it("casts to string")              { get(:'Table with caption').should == 'table-with-caption-data' }
-
-    context "with exact match", :type => :exact do
-      it("finds by caption")                     { get('Table with caption').should == 'table-with-caption-data' }
-      it("does not find by approximate caption") { get('Table with').should be_nil }
-    end
-  end
-
-  describe "#definition_description" do
-    subject {:definition_description}
-    let(:template) {'stuff'}
-    it("find definition description by id")   { get('latte').should == "with-id" }
-    it("find definition description by term") { get("Milk").should == "with-dt" }
-    it("casts to string")                     { get(:"Milk").should == "with-dt" }
-  end
-end