xpath 2.0.0 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce787a09ca48f5c96580cbced2533d00b741a0e3
+  data.tar.gz: c4310006453b0029c593077b225d36e79dfd35af
+SHA512:
+  metadata.gz: 83b64861c13aecd52661c7cbc598f90c4a17aeb71c86936f0bec36d97ffe4248fc8302cad434742b95074b6aded1de563c33a3f82df12e4baf42d10c42d132ac
+  data.tar.gz: bc2e7c29f1240475904601bc7f8ad2ecda2978536b97e1ab407bc855ec16b7f64b48cc49400a501833bb8ac643bcc8b1e2052d4a05974c3df7ca0355ac26fe4e

data/README.md

@@ -3,7 +3,8 @@
 XPath is a Ruby DSL around a subset of XPath 1.0. Its primary purpose is to
 facilitate writing complex XPath queries from Ruby code.
 
-[![Build Status](https://secure.travis-ci.org/jnicklas/xpath.png?branch=master)](http://travis-ci.org/jnicklas/xpath)
+[![Gem Version](https://badge.fury.io/rb/xpath.png)](http://badge.fury.io/rb/xpath)
+[![Build Status](https://secure.travis-ci.org/teamcapybara/xpath.png?branch=master)](http://travis-ci.org/teamcapybara/xpath)
 
 ## Generating expressions
 
@@ -36,11 +37,9 @@ module MyXPaths
 end
 ```
 
-Both ways return an
-[`XPath::Expression`](http://rdoc.info/github/jnicklas/xpath/XPath/Expression)
-instance, which can be further modified.  To convert the expression to a
-string, just call `#to_s` on it. All available expressions are defined in
-[`XPath::DSL`](http://rdoc.info/github/jnicklas/xpath/XPath/DSL).
+Both ways return an `XPath::Expression` instance, which can be further
+modified. To convert the expression to a string, just call `#to_s` on it. All
+available expressions are defined in `XPath::DSL`.
 
 ## String, Hashes and Symbols
 
@@ -74,63 +73,6 @@ XPath.descendant(:p)[1]
 Keep in mind that XPath is 1-indexed and not 0-indexed like most other
 programming languages, including Ruby.
 
-Hashes are automatically converted to equality expressions, so the above
-example could be written as:
-
-``` ruby
-XPath.descendant(:p)[:@id => 'foo']
-```
-
-Which would generate the same expression:
-
-```
-.//p[@id = 'foo']
-```
-
-Note that the same rules apply here, both the keys and values in the hash are
-treated the same way as any other expression in XPath. Thus the following are
-not equivalent:
-
-``` ruby
-XPath.descendant(:p)[:@id => 'foo'] # => .//p[@id = 'foo']
-XPath.descendant(:p)[:id => 'foo']  # => .//p[id = 'foo']
-XPath.descendant(:p)['id' => 'foo'] # => .//p['id' = 'foo']
-```
-
-## HTML
-
-XPath comes with a set of premade XPaths for use with HTML documents.
-
-You can generate these like this:
-
-``` ruby
-XPath::HTML.link('Home')
-XPath::HTML.field('Name')
-```
-
-See [`XPath::HTML`](http://rdoc.info/github/jnicklas/xpath/XPath/HTML) for all
-available matchers.
-
 ## License
 
-(The MIT License)
-
-Copyright © 2010 Jonas Nicklas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the ‘Software’), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+See [LICENSE](LICENSE).

data/lib/xpath.rb

@@ -8,9 +8,8 @@ require 'xpath/renderer'
 require 'xpath/html'
 
 module XPath
-
-  extend XPath::DSL::TopLevel
-  include XPath::DSL::TopLevel
+  extend XPath::DSL
+  include XPath::DSL
 
   def self.generate
     yield(self)

data/lib/xpath/dsl.rb

@@ -1,112 +1,147 @@
 module XPath
   module DSL
-    module TopLevel
-      def current
-        Expression.new(:this_node)
-      end
-
-      def name
-        Expression.new(:node_name, current)
-      end
+    def current
+      Expression.new(:this_node)
+    end
 
-      def descendant(*expressions)
-        Expression.new(:descendant, current, expressions)
-      end
+    def descendant(*expressions)
+      Expression.new(:descendant, current, expressions)
+    end
 
-      def child(*expressions)
-        Expression.new(:child, current, expressions)
-      end
+    def child(*expressions)
+      Expression.new(:child, current, expressions)
+    end
 
-      def axis(name, tag_name=:*)
-        Expression.new(:axis, current, name, tag_name)
-      end
+    def axis(name, *element_names)
+      Expression.new(:axis, current, name, element_names)
+    end
 
-      def next_sibling(*expressions)
-        Expression.new(:next_sibling, current, expressions)
-      end
+    def anywhere(*expressions)
+      Expression.new(:anywhere, expressions)
+    end
 
-      def previous_sibling(*expressions)
-        Expression.new(:previous_sibling, current, expressions)
-      end
+    def attr(expression)
+      Expression.new(:attribute, current, expression)
+    end
 
-      def anywhere(*expressions)
-        Expression.new(:anywhere, expressions)
-      end
+    def text
+      Expression.new(:text, current)
+    end
 
-      def attr(expression)
-        Expression.new(:attribute, current, expression)
-      end
+    def css(selector)
+      Expression.new(:css, current, Literal.new(selector))
+    end
 
-      def contains(expression)
-        Expression.new(:contains, current, expression)
-      end
+    def function(name, *arguments)
+      Expression.new(:function, name, *arguments)
+    end
 
-      def starts_with(expression)
-        Expression.new(:starts_with, current, expression)
-      end
+    def method(name, *arguments)
+      Expression.new(:function, name, current, *arguments)
+    end
 
-      def text
-        Expression.new(:text, current)
-      end
+    def where(expression)
+      Expression.new(:where, current, expression)
+    end
+    alias_method :[], :where
 
-      def string
-        Expression.new(:string_function, current)
-      end
+    def is(expression)
+      Expression.new(:is, current, expression)
+    end
 
-      def css(selector)
-        Expression.new(:css, current, Literal.new(selector))
-      end
+    def binary_operator(name, rhs)
+      Expression.new(:binary_operator, name, current, rhs)
     end
 
-    module ExpressionLevel
-      include XPath::DSL::TopLevel
+    def union(*expressions)
+      Union.new(*[self, expressions].flatten)
+    end
+    alias_method :+, :union
 
-      def where(expression)
-        Expression.new(:where, current, expression)
-      end
-      alias_method :[], :where
+    def last
+      function(:last)
+    end
 
-      def one_of(*expressions)
-        Expression.new(:one_of, current, expressions)
-      end
+    def position
+      function(:position)
+    end
 
-      def equals(expression)
-        Expression.new(:equality, current, expression)
+    METHODS = [
+      # node set
+      :count, :id, :local_name, :namespace_uri, :name,
+      # string
+      :string, :concat, :starts_with, :contains, :substring_before,
+      :substring_after, :substring, :string_length, :normalize_space,
+      :translate,
+      # boolean
+      :boolean, :not, :true, :false, :lang,
+      # number
+      :number, :sum, :floor, :ceiling, :round,
+    ]
+
+    METHODS.each do |key|
+      name = key.to_s.gsub("_", "-").to_sym
+      define_method key do |*args|
+        method(name, *args)
       end
-      alias_method :==, :equals
+    end
 
-      def is(expression)
-        Expression.new(:is, current, expression)
-      end
+    alias_method :inverse, :not
+    alias_method :~, :not
+    alias_method :normalize, :normalize_space
+    alias_method :n, :normalize_space
+
+    OPERATORS = [
+      [:equals, :"=", :==],
+      [:or, :or, :|],
+      [:and, :and, :&],
+      [:lte, :<=, :<=],
+      [:lt, :<, :<],
+      [:gte, :>=, :>=],
+      [:gt, :>, :>],
+      [:plus, :+],
+      [:minus, :-],
+      [:multiply, :*, :*],
+      [:divide, :div, :/],
+      [:mod, :mod, :%],
+    ]
+
+    OPERATORS.each do |(name, operator, alias_name)|
+      define_method name do |rhs|
+        binary_operator(operator, rhs)
+      end
+      alias_method alias_name, name if alias_name
+    end
 
-      def or(expression)
-        Expression.new(:or, current, expression)
-      end
-      alias_method :|, :or
+    AXES = [
+      :ancestor, :ancestor_or_self, :attribute, :descendant_or_self,
+      :following, :following_sibling, :namespace, :parent, :preceding,
+      :preceding_sibling, :self,
+    ]
 
-      def and(expression)
-        Expression.new(:and, current, expression)
+    AXES.each do |key|
+      name = key.to_s.gsub("_", "-").to_sym
+      define_method key do |*element_names|
+        axis(name, *element_names)
       end
-      alias_method :&, :and
+    end
 
-      def union(*expressions)
-        Union.new(*[self, expressions].flatten)
-      end
-      alias_method :+, :union
+    alias_method :self_axis, :self
 
-      def inverse
-        Expression.new(:inverse, current)
+    def one_of(*expressions)
+      expressions.map do |e|
+        current.equals(e)
+      end.reduce do |a, b|
+        a.or(b)
       end
-      alias_method :~, :inverse
+    end
 
-      def string_literal
-        Expression.new(:string_literal, self)
-      end
+    def next_sibling(*expressions)
+      axis(:"following-sibling")[1].axis(:self, *expressions)
+    end
 
-      def normalize
-        Expression.new(:normalized_space, current)
-      end
-      alias_method :n, :normalize
+    def previous_sibling(*expressions)
+      axis(:"preceding-sibling")[1].axis(:self, *expressions)
     end
   end
 end

data/lib/xpath/expression.rb

@@ -1,7 +1,7 @@
 module XPath
   class Expression
     attr_accessor :expression, :arguments
-    include XPath::DSL::ExpressionLevel
+    include XPath::DSL
 
     def initialize(expression, *arguments)
       @expression = expression

data/lib/xpath/html.rb

@@ -1,6 +1,6 @@
 module XPath
   module HTML
-    include XPath::DSL::TopLevel
+    include XPath::DSL
     extend self
 
     # Match an `a` link element.

data/lib/xpath/renderer.rb

@@ -38,32 +38,20 @@ module XPath
       '.'
     end
 
-    def descendant(parent, element_names)
-      if element_names.length == 1
-        "#{parent}//#{element_names.first}"
-      elsif element_names.length > 1
-        "#{parent}//*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
-      else
-        "#{parent}//*"
-      end
+    def descendant(current, element_names)
+      with_element_conditions("#{current}//", element_names)
     end
 
-    def child(parent, element_names)
-      if element_names.length == 1
-        "#{parent}/#{element_names.first}"
-      elsif element_names.length > 1
-        "#{parent}/*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
-      else
-        "#{parent}/*"
-      end
+    def child(current, element_names)
+      with_element_conditions("#{current}/", element_names)
     end
 
-    def axis(parent, name, tag_name)
-      "#{parent}/#{name}::#{tag_name}"
+    def axis(current, name, element_names)
+      with_element_conditions("#{current}/#{name}::", element_names)
     end
 
-    def node_name(current)
-      "name(#{current})"
+    def anywhere(element_names)
+      with_element_conditions("//", element_names)
     end
 
     def where(on, condition)
@@ -74,15 +62,15 @@ module XPath
       "#{current}/@#{name}"
     end
 
-    def equality(one, two)
-      "#{one} = #{two}"
+    def binary_operator(name, left, right)
+      "(#{left} #{name} #{right})"
     end
 
     def is(one, two)
       if @type == :exact
-        equality(one, two)
+        binary_operator("=", one, two)
       else
-        contains(one, two)
+        function(:contains, one, two)
       end
     end
 
@@ -94,10 +82,6 @@ module XPath
       "#{current}/text()"
     end
 
-    def normalized_space(current)
-      "normalize-space(#{current})"
-    end
-
     def literal(node)
       node
     end
@@ -113,62 +97,20 @@ module XPath
       expressions.join(' | ')
     end
 
-    def anywhere(element_names)
-      if element_names.length == 1
-        "//#{element_names.first}"
-      elsif element_names.length > 1
-        "//*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
-      else
-        "//*"
-      end
+    def function(name, *arguments)
+      "#{name}(#{arguments.join(", ")})"
     end
 
-    def contains(current, value)
-      "contains(#{current}, #{value})"
-    end
+  private
 
-    def starts_with(current, value)
-      "starts-with(#{current}, #{value})"
-    end
-
-    def and(one, two)
-      "(#{one} and #{two})"
-    end
-
-    def or(one, two)
-      "(#{one} or #{two})"
-    end
-
-    def one_of(current, values)
-      values.map { |value| "#{current} = #{value}" }.join(' or ')
-    end
-
-    def next_sibling(current, element_names)
+    def with_element_conditions(expression, element_names)
       if element_names.length == 1
-        "#{current}/following-sibling::*[1]/self::#{element_names.first}"
+        "#{expression}#{element_names.first}"
       elsif element_names.length > 1
-        "#{current}/following-sibling::*[1]/self::*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
+        "#{expression}*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
       else
-        "#{current}/following-sibling::*[1]/self::*"
+        "#{expression}*"
       end
     end
-
-    def previous_sibling(current, element_names)
-      if element_names.length == 1
-        "#{current}/preceding-sibling::*[1]/self::#{element_names.first}"
-      elsif element_names.length > 1
-        "#{current}/preceding-sibling::*[1]/self::*[#{element_names.map { |e| "self::#{e}" }.join(" | ")}]"
-      else
-        "#{current}/preceding-sibling::*[1]/self::*"
-      end
-    end
-
-    def inverse(current)
-      "not(#{current})"
-    end
-
-    def string_function(current)
-      "string(#{current})"
-    end
   end
 end

data/lib/xpath/version.rb

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

data/spec/fixtures/simple.html

@@ -41,5 +41,9 @@
       <div id="elephantay">elephant</div>
       <p id="amingoflay">flamingo</p>
     </div>
+
+    <span id="substring">Hello there</span>
+
+    <span id="string-length">Hello there</span>
   </body>
 </html>

data/spec/html_spec.rb

@@ -5,13 +5,13 @@ 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)
-    type = example.metadata[:type]
     doc.xpath(XPath::HTML.send(subject, *args).to_xpath(type)).map { |node| node[:data] }
   end
 

data/spec/spec_helper.rb

@@ -1 +1,6 @@
 require 'xpath'
+require 'pry'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+end

data/spec/xpath_spec.rb

@@ -191,6 +191,43 @@ describe XPath do
     end
   end
 
+  describe '#substring' 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"
+      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"
+      end
+    end
+  end
+
+  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
+    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
+    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
+    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"
@@ -346,4 +383,113 @@ describe XPath do
     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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    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"
+    end
+  end
 end

metadata

@@ -1,108 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: xpath
 version: !ruby/object:Gem::Version
-  version: 2.0.0
-  prerelease: 
+  version: 2.1.0
 platform: ruby
 authors:
 - Jonas Nicklas
 autorequire: 
 bindir: bin
 cert_chain:
-- !binary |-
-  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURoVENDQW0yZ0F3SUJB
-  Z0lCQVRBTkJna3Foa2lHOXcwQkFRVUZBREJFTVJZd0ZBWURWUVFEREExcWIy
-  NWgKY3k1dWFXTnJiR0Z6TVJVd0V3WUtDWkltaVpQeUxHUUJHUllGWjIxaGFX
-  d3hFekFSQmdvSmtpYUprL0lzWkFFWgpGZ05qYjIwd0hoY05NVE13TXpFMk1E
-  RXpNVEV4V2hjTk1UUXdNekUyTURFek1URXhXakJFTVJZd0ZBWURWUVFECkRB
-  MXFiMjVoY3k1dWFXTnJiR0Z6TVJVd0V3WUtDWkltaVpQeUxHUUJHUllGWjIx
-  aGFXd3hFekFSQmdvSmtpYUoKay9Jc1pBRVpGZ05qYjIwd2dnRWlNQTBHQ1Nx
-  R1NJYjNEUUVCQVFVQUE0SUJEd0F3Z2dFS0FvSUJBUUMrQjlteAowVFZrdlhJ
-  TjMxSkM0czROaTZtY2hKTC85OGgrZXVNSUVOdDVMb3hjZVlsaWpQMG5HZFlI
-  QU1vQTJDVWw3RStKCi9LbTNXMXppU0MwTXIzWUlxQ3dwNGZ5Z1Axd295UktS
-  WW1veUJSWmRXNUppUEFRell4WGFpYjArQkNCK0poU20KUmV2MitCYUhKdVJS
-  S1dxK1MzYnpaNjFVNlJNVnAvdEFmZUluWE9RZHZtM3ljeWhPR1d4NlhwRVcy
-  T042b1JEbAptQnVBTThiOWhqcE9BekZYaDNPTFhCQzl6cTVaNXBsMmZybGZB
-  VkIyaEt6dHdpRWlOa0dqeC9xQlhpeHZvN2R1Ck14K08yOTZXcEx1dVd3ck9h
-  SXNSM1EzN2FOdkxCdmllaDc0RDlRSmpjd1IzTXIwUlJRTGJYeE5Hc1NRYTZn
-  WTQKbDlqMEV0VVZTRFpCNTRINUFnTUJBQUdqZ1lFd2Z6QUpCZ05WSFJNRUFq
-  QUFNQXNHQTFVZER3UUVBd0lFc0RBZApCZ05WSFE0RUZnUVVmOEd0anduYVJ0
-  U3FndkpEekNjM1RhN0xITXN3SWdZRFZSMFJCQnN3R1lFWGFtOXVZWE11CmJt
-  bGphMnhoYzBCbmJXRnBiQzVqYjIwd0lnWURWUjBTQkJzd0dZRVhhbTl1WVhN
-  dWJtbGphMnhoYzBCbmJXRnAKYkM1amIyMHdEUVlKS29aSWh2Y05BUUVGQlFB
-  RGdnRUJBR2xzbnBjZXY0ZnUrRkRBeWdiT2JmYzczcGx0S25RRgpFd3k4OCtI
-  Z0o0QWhqd0hFUjdPV0RWTXdoNnZIa21FZXAxcmhMbk5XR3p0RC95bTVpRms0
-  RkdJejFENUo3VHFRCms0djJ3K09qZTNZVy9wU0FHZ0FWUEdDQ3JscWl3NGhL
-  WlV6UG9iOE5XaHVTNHRLRFBXTUdCUXgzWlNSeXFJTGMKL1dRL0ZtbmJWYTl4
-  UlVvK1JXaVA5VHB6S1FKaVIzQlA5T3BWclJ4MTNtMGV1Rnh6VGk2aWtKekM0
-  NVEzRHE1VgppUXhVbUNDUnNKVmNzU0ZPUkpMZFdOVnF6Qk9XWlJucXJMRHVu
-  em91Q2JjcXppTldrOEtxalpDcjVpdFJpMzE5Ci8ya1pnd2MzMkZIbENkQ0JY
-  a2hFbEVIVC9iR0NGazIrYWpubVdSdHFacHovcG9UZ0VlaGlJVVk9Ci0tLS0t
-  RU5EIENFUlRJRklDQVRFLS0tLS0K
-date: 2013-04-09 00:00:00.000000000 Z
+- gem-public_cert.pem
+date: 2017-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :runtime
   prerelease: false
   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:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.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
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     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
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: XPath is a Ruby DSL for generating XPath expressions
@@ -110,9 +86,10 @@ email:
 - jonas.nicklas@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.md
+extra_rdoc_files: []
 files:
+- README.md
+- lib/xpath.rb
 - lib/xpath/dsl.rb
 - lib/xpath/expression.rb
 - lib/xpath/html.rb
@@ -120,7 +97,6 @@ files:
 - lib/xpath/renderer.rb
 - lib/xpath/union.rb
 - lib/xpath/version.rb
-- lib/xpath.rb
 - spec/fixtures/form.html
 - spec/fixtures/simple.html
 - spec/fixtures/stuff.html
@@ -128,32 +104,28 @@ files:
 - spec/spec_helper.rb
 - spec/union_spec.rb
 - spec/xpath_spec.rb
-- README.md
-homepage: http://github.com/jnicklas/xpath
-licenses: []
+homepage: https://github.com/teamcapybara/xpath
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options:
-- --main
-- README.md
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: xpath
-rubygems_version: 1.8.25
+rubyforge_project: 
+rubygems_version: 2.5.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Generate XPath expressions from Ruby
 test_files: []
-has_rdoc: 

metadata.gz.sig

@@ -1 +0,0 @@
-Q�יִ.�C�����hiΑj�5hg/�Ϋ!7�z�4�	<X��Yn�W�o��A��U����W�]?��5S�,�mj�/Iqp<��|�~��Q�ݺS���ޟD-��@�x�oɶT�	K~o{���qΣT���J���F{� �z
a�=�չ��36���+;SC������1�S&�/I�d���O�8�Nz�`F�4��Y�c�X��G�S�rj4�U�7D�(�{���AO�k�
k�u���xa���;��vG�