xpath 0.1.4 → 1.0.0.beta1

data/spec/html_spec.rb

@@ -11,9 +11,7 @@ describe XPath::HTML do
   end
 
   def all(*args)
-    XPath::HTML.send(subject, *args).to_xpaths.map do |xpath|
-      doc.xpath(xpath)
-    end.flatten.uniq.map { |node| node[:data] }
+    doc.xpath(XPath::HTML.send(subject, *args).to_s).map { |node| node[:data] }
   end
 
   describe '#link' do
@@ -25,16 +23,11 @@ describe XPath::HTML do
     it("finds links with child tags by content")           { get('An emphatic link').should == 'link-children' }
     it("finds links by the content of theur child tags")   { get('emphatic').should == 'link-children' }
     it("finds links by approximate content")               { get('awesome').should == 'link-text' }
-    it("prefers exact matches of content")                 { all('A link').should == ['link-exact', 'link-fuzzy'] }
     it("finds links by title")                             { get('My title').should == 'link-title' }
     it("finds links by approximate title")                 { get('title').should == 'link-title' }
-    it("prefers exact matches of title")                   { all('This title').should == ['link-exact', 'link-fuzzy'] }
     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("prefers exact matches of image's alt attribute")   { all('An image').should == ['link-img-exact', 'link-img-fuzzy'] }
     it("does not find links without href attriutes")       { get('Wrong Link').should be_nil }
-    it("finds links with an href")                         { get("Href-ed link", :href => 'http://www.example.com').should == 'link-href' }
-    it("does not find links with an incorrect href")       { get("Href-ed link", :href => 'http://www.somewhere.com').should be_nil }
   end
 
   describe '#button' do
@@ -44,20 +37,24 @@ describe XPath::HTML 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("prefers buttons with exact value")   { all('exact value submit').should == ['exact-value-submit', 'not-exact-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' }
-      it("prefers exact matches of title")     { all('Exact submit title').should == ['exact-title-submit', 'not-exact-title-submit'] }
+    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' }
     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("prefers buttons with exact value")   { all('exact value button').should == ['exact-value-button', 'not-exact-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' }
-      it("prefers exact matches of title")     { all('Exact button title').should == ['exact-title-button', 'not-exact-title-button'] }
     end
 
     context "with image type" do
@@ -65,26 +62,21 @@ describe XPath::HTML do
       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("prefers buttons with exact value")   { all('exact value imgbut').should == ['exact-value-imgbut', 'not-exact-value-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' }
-      it("prefers exact matches of title")     { all('Exact imgbut title').should == ['exact-title-imgbut', 'not-exact-title-imgbut'] }
     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 prefers buttons with exact value")    { all('exact value btag').should == ['exact-value-btag', 'not-exact-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("prefers buttons with exact text")           { all('exact text btag').should == ['exact-text-btag', 'not-exact-text-btag'] }
       it("finds buttons by title")                    { get('My btag title').should == 'title-btag' }
       it("finds buttons by approximate title")        { get('btag title').should == 'title-btag' }
-      it("prefers exact matches of title")            { all('Exact btag title').should == ['exact-title-btag', 'not-exact-title-btag'] }
     end
 
     context "with unkown type" do
@@ -99,7 +91,7 @@ describe XPath::HTML do
     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("prefers exact legend")                   { all('Long legend').should == ['fieldset-exact', 'fieldset-fuzzy'] }
+    it("finds nested fieldsets by legend")       { get('Inner legend').should == 'fieldset-inner' }
   end
 
   describe '#field' do
@@ -129,6 +121,15 @@ describe XPath::HTML do
       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' }
@@ -152,28 +153,6 @@ describe XPath::HTML do
       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
-
-    context "with :with option" do
-      it("finds inputs that match option")          { get('input-with-id', :with => 'correct-value').should == 'input-with-id-data' }
-      it("omits inputs that don't match option")    { get('input-with-id', :with => 'wrong-value').should be_nil }
-      it("finds textareas that match option")       { get('textarea-with-id', :with => 'Correct value').should == 'textarea-with-id-data' }
-      it("omits textareas that don't match option") { get('textarea-with-id', :with => 'Wrong value').should be_nil }
-    end
-
-    context "with :checked option" do
-      context "when true" do
-        it("finds checked fields")   {}
-        it("omits unchecked fields") {}
-      end
-      context "when false" do
-        it("finds unchecked fields") {}
-        it("omits checked fields")   {}
-      end
-      context "when ommitted" do
-        it("finds unchecked fields") {}
-        it("finds checked fields")   {}
-      end
-    end
   end
 
   describe '#fillable_field' do
@@ -186,34 +165,53 @@ describe XPath::HTML do
   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' }
   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' }
   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' }
 
   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' }
   end
 
   describe '#option' do
-
+    subject{ :option }
+    it("finds options by text") { get('Option with text').should == 'option-with-text-data' }
+    it("does not find option by partial text") { get('Option with').should be_nil }
   end
 
   describe "#optgroup" do
     subject { :optgroup }
-
     it("finds optgroups by label") { get('Group A').should == 'optgroup-a' }
   end
 
   describe "#table" do
     subject {:table}
-
-    it("finds cell content regardless of whitespace") {get('whitespaced-table', :rows => [["I have nested whitespace", "I don't"]]).should == 'table-with-whitespace'}
+    it("finds tables by id") { get('table-with-id').should == 'table-with-id-data' }
+    it("finds tables by caption") { get('Table with caption').should == 'table-with-caption-data' }
   end
+
 end

data/spec/union_spec.rb

@@ -6,8 +6,8 @@ describe XPath::Union do
 
   describe '#expressions' do
     it "should return the expressions" do
-      @expr1 = XPath.generate { |x| x.descendant(:p) } 
-      @expr2 = XPath.generate { |x| x.descendant(:div) } 
+      @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]
     end
@@ -15,8 +15,8 @@ describe XPath::Union do
 
   describe '#each' do
     it "should iterate through the expressions" do
-      @expr1 = XPath.generate { |x| x.descendant(:p) } 
-      @expr2 = XPath.generate { |x| x.descendant(:div) } 
+      @expr1 = XPath.generate { |x| x.descendant(:p) }
+      @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = XPath::Union.new(@expr1, @expr2)
       exprs = []
       @collection.each { |expr| exprs << expr }
@@ -26,17 +26,17 @@ describe XPath::Union do
 
   describe '#map' do
     it "should map the expressions" do
-      @expr1 = XPath.generate { |x| x.descendant(:p) } 
-      @expr2 = XPath.generate { |x| x.descendant(:div) } 
+      @expr1 = XPath.generate { |x| x.descendant(:p) }
+      @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = XPath::Union.new(@expr1, @expr2)
-      @collection.map { |expr| expr.class }.should == [XPath::Expression::Descendant, XPath::Expression::Descendant]
+      @collection.map { |expr| expr.expression }.should == [:descendant, :descendant]
     end
   end
 
   describe '#to_xpath' do
     it "should create a valid xpath expression" do
-      @expr1 = XPath.generate { |x| x.descendant(:p) } 
-      @expr2 = XPath.generate { |x| x.descendant(:div).where(x.attr(:id) == 'foo') } 
+      @expr1 = XPath.generate { |x| x.descendant(:p) }
+      @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'
@@ -45,13 +45,14 @@ describe XPath::Union do
     end
   end
 
-  describe '#where, #apply and others' do
+
+  describe '#where and others' do
     it "should be delegated to the individual expressions" do
-      @expr1 = XPath.generate { |x| x.descendant(:p) } 
-      @expr2 = XPath.generate { |x| x.descendant(:div) } 
+      @expr1 = XPath.generate { |x| x.descendant(:p) }
+      @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = XPath::Union.new(@expr1, @expr2)
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
-      @xpath2 = @collection.where(XPath.attr(:id) == XPath.varstring(:id)).apply(:id => 'fooDiv').to_xpath
+      @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
       @results[0][:title].should == 'fooDiv'
       @results = doc.xpath(@xpath2)

data/spec/xpath_spec.rb

@@ -14,8 +14,8 @@ describe XPath do
   let(:template) { File.read(File.expand_path('fixtures/simple.html', File.dirname(__FILE__))) }
   let(:doc) { Nokogiri::HTML(template) }
 
-  def xpath(predicate=nil, &block)
-    doc.xpath XPath.generate(&block).to_xpath(predicate)
+  def xpath(&block)
+    doc.xpath XPath.generate(&block).to_xpath
   end
 
   it "should work as a mixin" do
@@ -76,6 +76,18 @@ describe XPath do
     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"
+    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"
+    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'
@@ -96,14 +108,6 @@ describe XPath do
     end
   end
 
-  describe '#tag' do
-    it "should filter elements by tag" do
-      @results = xpath { |x| x.descendant[x.tag(:p) | x.tag(:li)] }
-      @results[0].text.should == 'Blah'
-      @results[3].text.should == 'A list'
-    end
-  end
-
   describe '#contains' do
     it "should find nodes that contain the given string" do
       @results = xpath do |x|
@@ -121,6 +125,25 @@ describe XPath do
     end
   end
 
+  describe '#starts_with' do
+    it "should find nodes that begin with the given string" 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"
+    end
+
+    it "should find nodes that contain the given expression" do
+      @results = xpath do |x|
+        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"
+    end
+  end
+
   describe '#text' do
     it "should select a node's text" do
       @results = xpath { |x| x.descendant(:p).where(x.text == 'Bax') }
@@ -161,35 +184,6 @@ describe XPath do
     end
   end
 
-  describe '#is' do
-    it "should limit the expression to only nodes that contain the given expression" do
-      @results = xpath { |x| x.descendant(:p).where(x.text.is('llama')) }
-      @results[0][:id].should == 'is-fuzzy'
-      @results[1][:id].should == 'is-exact'
-    end
-
-    it "should limit the expression to only nodes that contain the given expression if fuzzy predicate given" do
-      @results = xpath(:fuzzy) { |x| x.descendant(:p).where(x.text.is('llama')) }
-      @results[0][:id].should == 'is-fuzzy'
-      @results[1][:id].should == 'is-exact'
-    end
-
-    it "should limit the expression to only nodes that equal the given expression if exact predicate given" do
-      @results = xpath(:exact) { |x| x.descendant(:p).where(x.text.is('llama')) }
-      @results[0][:id].should == 'is-exact'
-      @results[1].should be_nil
-    end
-
-    context "with to_xpaths" do
-      it "should prefer exact matches" do
-        @xpath = XPath.generate { |x| x.descendant(:p).where(x.text.is('llama')) }
-        @results = @xpath.to_xpaths.map { |path| doc.xpath(path) }.flatten
-        @results[0][:id].should == 'is-exact'
-        @results[1][:id].should == 'is-fuzzy'
-      end
-    end
-  end
-
   describe '#one_of' do
     it "should return all nodes where the condition matches" do
       @results = xpath do |x|
@@ -242,14 +236,6 @@ describe XPath do
       @results[0][:title].should == "barDiv"
       @results[1][:title].should == "fooDiv"
     end
-
-    it "should be closed" do
-      @results = xpath do |x|
-        foo_div = x.anywhere(:div).where(x.attr(:id) == 'foo')
-        id = x.attr(foo_div.attr(:data))
-        x.descendant(:div).where(id == 'bar')
-      end.first[:title].should == "barDiv"
-    end
   end
 
   describe '#css' do
@@ -285,52 +271,13 @@ describe XPath do
     end
   end
 
-  describe '#apply and #var' do
-    it "should interpolate variables in the xpath expression" do
-      @xpath = XPath.generate do |x|
-        exp = x.descendant(:*).where(x.attr(:id) == x.var(:id).string_literal)
-      end
-      @result1 = doc.xpath(@xpath.apply(:id => 'foo').to_xpath).first
-      @result1[:title].should == 'fooDiv'
-      @result2 = doc.xpath(@xpath.apply(:id => 'baz').to_xpath).first
-      @result2[:title].should == 'bazDiv'
-    end
-
-    it "should raise an argument error if the interpolation key is not given" do
-      @xpath = XPath.generate { |x| x.descendant(:*).where(x.attr(:id) == x.var(:id).string_literal) }
-      if defined?(KeyError)
-        lambda { @xpath.apply.to_xpath }.should raise_error(KeyError)
-      else
-        lambda { @xpath.apply.to_xpath }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#varstring' do
-    it "should add a literal string variable" do
-      @xpath = XPath.generate { |x| x.descendant(:*).where(x.attr(:id) == x.varstring(:id)) }
-      @result1 = doc.xpath(@xpath.apply(:id => 'foo').to_xpath).first
-      @result1[:title].should == 'fooDiv'
-    end
-  end
-
-  describe '#normalize' do
-    it "should normalize whitespace" do
-      xpath { |x| x.descendant(:p).where(x.text.normalize == 'A lot of whitespace') }.first[:id].should == "whitespace"
-    end
-
-    it "should be aliased as 'n'" do
-      xpath { |x| x.descendant(:p).where(x.text.n == 'A lot of whitespace') }.first[:id].should == "whitespace"
-    end
-  end
-
   describe '#union' do
     it "should create a union expression" do
       @expr1 = XPath.generate { |x| x.descendant(:p) }
       @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = @expr1.union(@expr2)
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
-      @xpath2 = @collection.where(XPath.attr(:id) == XPath.varstring(:id)).apply(:id => 'fooDiv').to_xpath
+      @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
       @results[0][:title].should == 'fooDiv'
       @results = doc.xpath(@xpath2)
@@ -342,7 +289,7 @@ describe XPath do
       @expr2 = XPath.generate { |x| x.descendant(:div) }
       @collection = @expr1 + @expr2
       @xpath1 = @collection.where(XPath.attr(:id) == 'foo').to_xpath
-      @xpath2 = @collection.where(XPath.attr(:id) == XPath.varstring(:id)).apply(:id => 'fooDiv').to_xpath
+      @xpath2 = @collection.where(XPath.attr(:id) == 'fooDiv').to_xpath
       @results = doc.xpath(@xpath1)
       @results[0][:title].should == 'fooDiv'
       @results = doc.xpath(@xpath2)

metadata

@@ -1,77 +1,93 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: xpath
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 4
-  version: 0.1.4
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta1
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Jonas Nicklas
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-25 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: nokogiri
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 3
-        version: "1.3"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
-        version: "2.0"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
   name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 8
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.5.8
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: XPath is a Ruby DSL for generating XPath expressions
-email: 
+email:
 - jonas.nicklas@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
+- lib/xpath/dsl.rb
 - lib/xpath/expression.rb
 - lib/xpath/html.rb
+- lib/xpath/literal.rb
+- lib/xpath/renderer.rb
 - lib/xpath/union.rb
 - lib/xpath/version.rb
 - lib/xpath.rb
@@ -83,38 +99,31 @@ files:
 - spec/union_spec.rb
 - spec/xpath_spec.rb
 - README.rdoc
-has_rdoc: true
 homepage: http://github.com/jnicklas/xpath
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: xpath
-rubygems_version: 1.3.7
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Generate XPath expressions from Ruby
 test_files: []
-
+has_rdoc: