tenderlove-nokogiri 0.0.0.20081001111445

data/lib/nokogiri.rb

@@ -0,0 +1,45 @@
+require 'nokogiri/version'
+require 'nokogiri/xml'
+require 'nokogiri/xslt'
+require 'nokogiri/html'
+require 'nokogiri/decorators'
+require 'nokogiri/css'
+require 'nokogiri/html/builder'
+require 'nokogiri/hpricot'
+require 'nokogiri/native'
+
+module Nokogiri
+  class << self
+    def parse(string, url = nil, encoding = nil, options = 32)
+      doc =
+        if string =~ /^\s*<[^Hh>]*html/i # Probably html
+          Nokogiri::HTML.parse(string, url, encoding, options)
+        else
+          Nokogiri::XML.parse(string, url, encoding, options)
+        end
+      yield doc if block_given?
+      doc
+    end
+
+    def XML(string)
+      Nokogiri::XML.parse(string)
+    end
+
+    def make(input = nil, opts = {}, &blk)
+      if input
+        Nokogiri::XML::Node.new_from_str(input)
+      else
+        Nokogiri(&blk)
+      end
+    end
+  end
+end
+
+def Nokogiri(*args, &block)
+  if block_given?
+    builder = Nokogiri::HTML::Builder.new(&block)
+    return builder.doc
+  else
+    Nokogiri::HTML.parse(*args)
+  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/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.to_a }
+      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 { result = :DESCENDANT_SELECTOR }
+    | SLASH { 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] }
+            \/\/             { [:DOUBLESLASH, text] }
+            \/               { [: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