nokogiri 1.0.0-x86-mswin32-60

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

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

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

@@ -0,0 +1,47 @@
+require 'nokogiri'
+
+module Nokogiri
+  module Hpricot
+    STag = String
+    Elem = XML::Node
+    NamedCharacters = Nokogiri::HTML::NamedCharacters
+    class << self
+      def parse(*args)
+        doc = Nokogiri.parse(*args)
+        add_decorators(doc)
+      end
+
+      def XML(string)
+        doc = Nokogiri::XML.parse(string)
+        add_decorators(doc)
+      end
+
+      def make string
+        ns = XML::NodeSet.new
+        ns << XML::Text.new(string)
+        ns
+      end
+
+      def add_decorators(doc)
+        doc.decorators['node'] << Decorators::Hpricot::Node
+        doc.decorators['element'] << Decorators::Hpricot::Node
+        doc.decorators['document'] << Decorators::Hpricot::Node
+        doc.decorators['nodeset'] << Decorators::Hpricot::NodeSet
+        doc.decorate!
+        doc
+      end
+    end
+  end
+  
+  class << self
+    def Hpricot(*args, &block)
+      if block_given?
+        builder = Nokogiri::HTML::Builder.new(&block)
+        Nokogiri::Hpricot.add_decorators(builder.doc)
+      else
+        doc = Nokogiri::HTML.parse(*args)
+        Nokogiri::Hpricot.add_decorators(doc)
+      end
+    end
+  end
+end

data/lib/nokogiri/html.rb

@@ -0,0 +1,95 @@
+require 'nokogiri/html/document'
+require 'nokogiri/html/sax/parser'
+
+module Nokogiri
+  class << self
+    def HTML thing, url = nil, encoding = nil, options = 2145
+      Nokogiri::HTML.parse(thing, url, encoding, options)
+    end
+  end
+
+  module HTML
+    # Parser options
+    PARSE_NOERROR   = 1 << 5  # No error reports
+    PARSE_NOWARNING = 1 << 6  # No warnings 
+    PARSE_PEDANTIC  = 1 << 7  # Pedantic errors
+    PARSE_NOBLANKS  = 1 << 8  # Remove blanks nodes
+    PARSE_NONET     = 1 << 11 # No network access
+
+    class << self
+      def parse string_or_io, url = nil, encoding = nil, options = 2145
+        if string_or_io.respond_to?(:read)
+          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+          string_or_io = string_or_io.read
+        end
+
+        Document.read_memory(string_or_io, url, encoding, options)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string
+        doc = parse(string)
+        finder = lambda { |children, f|
+          children.each do |child|
+            return children if string =~ /<#{child.name}/
+            finder.call(child.children, f)
+          end
+        }
+        finder.call(doc.children, finder)
+      end
+    end
+
+  NamedCharacters =
+{"AElig"=>198, "Aacute"=>193, "Acirc"=>194, "Agrave"=>192, "Alpha"=>913,
+ "Aring"=>197, "Atilde"=>195, "Auml"=>196, "Beta"=>914, "Ccedil"=>199,
+ "Chi"=>935, "Dagger"=>8225, "Delta"=>916, "ETH"=>208, "Eacute"=>201,
+ "Ecirc"=>202, "Egrave"=>200, "Epsilon"=>917, "Eta"=>919, "Euml"=>203,
+ "Gamma"=>915, "Iacute"=>205, "Icirc"=>206, "Igrave"=>204, "Iota"=>921,
+ "Iuml"=>207, "Kappa"=>922, "Lambda"=>923, "Mu"=>924, "Ntilde"=>209, "Nu"=>925,
+ "OElig"=>338, "Oacute"=>211, "Ocirc"=>212, "Ograve"=>210, "Omega"=>937,
+ "Omicron"=>927, "Oslash"=>216, "Otilde"=>213, "Ouml"=>214, "Phi"=>934,
+ "Pi"=>928, "Prime"=>8243, "Psi"=>936, "Rho"=>929, "Scaron"=>352, "Sigma"=>931,
+ "THORN"=>222, "Tau"=>932, "Theta"=>920, "Uacute"=>218, "Ucirc"=>219,
+ "Ugrave"=>217, "Upsilon"=>933, "Uuml"=>220, "Xi"=>926, "Yacute"=>221,
+ "Yuml"=>376, "Zeta"=>918, "aacute"=>225, "acirc"=>226, "acute"=>180,
+ "aelig"=>230, "agrave"=>224, "alefsym"=>8501, "alpha"=>945, "amp"=>38,
+ "and"=>8743, "ang"=>8736, "apos"=>39, "aring"=>229, "asymp"=>8776,
+ "atilde"=>227, "auml"=>228, "bdquo"=>8222, "beta"=>946, "brvbar"=>166,
+ "bull"=>8226, "cap"=>8745, "ccedil"=>231, "cedil"=>184, "cent"=>162,
+ "chi"=>967, "circ"=>710, "clubs"=>9827, "cong"=>8773, "copy"=>169,
+ "crarr"=>8629, "cup"=>8746, "curren"=>164, "dArr"=>8659, "dagger"=>8224,
+ "darr"=>8595, "deg"=>176, "delta"=>948, "diams"=>9830, "divide"=>247,
+ "eacute"=>233, "ecirc"=>234, "egrave"=>232, "empty"=>8709, "emsp"=>8195,
+ "ensp"=>8194, "epsilon"=>949, "equiv"=>8801, "eta"=>951, "eth"=>240,
+ "euml"=>235, "euro"=>8364, "exist"=>8707, "fnof"=>402, "forall"=>8704,
+ "frac12"=>189, "frac14"=>188, "frac34"=>190, "frasl"=>8260, "gamma"=>947,
+ "ge"=>8805, "gt"=>62, "hArr"=>8660, "harr"=>8596, "hearts"=>9829,
+ "hellip"=>8230, "iacute"=>237, "icirc"=>238, "iexcl"=>161, "igrave"=>236,
+ "image"=>8465, "infin"=>8734, "int"=>8747, "iota"=>953, "iquest"=>191,
+ "isin"=>8712, "iuml"=>239, "kappa"=>954, "lArr"=>8656, "lambda"=>955,
+ "lang"=>9001, "laquo"=>171, "larr"=>8592, "lceil"=>8968, "ldquo"=>8220,
+ "le"=>8804, "lfloor"=>8970, "lowast"=>8727, "loz"=>9674, "lrm"=>8206,
+ "lsaquo"=>8249, "lsquo"=>8216, "lt"=>60, "macr"=>175, "mdash"=>8212,
+ "micro"=>181, "middot"=>183, "minus"=>8722, "mu"=>956, "nabla"=>8711,
+ "nbsp"=>160, "ndash"=>8211, "ne"=>8800, "ni"=>8715, "not"=>172, "notin"=>8713,
+ "nsub"=>8836, "ntilde"=>241, "nu"=>957, "oacute"=>243, "ocirc"=>244,
+ "oelig"=>339, "ograve"=>242, "oline"=>8254, "omega"=>969, "omicron"=>959,
+ "oplus"=>8853, "or"=>8744, "ordf"=>170, "ordm"=>186, "oslash"=>248,
+ "otilde"=>245, "otimes"=>8855, "ouml"=>246, "para"=>182, "part"=>8706,
+ "permil"=>8240, "perp"=>8869, "phi"=>966, "pi"=>960, "piv"=>982,
+ "plusmn"=>177, "pound"=>163, "prime"=>8242, "prod"=>8719, "prop"=>8733,
+ "psi"=>968, "quot"=>34, "rArr"=>8658, "radic"=>8730, "rang"=>9002,
+ "raquo"=>187, "rarr"=>8594, "rceil"=>8969, "rdquo"=>8221, "real"=>8476,
+ "reg"=>174, "rfloor"=>8971, "rho"=>961, "rlm"=>8207, "rsaquo"=>8250,
+ "rsquo"=>8217, "sbquo"=>8218, "scaron"=>353, "sdot"=>8901, "sect"=>167,
+ "shy"=>173, "sigma"=>963, "sigmaf"=>962, "sim"=>8764, "spades"=>9824,
+ "sub"=>8834, "sube"=>8838, "sum"=>8721, "sup"=>8835, "sup1"=>185, "sup2"=>178,
+ "sup3"=>179, "supe"=>8839, "szlig"=>223, "tau"=>964, "there4"=>8756,
+ "theta"=>952, "thetasym"=>977, "thinsp"=>8201, "thorn"=>254, "tilde"=>732,
+ "times"=>215, "trade"=>8482, "uArr"=>8657, "uacute"=>250, "uarr"=>8593,
+ "ucirc"=>251, "ugrave"=>249, "uml"=>168, "upsih"=>978, "upsilon"=>965,
+ "uuml"=>252, "weierp"=>8472, "xi"=>958, "yacute"=>253, "yen"=>165,
+ "yuml"=>255, "zeta"=>950, "zwj"=>8205, "zwnj"=>8204}
+  end
+end