nokogiri 1.5.10 → 1.10.4

data/lib/nokogiri/css/parser.y

@@ -10,13 +10,12 @@ rule
         result = [val.first, val.last].flatten
       }
     | prefixless_combinator_selector { result = val.flatten }
-    | simple_selector_1toN { result = val.flatten }
+    | optional_S simple_selector_1toN { result = [val.last].flatten }
     ;
   combinator
     : PLUS { result = :DIRECT_ADJACENT_SELECTOR }
     | GREATER { result = :CHILD_SELECTOR }
     | TILDE { result = :FOLLOWING_SELECTOR }
-    | S { result = :DESCENDANT_SELECTOR }
     | DOUBLESLASH { result = :DESCENDANT_SELECTOR }
     | SLASH { result = :CHILD_SELECTOR }
     ;
@@ -28,17 +27,6 @@ rule
                     Node.new(:CONDITIONAL_SELECTOR, [val.first, val[1]])
                   end
       }
-    | element_name hcap_1toN negation {
-        result = Node.new(:CONDITIONAL_SELECTOR,
-          [
-            val.first,
-            Node.new(:COMBINATOR, [val[1], val.last])
-          ]
-        )
-      }
-    | element_name negation {
-        result = Node.new(:CONDITIONAL_SELECTOR, val)
-      }
     | function
     | function pseudo {
         result = Node.new(:CONDITIONAL_SELECTOR, val)
@@ -46,14 +34,6 @@ rule
     | function attrib {
         result = Node.new(:CONDITIONAL_SELECTOR, val)
       }
-    | hcap_1toN negation {
-        result = Node.new(:CONDITIONAL_SELECTOR,
-          [
-            Node.new(:ELEMENT_NAME, ['*']),
-            Node.new(:COMBINATOR, val)
-          ]
-        )
-      }
     | hcap_1toN {
         result = Node.new(:CONDITIONAL_SELECTOR,
           [Node.new(:ELEMENT_NAME, ['*']), val.first]
@@ -69,10 +49,13 @@ rule
     : simple_selector combinator simple_selector_1toN {
         result = Node.new(val[1], [val.first, val.last])
       }
+    | simple_selector S simple_selector_1toN {
+        result = Node.new(:DESCENDANT_SELECTOR, [val.first, val.last])
+      }
     | simple_selector
     ;
   class
-    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [val[1]]) }
+    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [unescape_css_identifier(val[1])]) }
     ;
   element_name
     : namespaced_ident
@@ -130,7 +113,7 @@ rule
     | FUNCTION expr RPAREN {
         result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
       }
-    | FUNCTION an_plus_b RPAREN {
+    | FUNCTION nth RPAREN {
         result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
       }
     | NOT expr RPAREN {
@@ -148,12 +131,13 @@ rule
     | STRING
     | IDENT                             # even, odd
       {
-        if val[0] == 'even'
-          val = ["2","n","+","0"]
-          result = Node.new(:AN_PLUS_B, val)
-        elsif val[0] == 'odd'
-          val = ["2","n","+","1"]
-          result = Node.new(:AN_PLUS_B, val)
+        case val[0]
+        when 'even'
+          result = Node.new(:NTH, ['2','n','+','0'])
+        when 'odd'
+          result = Node.new(:NTH, ['2','n','+','1'])
+        when 'n'
+          result = Node.new(:NTH, ['1','n','+','0'])
         else
           # This is not CSS standard.  It allows us to support this:
           # assert_xpath("//a[foo(., @href)]", @parser.parse('a:foo(@href)'))
@@ -163,11 +147,11 @@ rule
         end
       }
     ;
-  an_plus_b
+  nth
     : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
       {
         if val[1] == 'n'
-          result = Node.new(:AN_PLUS_B, val)
+          result = Node.new(:NTH, val)
         else
           raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
         end
@@ -175,21 +159,27 @@ rule
     | IDENT PLUS NUMBER {               # n+3, -n+3
         if val[0] == 'n'
           val.unshift("1")
-          result = Node.new(:AN_PLUS_B, val)
+          result = Node.new(:NTH, val)
         elsif val[0] == '-n'
           val[0] = 'n'
           val.unshift("-1")
-          result = Node.new(:AN_PLUS_B, val)
+          result = Node.new(:NTH, val)
         else
           raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
         end
       }
-    | NUMBER IDENT                      # 5n, -5n
-      {
-        if val[1] == 'n'
+    | NUMBER IDENT {                    # 5n, -5n, 10n-1
+        n = val[1]
+        if n[0, 2] == 'n-'
+          val[1] = 'n'
+          val << "-"
+          # b is contained in n as n is the string "n-b"
+          val << n[2, n.size]
+          result = Node.new(:NTH, val)
+        elsif n == 'n'
           val << "+"
           val << "0"
-          result = Node.new(:AN_PLUS_B, val)
+          result = Node.new(:NTH, val)
         else
           raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
         end
@@ -218,17 +208,22 @@ rule
     | pseudo hcap_1toN {
         result = Node.new(:COMBINATOR, val)
       }
+    | negation hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
     | attribute_id
     | class
     | attrib
     | pseudo
+    | negation
     ;
   attribute_id
-    : HASH { result = Node.new(:ID, val) }
+    : HASH { result = Node.new(:ID, [unescape_css_identifier(val.first)]) }
     ;
   attrib_val_0or1
-    : eql_incl_dash IDENT { result = [val.first, val[1]] }
-    | eql_incl_dash STRING { result = [val.first, val[1]] }
+    : eql_incl_dash IDENT { result = [val.first, unescape_css_identifier(val[1])] }
+    | eql_incl_dash STRING { result = [val.first, unescape_css_string(val[1])] }
+    | eql_incl_dash NUMBER { result = [val.first, val[1]] }
     |
     ;
   eql_incl_dash
@@ -250,9 +245,28 @@ rule
     | element_name hcap_1toN
     | hcap_1toN
     ;
+  optional_S
+    : S
+    |
+    ;
 end
 
 ---- header
 
 require 'nokogiri/css/parser_extras'
 
+---- inner
+
+def unescape_css_identifier(identifier)
+  identifier.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/){ |m| $1 || [$2.hex].pack('U') }
+end
+
+def unescape_css_string(str)
+  str.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/) do |m|
+    if $1=="\n"
+      ''
+    else
+      $1 || [$2.hex].pack('U')
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rb

@@ -1,151 +1,152 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.5
+# This file is automatically generated by rex 1.0.7
 # from lexical definition file "lib/nokogiri/css/tokenizer.rex".
 #++
 
 module Nokogiri
 module CSS
 class Tokenizer # :nodoc:
-  require 'strscan'
+      require 'strscan'
 
-  class ScanError < StandardError ; end
+      class ScanError < StandardError ; end
 
-  attr_reader   :lineno
-  attr_reader   :filename
-  attr_accessor :state
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
 
-  def scan_setup(str)
-    @ss = StringScanner.new(str)
-    @lineno =  1
-    @state  = nil
-  end
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
 
-  def action
-    yield
-  end
+      def action
+        yield
+      end
 
-  def scan_str(str)
-    scan_setup(str)
-    do_parse
-  end
-  alias :scan :scan_str
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
 
-  def load_file( filename )
-    @filename = filename
-    open(filename, "r") do |f|
-      scan_setup(f.read)
-    end
-  end
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
 
-  def scan_file( filename )
-    load_file(filename)
-    do_parse
-  end
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
 
 
-  def next_token
-    return if @ss.eos?
-    
-    # skips empty actions
-    until token = _next_token or @ss.eos?; end
-    token
-  end
+        def next_token
+          return if @ss.eos?
 
-  def _next_token
-    text = @ss.peek(1)
-    @lineno  +=  1  if text == "\n"
-    token = case @state
-    when nil
-      case
-      when (text = @ss.scan(/has\([\s]*/))
-         action { [:HAS, text] }
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
-         action { [:FUNCTION, text] }
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/has\([\s]*/))
+                     action { [:HAS, text] }
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
-         action { [:IDENT, text] }
+                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
+                     action { [:FUNCTION, text] }
 
-      when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/))
-         action { [:HASH, text] }
+                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
+                     action { [:IDENT, text] }
 
-      when (text = @ss.scan(/[\s]*~=[\s]*/))
-         action { [:INCLUDES, text] }
+                  when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/))
+                     action { [:HASH, text] }
 
-      when (text = @ss.scan(/[\s]*\|=[\s]*/))
-         action { [:DASHMATCH, text] }
+                  when (text = @ss.scan(/[\s]*~=[\s]*/))
+                     action { [:INCLUDES, text] }
 
-      when (text = @ss.scan(/[\s]*\^=[\s]*/))
-         action { [:PREFIXMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\|=[\s]*/))
+                     action { [:DASHMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*\$=[\s]*/))
-         action { [:SUFFIXMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\^=[\s]*/))
+                     action { [:PREFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*\*=[\s]*/))
-         action { [:SUBSTRINGMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\$=[\s]*/))
+                     action { [:SUFFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*!=[\s]*/))
-         action { [:NOT_EQUAL, text] }
+                  when (text = @ss.scan(/[\s]*\*=[\s]*/))
+                     action { [:SUBSTRINGMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*=[\s]*/))
-         action { [:EQUAL, text] }
+                  when (text = @ss.scan(/[\s]*!=[\s]*/))
+                     action { [:NOT_EQUAL, text] }
 
-      when (text = @ss.scan(/[\s]*\)/))
-         action { [:RPAREN, text] }
+                  when (text = @ss.scan(/[\s]*=[\s]*/))
+                     action { [:EQUAL, text] }
 
-      when (text = @ss.scan(/[\s]*\[[\s]*/))
-         action { [:LSQUARE, text] }
+                  when (text = @ss.scan(/[\s]*\)/))
+                     action { [:RPAREN, text] }
 
-      when (text = @ss.scan(/[\s]*\]/))
-         action { [:RSQUARE, text] }
+                  when (text = @ss.scan(/\[[\s]*/))
+                     action { [:LSQUARE, text] }
 
-      when (text = @ss.scan(/[\s]*\+[\s]*/))
-         action { [:PLUS, text] }
+                  when (text = @ss.scan(/[\s]*\]/))
+                     action { [:RSQUARE, text] }
 
-      when (text = @ss.scan(/[\s]*>[\s]*/))
-         action { [:GREATER, text] }
+                  when (text = @ss.scan(/[\s]*\+[\s]*/))
+                     action { [:PLUS, text] }
 
-      when (text = @ss.scan(/[\s]*,[\s]*/))
-         action { [:COMMA, text] }
+                  when (text = @ss.scan(/[\s]*>[\s]*/))
+                     action { [:GREATER, text] }
 
-      when (text = @ss.scan(/[\s]*~[\s]*/))
-         action { [:TILDE, text] }
+                  when (text = @ss.scan(/[\s]*,[\s]*/))
+                     action { [:COMMA, text] }
 
-      when (text = @ss.scan(/\:not\([\s]*/))
-         action { [:NOT, text] }
+                  when (text = @ss.scan(/[\s]*~[\s]*/))
+                     action { [:TILDE, text] }
 
-      when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
-         action { [:NUMBER, text] }
+                  when (text = @ss.scan(/\:not\([\s]*/))
+                     action { [:NOT, text] }
 
-      when (text = @ss.scan(/[\s]*\/\/[\s]*/))
-         action { [:DOUBLESLASH, text] }
+                  when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
+                     action { [:NUMBER, text] }
 
-      when (text = @ss.scan(/[\s]*\/[\s]*/))
-         action { [:SLASH, text] }
+                  when (text = @ss.scan(/[\s]*\/\/[\s]*/))
+                     action { [:DOUBLESLASH, text] }
 
-      when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
-         action {[:UNICODE_RANGE, text] }
+                  when (text = @ss.scan(/[\s]*\/[\s]*/))
+                     action { [:SLASH, text] }
 
-      when (text = @ss.scan(/[\s]+/))
-         action { [:S, text] }
+                  when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
+                     action {[:UNICODE_RANGE, text] }
 
-      when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*'/))
-         action { [:STRING, text] }
+                  when (text = @ss.scan(/[\s]+/))
+                     action { [:S, text] }
 
-      when (text = @ss.scan(/./))
-         action { [text, text] }
+                  when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*'/))
+                     action { [:STRING, text] }
 
-      else
-        text = @ss.string[@ss.pos .. -1]
-        raise  ScanError, "can not match: '" + text + "'"
-      end  # if
+                  when (text = @ss.scan(/./))
+                     action { [text, text] }
 
-    else
-      raise  ScanError, "undefined state: '" + state.to_s + "'"
-    end  # case state
-    token
-  end  # def _next_token
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
 
 end # class
 end

data/lib/nokogiri/css/tokenizer.rex

@@ -14,8 +14,8 @@ macro
   nmstart   [_A-Za-z]|{nonascii}|{escape}
   ident     [-@]?({nmstart})({nmchar})*
   name      ({nmchar})+
-  string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*"
-  string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*'
+  string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*"
+  string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*'
   string    {string1}|{string2}
 
 rule
@@ -34,7 +34,7 @@ rule
             {w}!={w}         { [:NOT_EQUAL, text] }
             {w}={w}          { [:EQUAL, text] }
             {w}\)            { [:RPAREN, text] }
-            {w}\[{w}         { [:LSQUARE, text] }
+            \[{w}            { [:LSQUARE, text] }
             {w}\]            { [:RSQUARE, text] }
             {w}\+{w}         { [:PLUS, text] }
             {w}>{w}          { [:GREATER, text] }
@@ -44,9 +44,9 @@ rule
             {num}            { [:NUMBER, text] }
             {w}\/\/{w}       { [:DOUBLESLASH, text] }
             {w}\/{w}         { [:SLASH, text] }
-            
+
             U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
-            
+
             [\s]+            { [:S, text] }
             {string}         { [:STRING, text] }
             .                { [text, text] }

data/lib/nokogiri/css/xpath_visitor.rb

@@ -2,7 +2,7 @@ module Nokogiri
   module CSS
     class XPathVisitor # :nodoc:
       def visit_function node
-        #  note that nth-child and nth-last-child are preprocessed in css/node.rb.
+
         msg = :"visit_function_#{node.value.first.gsub(/[(]/, '')}"
         return self.send(msg, node) if self.respond_to?(msg)
 
@@ -13,19 +13,31 @@ module Nokogiri
           "self::#{node.value[1]}"
         when /^eq\(/
           "position() = #{node.value[1]}"
-        when /^(nth|nth-of-type|nth-child)\(/
-          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
-            an_plus_b(node.value[1])
+        when /^(nth|nth-of-type)\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
+            nth(node.value[1])
           else
             "position() = #{node.value[1]}"
           end
-        when /^(nth-last-child|nth-last-of-type)\(/
-          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
-            an_plus_b(node.value[1], :last => true)
+        when /^nth-child\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
+            nth(node.value[1], :child => true)
+          else
+            "count(preceding-sibling::*) = #{node.value[1].to_i-1}"
+          end
+        when /^nth-last-of-type\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
+            nth(node.value[1], :last => true)
           else
             index = node.value[1].to_i - 1
             index == 0 ? "position() = last()" : "position() = last() - #{index}"
           end
+        when /^nth-last-child\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
+            nth(node.value[1], :last => true, :child => true)
+          else
+            "count(following-sibling::*) = #{node.value[1].to_i-1}"
+          end
         when /^(first|first-of-type)\(/
           "position() = 1"
         when /^(last|last-of-type)\(/
@@ -39,7 +51,7 @@ module Nokogiri
         when /^comment\(/
           "comment()"
         when /^has\(/
-          node.value[1].accept(self)
+          ".//#{node.value[1].accept(self)}"
         else
           args = ['.'] + node.value[1..-1]
           "#{node.value.first}#{args.join(', ')})"
@@ -76,6 +88,13 @@ module Nokogiri
         value = node.value.last
         value = "'#{value}'" if value !~ /^['"]/
 
+        if (value[0]==value[-1]) && %q{"'}.include?(value[0])
+          str_value = value[1..-2]
+          if str_value.include?(value[0])
+            value = 'concat("' + str_value.split('"', -1).join(%q{", '"', "}) + '", "")'
+          end
+        end
+
         case node.value[1]
         when :equal
           attribute + " = " + "#{value}"
@@ -105,10 +124,13 @@ module Nokogiri
           return self.send(msg, node) if self.respond_to?(msg)
 
           case node.value.first
-          when "first", "first-child" then "position() = 1"
-          when "last", "last-child" then "position() = last()"
+          when "first" then "position() = 1"
+          when "first-child" then "count(preceding-sibling::*) = 0"
+          when "last" then "position() = last()"
+          when "last-child" then "count(following-sibling::*) = 0"
           when "first-of-type" then "position() = 1"
           when "last-of-type" then "position() = last()"
+          when "only-child" then "count(preceding-sibling::*) = 0 and count(following-sibling::*) = 0"
           when "only-of-type" then "last() = 1"
           when "empty" then "not(node())"
           when "parent" then "node()"
@@ -123,8 +145,15 @@ module Nokogiri
         "contains(concat(' ', normalize-space(@class), ' '), ' #{node.value.first} ')"
       end
 
+      def visit_combinator node
+        if is_of_type_pseudo_class?(node.value.last)
+          "#{node.value.first.accept(self) if node.value.first}][#{node.value.last.accept(self)}"
+        else
+          "#{node.value.first.accept(self) if node.value.first} and #{node.value.last.accept(self)}"
+        end
+      end
+
       {
-        'combinator'                => ' and ',
         'direct_adjacent_selector'  => "/following-sibling::*[1]/self::",
         'following_selector'        => "/following-sibling::",
         'descendant_selector'       => '//',
@@ -151,21 +180,51 @@ module Nokogiri
       end
 
     private
-      def an_plus_b node, options={}
+      def nth node, options={}
         raise ArgumentError, "expected an+b node to contain 4 tokens, but is #{node.value.inspect}" unless node.value.size == 4
 
-        a = node.value[0].to_i
-        b = node.value[3].to_i
-        position = options[:last] ? "(last()-position()+1)" : "position()"
+        a, b = read_a_and_positive_b node.value
+        position = if options[:child]
+          options[:last] ? "(count(following-sibling::*) + 1)" : "(count(preceding-sibling::*) + 1)"
+        else
+          options[:last] ? "(last()-position()+1)" : "position()"
+        end
 
-        if (b == 0)
-          return "(#{position} mod #{a}) = 0"
+        if b.zero?
+          "(#{position} mod #{a}) = 0"
         else
-          compare = (a < 0) ? "<=" : ">="
-          return "(#{position} #{compare} #{b}) and (((#{position}-#{b}) mod #{a.abs}) = 0)"
+          compare = a < 0 ? "<=" : ">="
+          if a.abs == 1
+            "#{position} #{compare} #{b}"
+          else
+            "(#{position} #{compare} #{b}) and (((#{position}-#{b}) mod #{a.abs}) = 0)"
+          end
         end
       end
 
+      def read_a_and_positive_b values
+        op = values[2]
+        if op == "+"
+          a = values[0].to_i
+          b = values[3].to_i
+        elsif op == "-"
+          a = values[0].to_i
+          b = a - (values[3].to_i % a)
+        else
+          raise ArgumentError, "expected an+b node to have either + or - as the operator, but is #{op.inspect}"
+        end
+        [a, b]
+      end
+
+      def is_of_type_pseudo_class? node
+        if node.type==:PSEUDO_CLASS
+          if node.value[0].is_a?(Nokogiri::CSS::Node) and node.value[0].type == :FUNCTION
+            node.value[0].value[0]
+          else
+            node.value[0]
+          end =~ /(nth|first|last|only)-of-type(\()?/
+        end
+      end
     end
   end
 end