tenderlove-nokogiri 0.0.0-x86-mswin32-60

data/lib/nokogiri/css/node.rb

@@ -0,0 +1,95 @@
+module Nokogiri
+  module CSS
+    class Node
+      attr_accessor :type, :value
+      def initialize type, value
+        @type = type
+        @value = value
+      end
+
+      def accept visitor
+        visitor.send(:"visit_#{type.to_s.downcase}", self)
+      end
+
+      def to_xpath prefix = '//', preprocess = true
+        self.preprocess! if preprocess
+        prefix + XPathVisitor.new.accept(self)
+      end
+
+      def preprocess!
+        ### Deal with nth-child
+        matches = find_by_type(
+          [:CONDITIONAL_SELECTOR,
+            [:ELEMENT_NAME],
+            [:PSEUDO_CLASS,
+              [:FUNCTION]
+            ]
+          ]
+        )
+        matches.each do |match|
+          if match.value[1].value[0].value[0] =~ /^nth-child/
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              match.value[1].value[0],
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          end
+          if match.value[1].value[0].value[0] =~ /^nth-last-child/
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              match.value[1].value[0],
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          end
+        end
+
+        ### Deal with first-child, last-child
+        matches = find_by_type(
+          [:CONDITIONAL_SELECTOR,
+            [:ELEMENT_NAME], [:PSEUDO_CLASS]
+        ])
+        matches.each do |match|
+          if ['first-child', 'last-child'].include?(match.value[1].value.first)
+            which = match.value[1].value.first.gsub(/-\w*$/, '')
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              Node.new(:FUNCTION, ["#{which}("]),
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          elsif 'only-child' == match.value[1].value.first
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              Node.new(:FUNCTION, ["#{match.value[1].value.first}("]),
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])                                        
+          end
+        end
+
+        self
+      end
+
+      def find_by_type(types)
+        matches = []
+        matches << self if to_type == types
+        @value.each do |v|
+          matches += v.find_by_type(types) if v.respond_to?(:find_by_type)
+        end
+        matches
+      end
+
+      def to_type
+        [@type] + @value.map { |n|
+          n.to_type if n.respond_to?(:to_type)
+        }.compact
+      end
+
+      def to_a
+        [@type] + @value.map { |n| n.respond_to?(:to_a) ? n.to_a : [n] }
+      end
+    end
+  end
+end

data/lib/nokogiri/css/parser.rb

@@ -0,0 +1,24 @@
+module Nokogiri
+  module CSS
+    class Parser < GeneratedParser
+      class << self
+        def parse string
+          new.parse(string)
+        end
+      end
+
+      def initialize
+        @tokenizer = Tokenizer.new
+      end
+
+      def parse string
+        @tokenizer.scan string
+        do_parse
+      end
+
+      def next_token
+        @tokenizer.next_token
+      end
+    end
+  end
+end

data/lib/nokogiri/css/parser.y

@@ -0,0 +1,198 @@
+class Nokogiri::CSS::GeneratedParser
+
+token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
+token COMMA URI CDO CDC NUMBER PERCENTAGE LENGTH EMS EXS ANGLE TIME FREQ
+token IMPORTANT_SYM IMPORT_SYM MEDIA_SYM PAGE_SYM CHARSET_SYM DIMENSION
+token PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL SLASH DOUBLESLASH
+token NOT
+
+rule
+  selector
+    : selector COMMA s_0toN simple_selector_1toN {
+        result = [val.first, val.last].flatten
+      }
+    | simple_selector_1toN { result = val.flatten }
+    ;
+  combinator
+    : PLUS s_0toN { result = :DIRECT_ADJACENT_SELECTOR }
+    | GREATER s_0toN { result = :CHILD_SELECTOR }
+    | TILDE s_0toN { result = :PRECEDING_SELECTOR }
+    | S { result = :DESCENDANT_SELECTOR }
+    | DOUBLESLASH s_0toN { result = :DESCENDANT_SELECTOR }
+    | SLASH s_0toN { result = :CHILD_SELECTOR }
+    ;
+  simple_selector
+    : element_name hcap_0toN {
+        result =  if val[1].nil?
+                    val.first
+                  else
+                    Node.new(:CONDITIONAL_SELECTOR, [val.first, val[1]])
+                  end
+      }
+    | element_name negation {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | function
+    | function attrib {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | hcap_1toN {
+        result = Node.new(:CONDITIONAL_SELECTOR,
+          [Node.new(:ELEMENT_NAME, ['*']), val.first]
+        )
+      }
+    ;
+  simple_selector_1toN
+    : simple_selector combinator simple_selector_1toN {
+        result = Node.new(val[1], [val.first, val.last])
+      }
+    | simple_selector
+    ;
+  class
+    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [val[1]]) }
+    ;
+  element_name
+    : IDENT { result = Node.new(:ELEMENT_NAME, val) }
+    | '*' { result = Node.new(:ELEMENT_NAME, val) }
+    ;
+  attrib
+    : '[' s_0toN IDENT s_0toN attrib_val_0or1 ']' {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [Node.new(:ELEMENT_NAME, [val[2]])] + (val[4] || [])
+        )
+      }
+    | '[' s_0toN function s_0toN attrib_val_0or1 ']' {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [val[2]] + (val[4] || [])
+        )
+      }
+    | '[' s_0toN NUMBER s_0toN ']' {
+        # Non standard, but hpricot supports it.
+        result = Node.new(:PSEUDO_CLASS,
+          [Node.new(:FUNCTION, ['nth-child(', val[2]])]
+        )
+      }
+    ;
+  function
+    : FUNCTION ')' {
+        result = Node.new(:FUNCTION, [val.first.strip])
+      }
+    | FUNCTION expr ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | FUNCTION an_plus_b ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | NOT expr ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    ;
+  expr
+    : NUMBER
+    | STRING
+    ;
+  an_plus_b
+    : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
+      {
+        if val[1] == 'n'
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | IDENT PLUS NUMBER {               # n+3, -n+3
+        if val[0] == 'n'
+          val.unshift("1")
+          result = Node.new(:AN_PLUS_B, val)
+        elsif val[0] == '-n'
+          val[0] = 'n'
+          val.unshift("-1")
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | NUMBER IDENT                      # 5n, -5n
+      {
+        if val[1] == 'n'
+          val << "+"
+          val << "0"
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | 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)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[0]}'"
+        end
+      }
+    ;
+  pseudo
+    : ':' function {
+        result = Node.new(:PSEUDO_CLASS, [val[1]])
+      }
+    | ':' IDENT { result = Node.new(:PSEUDO_CLASS, [val[1]]) }
+    ;
+  hcap_0toN
+    : hcap_1toN
+    |
+    ;
+  hcap_1toN
+    : attribute_id hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | class hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | attrib hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | pseudo hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | attribute_id
+    | class
+    | attrib
+    | pseudo
+    ;
+  attribute_id
+    : HASH { result = Node.new(:ID, val) }
+    ;
+  attrib_val_0or1
+    : eql_incl_dash s_0toN IDENT s_0toN { result = [val.first, val[2]] }
+    | eql_incl_dash s_0toN STRING s_0toN { result = [val.first, val[2]] }
+    |
+    ;
+  eql_incl_dash
+    : '='
+    | PREFIXMATCH
+    | SUFFIXMATCH
+    | SUBSTRINGMATCH
+    | NOT_EQUAL
+    | INCLUDES
+    | DASHMATCH
+    ;
+  negation
+    : NOT s_0toN negation_arg s_0toN ')' {
+        result = Node.new(:NOT, [val[2]])
+      }
+    ;
+  negation_arg
+    : hcap_1toN
+    ;
+  s_0toN
+    : S s_0toN
+    |
+    ;
+end
+
+---- header
+

data/lib/nokogiri/css/tokenizer.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module CSS
+    class Tokenizer < GeneratedTokenizer
+      def scan(str)
+        scan_evaluate(str)
+      end
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rex

@@ -0,0 +1,63 @@
+module Nokogiri
+module CSS
+class GeneratedTokenizer
+
+macro
+  nl        \n|\r\n|\r|\f
+  w         [\s\r\n\f]*
+  nonascii  [^\\\\0-\\\\177]
+  num       -?([0-9]+|[0-9]*\.[0-9]+)
+  unicode   \\\\\\\\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?
+
+  escape    {unicode}|\\\\\\\[^\n\r\f0-9a-f]
+  nmchar    [_a-z0-9-]|{nonascii}|{escape}
+  nmstart   [_a-z]|{nonascii}|{escape}
+  ident     [-]?({nmstart})({nmchar})*
+  name      ({nmchar})+
+  string1   "([^\n\r\f"]|\\{nl}|{nonascii}|{escape})*"
+  string2   '([^\n\r\f']|\\{nl}|{nonascii}|{escape})*'
+  string    {string1}|{string2}
+  invalid1  \"([^\n\r\f\\"]|\\{nl}|{nonascii}|{escape})*
+  invalid2  \'([^\n\r\f\\']|\\{nl}|{nonascii}|{escape})*
+  invalid   {invalid1}|{invalid2}
+  Comment   \/\*(.|[\r\n])*?\*\/
+
+rule
+
+# [:state]  pattern  [actions]
+
+            ~=               { [:INCLUDES, text] }
+            \|=              { [:DASHMATCH, text] }
+            \^=              { [:PREFIXMATCH, text] }
+            \$=              { [:SUFFIXMATCH, text] }
+            \*=              { [:SUBSTRINGMATCH, text] }
+            !=               { [:NOT_EQUAL, text] }
+            {ident}\(\s*     { [:FUNCTION, text] }
+            @{ident}         { [:IDENT, text] }
+            {ident}          { [:IDENT, text] }
+            {num}            { [:NUMBER, text] }
+            \#{name}         { [:HASH, text] }
+            {w}\+            { [:PLUS, text] }
+            {w}>             { [:GREATER, text] }
+            {w},             { [:COMMA, text] }
+            {w}~             { [:TILDE, text] }
+            \:not\(          { [:NOT, text] }
+            @{ident}         { [:ATKEYWORD, text] }
+            {num}%           { [:PERCENTAGE, text] }
+            {num}{ident}     { [:DIMENSION, text] }
+            <!--             { [:CDO, text] }
+            -->              { [:CDC, text] }
+            {w}\/\/          { [:DOUBLESLASH, text] }
+            {w}\/            { [:SLASH, text] }
+            
+            U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
+            
+            {Comment}                    /* ignore comments */
+            [\s\t\r\n\f]+    { [:S, text] }
+            [\.*:\[\]=\)]    { [text, text] }
+            {string}         { [:STRING, text] }
+            {invalid}        { [:INVALID, text] }
+            .                { [text, text] }
+end
+end
+end

data/lib/nokogiri/css/xpath_visitor.rb

@@ -0,0 +1,165 @@
+module Nokogiri
+  module CSS
+    class XPathVisitor
+      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)
+
+        case node.value.first
+        when /^text\(/
+          'child::text()'
+        when /^self\(/
+          "self::#{node.value[1]}"
+        when /^(eq|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])
+          else
+            "position() = " + node.value[1]
+          end
+        when /^(first|first-of-type)\(/
+          "position() = 1"
+        when /^(last|last-of-type)\(/
+          "position() = last()"
+        when /^(nth-last-child|nth-last-of-type)\(/
+          "position() = last() - #{node.value[1]}"
+        when /^contains\(/
+          "contains(., #{node.value[1]})"
+        when /^gt\(/
+          "position() > #{node.value[1]}"
+        when /^only-child\(/
+          "last() = 1"
+        else
+          node.value.first + ')'
+        end
+      end
+
+      def visit_not node
+        'not(' + node.value.first.accept(self) + ')'
+      end
+
+      def visit_preceding_selector node
+        node.value.last.accept(self) +
+          '[preceding-sibling::' +
+          node.value.first.accept(self) +
+          ']'
+      end
+
+      def visit_direct_adjacent_selector node
+        node.value.first.accept(self) +
+          "/following-sibling::*[1]/self::" +
+           node.value.last.accept(self)
+      end
+
+      def visit_id node
+        node.value.first =~ /^#(.*)$/
+        "@id = '#{$1}'"
+      end
+
+      def visit_attribute_condition node
+         attribute = if (node.value.first.type == :FUNCTION) or (node.value.first.value.first =~ /::/)
+                       ''
+                     else
+                       '@'
+                     end
+        attribute += node.value.first.accept(self)
+
+        # Support non-standard css
+        attribute.gsub!(/^@@/, '@')
+
+        return attribute unless node.value.length == 3
+
+        value = node.value.last
+        value = "'#{value}'" if value !~ /^['"]/
+
+        case node.value[1]
+        when '*='
+          "contains(#{attribute}, #{value})"
+        when '^='
+          "starts-with(#{attribute}, #{value})"
+        when '|='
+          "#{attribute} = #{value} or starts-with(#{attribute}, concat(#{value}, '-'))"
+        when '~='
+          "contains(concat(\" \", #{attribute}, \" \"),concat(\" \", #{value}, \" \"))"
+        when '$='
+          "substring(#{attribute}, string-length(#{attribute}) - " +
+            "string-length(#{value}) + 1, string-length(#{value})) = #{value}"
+        else
+          attribute + " #{node.value[1]} " + "#{value}"
+        end
+      end
+
+      def visit_pseudo_class node
+        if node.value.first.is_a?(Nokogiri::CSS::Node) and node.value.first.type == :FUNCTION
+          node.value.first.accept(self)
+        else
+          msg = :"visit_pseudo_class_#{node.value.first.gsub(/[(]/, '')}"
+          return self.send(msg, node) if self.respond_to?(msg)
+
+          case node.value.first
+          when "first" then "position() = 1"
+          when "last" then "position() = last()"
+          when "first-of-type" then "position() = 1"
+          when "last-of-type" then "position() = last()"
+          when "only-of-type" then "last() = 1"
+          when "empty" then "not(node())"
+          when "parent" then "node()"
+          when "root" then "not(parent::*)"
+          else
+            '1 = 1'
+          end
+        end
+      end
+
+      def visit_class_condition node
+        "contains(concat(' ', @class, ' '), ' #{node.value.first} ')"
+      end
+
+      def visit_combinator node
+        node.value.first.accept(self) + ' and ' +
+        node.value.last.accept(self)
+      end
+
+      def visit_conditional_selector node
+        node.value.first.accept(self) + '[' +
+        node.value.last.accept(self) + ']'
+      end
+
+      def visit_descendant_selector node
+        node.value.first.accept(self) +
+        '//' +
+        node.value.last.accept(self)
+      end
+
+      def visit_child_selector node
+        node.value.first.accept(self) +
+        '/' +
+        node.value.last.accept(self)
+      end
+
+      def visit_element_name node
+        node.value.first
+      end
+
+      def accept node
+        node.accept(self)
+      end
+
+    private
+      def an_plus_b node
+        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
+
+        if (b == 0)
+          return "(position() mod #{a}) = 0"
+        else
+          compare = (a < 0) ? "<=" : ">="
+          return "(position() #{compare} #{b}) and (((position()-#{b}) mod #{a.abs}) = 0)"
+        end
+      end
+
+    end
+  end
+end

data/lib/nokogiri/css.rb

@@ -0,0 +1,6 @@
+require 'nokogiri/css/node'
+require 'nokogiri/css/xpath_visitor'
+require 'nokogiri/css/generated_tokenizer'
+require 'nokogiri/css/generated_parser'
+require 'nokogiri/css/tokenizer'
+require 'nokogiri/css/parser'

data/lib/nokogiri/decorators/hpricot/node.rb

@@ -0,0 +1,58 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      module Node
+        def search *paths
+          ns = paths.last.is_a?(Hash) ? paths.pop : {}
+          converted = paths.map { |path|
+            convert_to_xpath(path)
+          }.flatten.uniq
+
+          namespaces = document.xml? ? document.namespaces.merge(ns) : ns
+          super(*converted + [namespaces])
+        end
+        def /(path); search(path) end
+
+        def xpath *args
+          return super if args.length > 0
+          path
+        end
+
+        def raw_attributes; self end
+
+        def get_element_by_id element_id
+          search("//*[@id='#{element_id}']").first
+        end
+
+        def get_elements_by_tag_name tag
+          search("//#{tag}")
+        end
+
+        def convert_to_xpath(rule)
+          rule = rule.to_s
+          case rule
+          when %r{^//}
+            [".#{rule}"]
+          when %r{^/}
+            [rule]
+          when %r{^.//}
+            [rule]
+          else
+            ctx = CSS::Parser.parse(rule)
+            visitor = CSS::XPathVisitor.new
+            visitor.extend(Hpricot::XPathVisitor)
+            ctx.map { |ast| './/' + visitor.accept(ast.preprocess!) }
+          end
+        end
+
+        def target
+          name
+        end
+
+        def to_original_html
+          to_html
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/decorators/hpricot/node_set.rb

@@ -0,0 +1,14 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      module NodeSet
+        def filter rule
+          ctx = CSS::Parser.parse(rule.to_s)
+          visitor = CSS::XPathVisitor.new
+          visitor.extend(Hpricot::XPathVisitor)
+          search('.//self::' + visitor.accept(ctx.first))
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/decorators/hpricot/xpath_visitor.rb

@@ -0,0 +1,17 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      ####
+      # This mixin does custom adjustments to deal with _whyML
+      module XPathVisitor
+        def visit_attribute_condition node
+          unless (node.value.first.type == :FUNCTION) or (node.value.first.value.first =~ /^@/)
+            node.value.first.value[0] = "child::" +
+              node.value.first.value[0]
+          end
+          super(node).gsub(/child::text\(\)/, 'normalize-space(child::text())')
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/decorators/hpricot.rb

@@ -0,0 +1,3 @@
+require 'nokogiri/decorators/hpricot/node'
+require 'nokogiri/decorators/hpricot/node_set'
+require 'nokogiri/decorators/hpricot/xpath_visitor'

data/lib/nokogiri/decorators.rb

@@ -0,0 +1 @@
+require 'nokogiri/decorators/hpricot'