nokogiri 1.3.0-x86-mingw32

data/lib/nokogiri/css/syntax_error.rb

@@ -0,0 +1,7 @@
+require 'nokogiri/syntax_error'
+module Nokogiri
+  module CSS
+    class SyntaxError < ::Nokogiri::SyntaxError
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module CSS
+    class Tokenizer < GeneratedTokenizer
+      ###
+      # Scan and tokenize +str+
+      def scan(str)
+        scan_evaluate(str)
+      end
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rex

@@ -0,0 +1,54 @@
+module Nokogiri
+module CSS
+class GeneratedTokenizer < GeneratedParser
+
+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-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?
+
+  escape    {unicode}|\\\\\\\[^\n\r\f0-9A-Fa-f]
+  nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
+  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})*'
+  string    {string1}|{string2}
+
+rule
+
+# [:state]  pattern  [actions]
+
+            {ident}\(\s*     { [:FUNCTION, text] }
+            {ident}          { [:IDENT, text] }
+            \#{name}         { [:HASH, text] }
+            {w}~={w}         { [:INCLUDES, text] }
+            {w}\|={w}        { [:DASHMATCH, text] }
+            {w}\^={w}        { [:PREFIXMATCH, text] }
+            {w}\$={w}        { [:SUFFIXMATCH, text] }
+            {w}\*={w}        { [:SUBSTRINGMATCH, text] }
+            {w}!={w}         { [:NOT_EQUAL, text] }
+            {w}={w}          { [:EQUAL, text] }
+            {w}\)            { [:RPAREN, text] }
+            {w}\[{w}         { [:LSQUARE, text] }
+            {w}\]            { [:RSQUARE, text] }
+            {w}\+{w}         { [:PLUS, text] }
+            {w}>{w}          { [:GREATER, text] }
+            {w},{w}          { [:COMMA, text] }
+            {w}~{w}          { [:TILDE, text] }
+            \:not\({w}       { [:NOT, text] }
+            {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\t\r\n\f]+    { [:S, text] }
+            {string}         { [:STRING, text] }
+            .                { [text, text] }
+end
+end
+end

data/lib/nokogiri/css/xpath_visitor.rb

@@ -0,0 +1,172 @@
+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)
+
+        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"
+        when /^comment\(/
+          "comment()"
+        else
+          args = ['.'] + node.value[1..-1]
+          "#{node.value.first}#{args.join(', ')})"
+        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 :equal
+          attribute + " = " + "#{value}"
+        when :not_equal
+          attribute + " != " + "#{value}"
+        when :substring_match
+          "contains(#{attribute}, #{value})"
+        when :prefix_match
+          "starts-with(#{attribute}, #{value})"
+        when :dash_match
+          "#{attribute} = #{value} or starts-with(#{attribute}, concat(#{value}, '-'))"
+        when :includes
+          "contains(concat(\" \", #{attribute}, \" \"),concat(\" \", #{value}, \" \"))"
+        when :suffix_match
+          "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
+            node.value.first + "(.)"
+          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,2 @@
+require 'nokogiri/decorators/hpricot'
+require 'nokogiri/decorators/slop'

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,56 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      module Node # :nodoc:
+        def search *paths
+          ns = paths.last.is_a?(Hash) ? paths.pop : {}
+          converted = paths.map { |path|
+            convert_to_xpath(path)
+          }.flatten.uniq
+
+          super(*converted + [ns])
+        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{^//}
+            [".#{Hpricot::XPathVisitor.xpath_namespace_helper(rule)}"]
+          when %r{^/}
+            [Hpricot::XPathVisitor.xpath_namespace_helper(rule)]
+          when %r{^.//}
+            [Hpricot::XPathVisitor.xpath_namespace_helper(rule)]
+          else
+            visitor = CSS::XPathVisitor.new
+            visitor.extend(Hpricot::XPathVisitor)
+            CSS.xpath_for(rule, :prefix => ".//", :visitor => visitor)
+          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,54 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      module NodeSet
+
+        # Select nodes matching the supplied rule.
+        # Note that positional rules (like <tt>:nth()</tt>) aren't currently supported.
+        #
+        # example:
+        #   node_set.filter('.ohmy')          # selects nodes from the set with class "ohmy"
+        #   node_set.filter('a#link2')        # selects nodes from the set with child node <a id='link2'>
+        #   node_set.filter('a[@id="link2"]') # selects nodes from the set with child node <a id='link2'>
+        def filter(rule)
+          filter_transformer( lambda {|j| j}, rule ) # identity transformer
+        end
+
+        # The complement to filter, select nodes <em>not</em> matching the supplied rule.
+        # Note that positional rules (like <tt>:nth()</tt>) aren't currently supported.
+        #
+        # See filter for examples.
+        #
+        # Also note that you can pass a XML::Node object instead of a
+        # rule to remove that object from the node set (if it is
+        # present):
+        #    node_set.not(node_to_exclude) # selects all nodes EXCEPT node_to_exclude
+        #
+        def not(rule)
+          filter_transformer( lambda {|j| !j}, rule ) # negation transformer
+        end
+
+      private
+        def filter_transformer(transformer, rule) # :nodoc:
+          sub_set = XML::NodeSet.new(document)
+          document.decorate(sub_set)
+
+          if rule.is_a?(XML::Node)
+            each { |node| sub_set << node if transformer.call(node == rule) }
+            return sub_set
+          end
+
+          ctx = CSS.parse(rule.to_s)
+          visitor = CSS::XPathVisitor.new
+          visitor.extend(Hpricot::XPathVisitor)
+          each do |node|
+            if transformer.call(node.at(".//self::" + visitor.accept(ctx.first)))
+              sub_set << node
+            end
+          end
+          sub_set
+        end          
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Nokogiri
+  module Decorators
+    module Hpricot
+      ####
+      # This mixin does custom adjustments to deal with _whyML
+      module XPathVisitor
+        ###
+        # Visit attribute condition nodes with +node+
+        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
+
+        #  take a path like '//t:sam' and convert to xpath "*[name()='t:sam']"
+        def self.xpath_namespace_helper rule
+          rule.split(/\//).collect do |tag|
+            if match = tag.match(/^(\w+:\w+)(.*)/)
+              "*[name()='#{match[1]}']#{match[2]}"
+            else
+              tag
+            end
+          end.join("/")
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/decorators/slop.rb

@@ -0,0 +1,33 @@
+module Nokogiri
+  module Decorators
+    ###
+    # The Slop decorator implements method missing such that a methods may be
+    # used instead of XPath or CSS.  See Nokogiri.Slop
+    module Slop
+      ###
+      # look for node with +name+.  See Nokogiri.Slop
+      def method_missing name, *args, &block
+        if args.empty?
+          list = xpath("./#{name}")
+        elsif args.first.is_a? Hash
+          hash = args.first
+          if hash[:css]
+            list = css("#{name}#{hash[:css]}")
+          elsif hash[:xpath]
+            conds = Array(hash[:xpath]).join(' and ')
+            list = xpath("./#{name}[#{conds}]")
+          end
+        else
+          CSS::Parser.without_cache do
+            list = xpath(
+              *CSS.xpath_for("#{name}#{args.first}", :prefix => "./")
+            )
+          end
+        end
+
+        super if list.empty?
+        list.length == 1 ? list.first : list
+      end
+    end
+  end
+end

data/lib/nokogiri/ffi/html/document.rb

@@ -0,0 +1,37 @@
+module Nokogiri
+  module HTML
+    class Document < XML::Document
+
+      attr_accessor :cstruct # :nodoc:
+
+      def self.new(*args) # :nodoc:
+        uri         = args[0]
+        external_id = args[1]
+        doc = wrap(LibXML.htmlNewDoc(uri, external_id))
+        doc.send :initialize, *args
+        doc
+      end
+
+      def self.read_io(io, url, encoding, options) # :nodoc:
+        wrap_with_error_handling do
+          LibXML.htmlReadIO(IoCallbacks.reader(io), nil, nil, url, encoding, options)
+        end
+      end
+
+      def self.read_memory(string, url, encoding, options) # :nodoc:
+        wrap_with_error_handling do
+          LibXML.htmlReadMemory(string, string.length, url, encoding, options)
+        end
+      end
+
+      def meta_encoding=(encoding) # :nodoc:
+        LibXML.htmlSetMetaEncoding(cstruct, encoding)
+        encoding
+      end
+
+      def meta_encoding # :nodoc:
+        LibXML.htmlGetMetaEncoding(cstruct)
+      end
+    end
+  end
+end