xpath 2.0.0 → 3.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a243005210afa835c320ea204ab3105d0b253dfdb905d4ff53c8267e53a23d6d
+  data.tar.gz: 4978108857ddbd50e336926db82b6bb056656861572aa518654cff2dcadb2bc7
+SHA512:
+  metadata.gz: e17ddd74ff29ac77050bec7cb5ee93f8b1c2386c56ea4390272d998540a69cf8f26f61541de3a583866b4531836d051e722ca93eabc9d52636e722aa78de491b
+  data.tar.gz: c75b155e85156faafa9e3ac63e7c16b7fbc20385b80ada25dcb5c0c680ea06fd06490a5d2e9096d68a51b22b62b06f5ad6b5d7b6e0191396e748bbd7e415d3ce

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/dsl.rb

@@ -1,112 +1,174 @@
+# frozen_string_literal: true
+
 module XPath
   module DSL
-    module TopLevel
-      def current
-        Expression.new(:this_node)
-      end
+    def current
+      Expression.new(:this_node)
+    end
 
-      def name
-        Expression.new(:node_name, current)
-      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, *element_names)
+      Expression.new(:axis, current, name, element_names)
+    end
 
-      def axis(name, tag_name=:*)
-        Expression.new(:axis, current, name, tag_name)
-      end
+    def anywhere(*expressions)
+      Expression.new(:anywhere, expressions)
+    end
 
-      def next_sibling(*expressions)
-        Expression.new(:next_sibling, current, expressions)
-      end
+    def attr(expression)
+      Expression.new(:attribute, current, expression)
+    end
 
-      def previous_sibling(*expressions)
-        Expression.new(:previous_sibling, current, expressions)
-      end
+    def text
+      Expression.new(:text, current)
+    end
 
-      def anywhere(*expressions)
-        Expression.new(:anywhere, expressions)
-      end
+    def css(selector)
+      Expression.new(:css, current, Literal.new(selector))
+    end
 
-      def attr(expression)
-        Expression.new(:attribute, current, expression)
-      end
+    def function(name, *arguments)
+      Expression.new(:function, name, *arguments)
+    end
 
-      def contains(expression)
-        Expression.new(:contains, current, expression)
-      end
+    def method(name, *arguments)
+      Expression.new(:function, name, current, *arguments)
+    end
 
-      def starts_with(expression)
-        Expression.new(:starts_with, current, expression)
+    def where(expression)
+      if expression
+        Expression.new(:where, current, expression)
+      else
+        current
       end
+    end
+    alias_method :[], :where
 
-      def text
-        Expression.new(:text, current)
-      end
+    def is(expression)
+      Expression.new(:is, current, expression)
+    end
 
-      def string
-        Expression.new(:string_function, current)
-      end
+    def binary_operator(name, rhs)
+      Expression.new(:binary_operator, name, current, rhs)
+    end
 
-      def css(selector)
-        Expression.new(:css, current, Literal.new(selector))
-      end
+    def union(*expressions)
+      Union.new(*[self, expressions].flatten)
     end
+    alias_method :+, :union
 
-    module ExpressionLevel
-      include XPath::DSL::TopLevel
+    def last
+      function(:last)
+    end
 
-      def where(expression)
-        Expression.new(:where, current, expression)
-      end
-      alias_method :[], :where
+    def position
+      function(:position)
+    end
 
-      def one_of(*expressions)
-        Expression.new(:one_of, current, expressions)
+    METHODS = [
+      # node set
+      :count, :id, :local_name, :namespace_uri,
+      # 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
+    ].freeze
+
+    METHODS.each do |key|
+      name = key.to_s.tr('_', '-').to_sym
+      define_method key do |*args|
+        method(name, *args)
       end
+    end
 
-      def equals(expression)
-        Expression.new(:equality, current, expression)
-      end
-      alias_method :==, :equals
+    def qname
+      method(:name)
+    end
 
-      def is(expression)
-        Expression.new(:is, current, expression)
-      end
+    alias_method :inverse, :not
+    alias_method :~, :not
+    alias_method :!, :not
+    alias_method :normalize, :normalize_space
+    alias_method :n, :normalize_space
+
+    OPERATORS = [
+      %i[equals = ==],
+      %i[or or |],
+      %i[and and &],
+      %i[not_equals != !=],
+      %i[lte <= <=],
+      %i[lt < <],
+      %i[gte >= >=],
+      %i[gt > >],
+      %i[plus +],
+      %i[minus -],
+      %i[multiply * *],
+      %i[divide div /],
+      %i[mod mod %]
+    ].freeze
+
+    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 = %i[
+      ancestor ancestor_or_self attribute descendant_or_self
+      following following_sibling namespace parent preceding
+      preceding_sibling self
+    ].freeze
 
-      def and(expression)
-        Expression.new(:and, current, expression)
+    AXES.each do |key|
+      name = key.to_s.tr('_', '-').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)
-      end
-      alias_method :~, :inverse
+    def ends_with(suffix)
+      function(:substring, current, function(:'string-length', current).minus(function(:'string-length', suffix)).plus(1)) == suffix
+    end
 
-      def string_literal
-        Expression.new(:string_literal, self)
-      end
+    def contains_word(word)
+      function(:concat, ' ', current.normalize_space, ' ').contains(" #{word} ")
+    end
 
-      def normalize
-        Expression.new(:normalized_space, current)
-      end
-      alias_method :n, :normalize
+    UPPERCASE_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'
+    LOWERCASE_LETTERS = 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ'
+
+    def lowercase
+      method(:translate, UPPERCASE_LETTERS, LOWERCASE_LETTERS)
+    end
+
+    def uppercase
+      method(:translate, LOWERCASE_LETTERS, UPPERCASE_LETTERS)
+    end
+
+    def one_of(*expressions)
+      expressions.map { |e| current.equals(e) }.reduce(:or)
+    end
+
+    def next_sibling(*expressions)
+      axis(:"following-sibling")[1].axis(:self, *expressions)
+    end
+
+    def previous_sibling(*expressions)
+      axis(:"preceding-sibling")[1].axis(:self, *expressions)
     end
   end
 end

data/lib/xpath/expression.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module XPath
   class Expression
     attr_accessor :expression, :arguments
-    include XPath::DSL::ExpressionLevel
+    include XPath::DSL
 
     def initialize(expression, *arguments)
       @expression = expression
@@ -12,7 +14,7 @@ module XPath
       self
     end
 
-    def to_xpath(type=nil)
+    def to_xpath(type = nil)
       Renderer.render(self, type)
     end
     alias_method :to_s, :to_xpath

data/lib/xpath/literal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XPath
   class Literal
     attr_reader :value

data/lib/xpath/renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XPath
   class Renderer
     def self.render(node, type)
@@ -15,11 +17,11 @@ module XPath
 
     def convert_argument(argument)
       case argument
-        when Expression, Union then render(argument)
-        when Array then argument.map { |element| convert_argument(element) }
-        when String then string_literal(argument)
-        when Literal then argument.value
-        else argument.to_s
+      when Expression, Union then render(argument)
+      when Array then argument.map { |element| convert_argument(element) }
+      when String then string_literal(argument)
+      when Literal then argument.value
+      else argument.to_s
       end
     end
 
@@ -27,7 +29,7 @@ module XPath
       if string.include?("'")
         string = string.split("'", -1).map do |substr|
           "'#{substr}'"
-        end.join(%q{,"'",})
+        end.join(%q(,"'",))
         "concat(#{string})"
       else
         "'#{string}'"
@@ -38,32 +40,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)
@@ -71,18 +61,22 @@ module XPath
     end
 
     def attribute(current, name)
-      "#{current}/@#{name}"
+      if valid_xml_name?(name)
+        "#{current}/@#{name}"
+      else
+        "#{current}/attribute::*[local-name(.) = #{string_literal(name)}]"
+      end
     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 +88,6 @@ module XPath
       "#{current}/text()"
     end
 
-    def normalized_space(current)
-      "normalize-space(#{current})"
-    end
-
     def literal(node)
       node
     end
@@ -113,62 +103,24 @@ 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
-    end
-
-    def contains(current, value)
-      "contains(#{current}, #{value})"
-    end
-
-    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})"
+    def function(name, *arguments)
+      "#{name}(#{arguments.join(', ')})"
     end
 
-    def one_of(current, values)
-      values.map { |value| "#{current} = #{value}" }.join(' or ')
-    end
+  private
 
-    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})"
+    def valid_xml_name?(name)
+      name =~ /^[a-zA-Z_:][a-zA-Z0-9_:\.\-]*$/
     end
   end
 end

data/lib/xpath/union.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XPath
   class Union
     include Enumerable
@@ -17,11 +19,11 @@ module XPath
       arguments.each(&block)
     end
 
-    def method_missing(*args)
+    def method_missing(*args) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
       XPath::Union.new(*arguments.map { |e| e.send(*args) })
     end
 
-    def to_xpath(type=nil)
+    def to_xpath(type = nil)
       Renderer.render(self, type)
     end
     alias_method :to_s, :to_xpath

data/lib/xpath/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XPath
-  VERSION = '2.0.0'
+  VERSION = '3.2.0'
 end

data/lib/xpath.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
 
 require 'xpath/dsl'
@@ -5,12 +7,10 @@ require 'xpath/expression'
 require 'xpath/literal'
 require 'xpath/union'
 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/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,9 +37,17 @@
     </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>
+
+    <span id="substring">Hello there</span>
+
+    <span id="string-length">Hello there</span>
+
+    <div id="oof" title="viDoof" data="id">
+      <p id="viDoof">Blah</p>
+    </div>
   </body>
 </html>

data/spec/spec_helper.rb

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