green_shoes 0.189.0 → 0.198.0

data/LICENSE

@@ -3,6 +3,7 @@ Copyright (c) 2010-2011 ashbb
 Except:
 
     * hh/static/(all).png (c) 2008 why the lucky stiff
+    * lib/ext/hpricot/(all) (c) 2008 why the lucky stiff
     * lib/ext/projector/(all).rb (c) 2010 MIZUTANI Tociyuki
     * samples/akatsukiface.png (c) 2010 MIZUTANI Tociyuki
     * samples/class-book.yaml (c) 2008 why the lucky stiff
@@ -13,6 +14,9 @@ Except:
     * static/Lacuna.ttf (c) 2003 Glashaus, designed by Peter Hoffman
     * static/gshoes-icon.png (c) 2010 Zachary Scott
     * static/gshoes-heading-icon.png (c) 2010 Zachary Scott
+    * static/code_highlighter.js (c) 2005 Dan Webb
+    * static/code_highlighter_ruby.js (c) 2008 why the lucky stiff
+    * static/manual.css (c) 2008 why the lucky stiff
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/README.md

@@ -97,6 +97,7 @@ Copyright (c) 2010-2011 ashbb
 Except:
 
 - hh/static/(all).png (c) 2008 why the lucky stiff
+- lib/ext/hpricot/(all) (c) 2008 why the lucky stiff
 - lib/ext/projector/(all).rb (c) 2010 MIZUTANI Tociyuki
 - samples/akatsukiface.png (c) 2010 MIZUTANI Tociyuki
 - samples/class-book.yaml (c) 2008 why the lucky stiff
@@ -107,6 +108,9 @@ Except:
 - static/Lacuna.ttf (c) 2003 Glashaus, designed by Peter Hoffman
 - static/gshoes-icon.png (c) 2010 Zachary Scott
 - static/gshoes-heading-icon.png (c) 2010 Zachary Scott
+- static/code_highlighter.js (c) 2005 Dan Webb
+- static/code_highlighter_ruby.js (c) 2008 why the lucky stiff
+- static/manual.css (c) 2008 why the lucky stiff
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/VERSION

@@ -1 +1 @@
-0.189.0
+0.198.0

data/lib/ext/hpricot.rb

@@ -0,0 +1,31 @@
+# == About hpricot.rb
+#
+# All of Hpricot's various part are loaded when you use <tt>require 'hpricot'</tt>.
+#
+# * hpricot_scan: the scanner (a C extension for Ruby) which turns an HTML stream into tokens.
+# * hpricot/parse.rb: uses the scanner to sort through tokens and give you back a complete document object.
+# * hpricot/tag.rb: sets up objects for the various types of elements in an HTML document.
+# * hpricot/modules.rb: categorizes the various elements using mixins.
+# * hpricot/traverse.rb: methods for searching documents.
+# * hpricot/elements.rb: methods for dealing with a group of elements as an Hpricot::Elements list.
+# * hpricot/inspect.rb: methods for displaying documents in a readable form.
+
+# If available, Nikolai's UTF-8 library will ease use of utf-8 documents.
+# See http://git.bitwi.se/ruby-character-encodings.git/.
+begin
+  require 'encoding/character/utf-8'
+rescue LoadError
+end
+
+require_relative 'hpricot/hpricot_scan'
+require_relative 'hpricot/tag'
+require_relative 'hpricot/modules'
+require_relative 'hpricot/elements'
+require_relative 'hpricot/traverse'
+require_relative 'hpricot/inspect'
+require_relative 'hpricot/parse'
+require_relative 'hpricot/tags'
+require_relative 'hpricot/blankslate'
+require_relative 'hpricot/htmlinfo'
+require_relative 'hpricot/builder'
+require_relative 'hpricot/xchar'

data/lib/ext/hpricot/blankslate.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module Hpricot
+
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BlankSlate
+    class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+	undef_method name if
+	  instance_methods.include?(name) and
+	  name !~ /^(__|instance_eval|object_id)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+end
+
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any defined
+module Kernel
+  class << self
+    alias_method :hpricot_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      hpricot_slate_method_added(name)
+      return if self != Kernel
+      Hpricot::BlankSlate.hide(name)
+    end
+  end
+end
+
+class Object
+  class << self
+    alias_method :hpricot_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      hpricot_slate_method_added(name)
+      return if self != Object
+      Hpricot::BlankSlate.hide(name)
+    end
+  end
+end

data/lib/ext/hpricot/builder.rb

@@ -0,0 +1,216 @@
+#require 'hpricot/tags'
+#require 'fast_xs'
+#require 'hpricot/blankslate'
+#require 'hpricot/htmlinfo'
+
+module Hpricot
+  # XML unescape
+  def self.uxs(str)
+    str.to_s.
+        gsub(/\&(\w+);/) { [NamedCharacters[$1] || ??].pack("U*") }.
+        gsub(/\&\#(\d+);/) { [$1.to_i].pack("U*") }
+  end
+
+  def self.build(ele = Doc.new, assigns = {}, &blk)
+    ele.extend Builder
+    assigns.each do |k, v|
+      ele.instance_variable_set("@#{k}", v)
+    end
+    ele.instance_eval(&blk)
+    ele
+  end
+
+  module Builder
+
+    @@default = {
+      :indent => 0,
+      :output_helpers => true,
+      :output_xml_instruction => true,
+      :output_meta_tag => true,
+      :auto_validation => true,
+      :tagset => Hpricot::XHTMLTransitional,
+      :root_attributes => {
+        :xmlns => 'http://www.w3.org/1999/xhtml', :'xml:lang' => 'en', :lang => 'en'
+      }
+    }
+
+    def self.set(option, value)
+      @@default[option] = value
+    end
+
+    def add_child ele
+      ele.parent = self
+      self.children ||= []
+      self.children << ele
+      ele
+    end
+
+    # Write a +string+ to the HTML stream, making sure to escape it.
+    def text!(string)
+      add_child Text.new(string)
+    end
+
+    # Write a +string+ to the HTML stream without escaping it.
+    def text(string)
+      add_child Text.new(string)
+      nil
+    end
+    alias_method :<<, :text
+    alias_method :concat, :text
+
+    # Create a tag named +tag+. Other than the first argument which is the tag name,
+    # the arguments are the same as the tags implemented via method_missing.
+    def tag!(tag, *args, &block)
+      ele_id = nil
+      if @auto_validation and @tagset
+          if !@tagset.tagset.has_key?(tag)
+              raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
+          elsif args.last.respond_to?(:to_hash)
+              attrs = args.last.to_hash
+
+              if @tagset.forms.include?(tag) and attrs[:id]
+                attrs[:name] ||= attrs[:id]
+              end
+
+              attrs.each do |k, v|
+                  atname = k.to_s.downcase.intern
+                  unless k =~ /:/ or @tagset.tagset[tag].include? atname
+                      raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
+                  end
+                  if atname == :id
+                      ele_id = v.to_s
+                      if @elements.has_key? ele_id
+                          raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
+                      end
+                  end
+              end
+          end
+      end
+
+      # turn arguments into children or attributes
+      childs = []
+      attrs = args.grep(Hash)
+      childs.concat((args - attrs).flatten.map do |x|
+        if x.respond_to? :to_html
+          Hpricot.make(x.to_html)
+        elsif x
+          Text.new(x)
+        end
+      end.flatten)
+      attrs = attrs.inject({}) do |hsh, ath|
+        ath.each do |k, v|
+          hsh[k] = v.to_s if v
+        end
+        hsh
+      end
+
+      # create the element itself
+      tag = tag.to_s
+      f = Elem.new(tag, attrs, childs, ETag.new(tag))
+
+      # build children from the block
+      if block
+        build(f, &block)
+      end
+
+      add_child f
+      f
+    end
+
+    def build(*a, &b)
+      Hpricot.build(*a, &b)
+    end
+
+    # Every HTML tag method goes through an html_tag call.  So, calling <tt>div</tt> is equivalent
+    # to calling <tt>html_tag(:div)</tt>.  All HTML tags in Hpricot's list are given generated wrappers
+    # for this method.
+    #
+    # If the @auto_validation setting is on, this method will check for many common mistakes which
+    # could lead to invalid XHTML.
+    def html_tag(sym, *args, &block)
+      if @auto_validation and @tagset.self_closing.include?(sym) and block
+        raise InvalidXhtmlError, "the `#{sym}' element is self-closing, please remove the block"
+      elsif args.empty? and block.nil?
+        CssProxy.new(self, sym)
+      else
+        tag!(sym, *args, &block)
+      end
+    end
+
+    XHTMLTransitional.tags.each do |k|
+      class_eval %{
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *args, &block)
+        end
+      }
+    end
+
+    def doctype(target, pub, sys)
+      add_child DocType.new(target, pub, sys)
+    end
+
+    remove_method :head
+
+    # Builds a head tag.  Adds a <tt>meta</tt> tag inside with Content-Type
+    # set to <tt>text/html; charset=utf-8</tt>.
+    def head(*args, &block)
+      tag!(:head, *args) do
+        tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag
+        instance_eval(&block)
+      end
+    end
+
+    # Builds an html tag.  An XML 1.0 instruction and an XHTML 1.0 Transitional doctype
+    # are prepended.  Also assumes <tt>:xmlns => "http://www.w3.org/1999/xhtml",
+    # :lang => "en"</tt>.
+    def xhtml_transitional(attrs = {}, &block)
+      # self.tagset = Hpricot::XHTMLTransitional
+      xhtml_html(attrs, &block)
+    end
+
+    # Builds an html tag with XHTML 1.0 Strict doctype instead.
+    def xhtml_strict(attrs = {}, &block)
+      # self.tagset = Hpricot::XHTMLStrict
+      xhtml_html(attrs, &block)
+    end
+
+    private
+
+    def xhtml_html(attrs = {}, &block)
+      instruct! if @output_xml_instruction
+      doctype(:html, *@@default[:tagset].doctype)
+      tag!(:html, @@default[:root_attributes].merge(attrs), &block)
+    end
+
+  end
+
+  # Class used by Markaby::Builder to store element options.  Methods called
+  # against the CssProxy object are added as element classes or IDs.
+  #
+  # See the README for examples.
+  class CssProxy < BlankSlate
+
+    # Creates a CssProxy object.
+    def initialize(builder, sym)
+      @builder, @sym, @attrs = builder, sym, {}
+    end
+
+    # Adds attributes to an element.  Bang methods set the :id attribute.
+    # Other methods add to the :class attribute.
+    def method_missing(id_or_class, *args, &block)
+      if (idc = id_or_class.to_s) =~ /!$/
+        @attrs[:id] = $`
+      else
+        @attrs[:class] = @attrs[:class].nil? ? idc : "#{@attrs[:class]} #{idc}".strip
+      end
+
+      if block or args.any?
+        args.push(@attrs)
+        return @builder.tag!(@sym, *args, &block)
+      end
+
+      return self
+    end
+
+  end
+end

data/lib/ext/hpricot/elements.rb

@@ -0,0 +1,510 @@
+module Hpricot
+# Once you've matched a list of elements, you will often need to handle them as
+# a group.  Or you may want to perform the same action on each of them.
+# Hpricot::Elements is an extension of Ruby's array class, with some methods
+# added for altering elements contained in the array.
+#
+# If you need to create an element array from regular elements:
+#
+#   Hpricot::Elements[ele1, ele2, ele3]
+#
+# Assuming that ele1, ele2 and ele3 contain element objects (Hpricot::Elem,
+# Hpricot::Doc, etc.)  
+#
+# == Continuing Searches
+#
+# Usually the Hpricot::Elements you're working on comes from a search you've
+# done.  Well, you can continue searching the list by using the same <tt>at</tt>
+# and <tt>search</tt> methods you can use on plain elements.
+#
+#   elements = doc.search("/div/p")
+#   elements = elements.search("/a[@href='http://hoodwink.d/']")
+#   elements = elements.at("img")
+#
+# == Altering Elements
+#
+# When you're altering elements in the list, your changes will be reflected in
+# the document you started searching from.
+#
+#   doc = Hpricot("That's my <b>spoon</b>, Tyler.")
+#   doc.at("b").swap("<i>fork</i>")
+#   doc.to_html
+#     #=> "That's my <i>fork</i>, Tyler." 
+#
+# == Getting More Detailed
+#
+# If you can't find a method here that does what you need, you may need to
+# loop through the elements and find a method in Hpricot::Container::Trav
+# which can do what you need.
+#
+# For example, you may want to search for all the H3 header tags in a document
+# and grab all the tags underneath the header, but not inside the header.
+# A good method for this is <tt>next_sibling</tt>:
+#
+#   doc.search("h3").each do |h3|
+#     while ele = h3.next_sibling
+#       ary << ele   # stuff away all the elements under the h3
+#     end
+#   end
+#
+# Most of the useful element methods are in the mixins Hpricot::Traverse
+# and Hpricot::Container::Trav.
+  class Elements < Array
+  
+    # Searches this list for any elements (or children of these elements) matching
+    # the CSS or XPath expression +expr+.  Root is assumed to be the element scanned.
+    #
+    # See Hpricot::Container::Trav.search for more.
+    def search(*expr,&blk)
+      Elements[*map { |x| x.search(*expr,&blk) }.flatten.uniq]
+    end
+    alias_method :/, :search
+
+    # Searches this list for the first element (or child of these elements) matching
+    # the CSS or XPath expression +expr+.  Root is assumed to be the element scanned.
+    #
+    # See Hpricot::Container::Trav.at for more.
+    def at(expr, &blk)
+      search(expr, &blk).first
+    end
+    alias_method :%, :at
+
+    # Convert this group of elements into a complete HTML fragment, returned as a
+    # string.
+    def to_html
+      map { |x| x.output("") }.join
+    end
+    alias_method :to_s, :to_html
+
+    # Returns an HTML fragment built of the contents of each element in this list.
+    #
+    # If a HTML +string+ is supplied, this method acts like inner_html=.
+    def inner_html(*string)
+      if string.empty?
+        map { |x| x.inner_html }.join
+      else
+        x = self.inner_html = string.pop || x
+      end
+    end
+    alias_method :html, :inner_html
+    alias_method :innerHTML, :inner_html
+
+    # Replaces the contents of each element in this list.  Supply an HTML +string+,
+    # which is loaded into Hpricot objects and inserted into every element in this
+    # list.
+    def inner_html=(string)
+      each { |x| x.inner_html = string }
+    end
+    alias_method :html=, :inner_html=
+    alias_method :innerHTML=, :inner_html=
+
+    # Returns an string containing the text contents of each element in this list.
+    # All HTML tags are removed.
+    def inner_text
+      map { |x| x.inner_text }.join
+    end
+    alias_method :text, :inner_text
+
+    # Remove all elements in this list from the document which contains them.
+    #
+    #   doc = Hpricot("<html>Remove this: <b>here</b></html>")
+    #   doc.search("b").remove
+    #   doc.to_html
+    #     => "<html>Remove this: </html>"
+    #
+    def remove
+      each { |x| x.parent.children.delete(x) }
+    end
+
+    # Empty the elements in this list, by removing their insides.
+    #
+    #   doc = Hpricot("<p> We have <i>so much</i> to say.</p>")
+    #   doc.search("i").empty
+    #   doc.to_html
+    #     => "<p> We have <i></i> to say.</p>"
+    #
+    def empty
+      each { |x| x.inner_html = nil }
+    end
+
+    # Add to the end of the contents inside each element in this list.
+    # Pass in an HTML +str+, which is turned into Hpricot elements.
+    def append(str = nil, &blk)
+      each { |x| x.html(x.children + x.make(str, &blk)) }
+    end
+
+    # Add to the start of the contents inside each element in this list.
+    # Pass in an HTML +str+, which is turned into Hpricot elements.
+    def prepend(str = nil, &blk)
+      each { |x| x.html(x.make(str, &blk) + x.children) }
+    end
+ 
+    # Add some HTML just previous to each element in this list.
+    # Pass in an HTML +str+, which is turned into Hpricot elements.
+    def before(str = nil, &blk)
+      each { |x| x.parent.insert_before x.make(str, &blk), x }
+    end
+
+    # Just after each element in this list, add some HTML.
+    # Pass in an HTML +str+, which is turned into Hpricot elements.
+    def after(str = nil, &blk)
+      each { |x| x.parent.insert_after x.make(str, &blk), x }
+    end
+
+    # Wraps each element in the list inside the element created by HTML +str+. 
+    # If more than one element is found in the string, Hpricot locates the
+    # deepest spot inside the first element.
+    #
+    #  doc.search("a[@href]").
+    #      wrap(%{<div class="link"><div class="link_inner"></div></div>})
+    #
+    # This code wraps every link on the page inside a +div.link+ and a +div.link_inner+ nest.
+    def wrap(str = nil, &blk)
+      each do |x|
+        wrap = x.make(str, &blk)
+        nest = wrap.detect { |w| w.respond_to? :children }
+        unless nest
+          raise "No wrapping element found."
+        end
+        x.parent.replace_child(x, wrap)
+        nest = nest.children.first until nest.empty?
+        nest.html([x])
+      end
+    end
+
+    # Gets and sets attributes on all matched elements.
+    #
+    # Pass in a +key+ on its own and this method will return the string value
+    # assigned to that attribute for the first elements.  Or +nil+ if the 
+    # attribute isn't found.
+    #
+    #   doc.search("a").attr("href")
+    #     #=> "http://hacketyhack.net/"
+    #
+    # Or, pass in a +key+ and +value+.  This will set an attribute for all
+    # matched elements.
+    #
+    #   doc.search("p").attr("class", "basic")
+    # 
+    # You may also use a Hash to set a series of attributes:
+    #
+    #   (doc/"a").attr(:class => "basic", :href => "http://hackety.org/")
+    # 
+    # Lastly, a block can be used to rewrite an attribute based on the element
+    # it belongs to.  The block will pass in an element.  Return from the block
+    # the new value of the attribute.
+    #
+    #   records.attr("href") { |e| e['href'] + "#top" }
+    #
+    # This example adds a <tt>#top</tt> anchor to each link.
+    #
+    def attr key, value = nil, &blk
+      if value or blk
+        each do |el|
+          el.set_attribute(key, value || blk[el])
+        end
+        return self      
+      end    
+      if key.is_a? Hash
+        key.each { |k,v| self.attr(k,v) }
+        return self
+      else
+        return self[0].get_attribute(key)
+      end
+    end
+    alias_method :set, :attr
+  
+    # Adds the class to all matched elements.
+    #
+    #   (doc/"p").add_class("bacon")
+    #
+    # Now all paragraphs will have class="bacon".
+    def add_class class_name
+      each do |el|
+        next unless el.respond_to? :get_attribute
+        classes = el.get_attribute('class').to_s.split(" ")
+        el.set_attribute('class', classes.push(class_name).uniq.join(" "))
+      end
+      self
+    end
+
+    # Remove an attribute from each of the matched elements.
+    #
+    #   (doc/"input").remove_attr("disabled")
+    #
+    def remove_attr name
+      each do |el|
+        next unless el.respond_to? :remove_attribute
+        el.remove_attribute(name)
+      end
+      self      
+    end
+
+    # Removes a class from all matched elements.
+    #
+    #   (doc/"span").remove_class("lightgrey")
+    #
+    # Or, to remove all classes:
+    #
+    #   (doc/"span").remove_class
+    # 
+    def remove_class name = nil
+      each do |el|
+        next unless el.respond_to? :get_attribute
+        if name
+          classes = el.get_attribute('class').to_s.split(" ")
+          el.set_attribute('class', (classes - [name]).uniq.join(" "))
+        else
+          el.remove_attribute("class")
+        end
+      end
+      self      
+    end
+
+    ATTR_RE = %r!\[ *(?:(@)([\w\(\)-]+)|([\w\(\)-]+\(\))) *([~\!\|\*$\^=]*) *'?"?([^'"]*)'?"? *\]!i
+    BRACK_RE = %r!(\[) *([^\]]*) *\]+!i
+    FUNC_RE = %r!(:)?([a-zA-Z0-9\*_-]*)\( *[\"']?([^ \)]*?)['\"]? *\)!
+    CUST_RE = %r!(:)([a-zA-Z0-9\*_-]*)()!
+    CATCH_RE = %r!([:\.#]*)([a-zA-Z0-9\*_-]+)!
+
+    def self.filter(nodes, expr, truth = true)
+        until expr.empty?
+            _, *m = *expr.match(/^(?:#{ATTR_RE}|#{BRACK_RE}|#{FUNC_RE}|#{CUST_RE}|#{CATCH_RE})/)
+            break unless _
+
+            expr = $'
+            m.compact!
+            if m[0] == '@'
+                m[0] = "@#{m.slice!(2,1).join}"
+            end
+
+            if m[0] == '[' && m[1] =~ /^\d+$/
+                m = [":", "nth", m[1].to_i-1]
+            end
+
+            if m[0] == ":" && m[1] == "not"
+                nodes, = Elements.filter(nodes, m[2], false)
+            elsif "#{m[0]}#{m[1]}" =~ /^(:even|:odd)$/
+                new_nodes = []
+                nodes.each_with_index {|n,i| new_nodes.push(n) if (i % 2 == (m[1] == "even" ? 0 : 1)) }
+                nodes = new_nodes
+            elsif "#{m[0]}#{m[1]}" =~ /^(:first|:last)$/
+                nodes = [nodes.send(m[1])]
+            else
+                meth = "filter[#{m[0]}#{m[1]}]" unless m[0].empty?
+                if meth and Traverse.method_defined? meth
+                    args = m[2..-1]
+                else
+                    meth = "filter[#{m[0]}]"
+                    if Traverse.method_defined? meth
+                        args = m[1..-1]
+                    end
+                end
+                args << -1
+                nodes = Elements[*nodes.find_all do |x| 
+                                      args[-1] += 1
+                                      x.send(meth, *args) ? truth : !truth
+                                  end]
+            end
+        end
+        [nodes, expr]
+    end
+
+    # Given two elements, attempt to gather an Elements array of everything between
+    # (and including) those two elements.
+    def self.expand(ele1, ele2, excl=false)
+      ary = []
+      offset = excl ? -1 : 0
+
+      if ele1 and ele2
+        # let's quickly take care of siblings
+        if ele1.parent == ele2.parent
+          ary = ele1.parent.children[ele1.node_position..(ele2.node_position+offset)]
+        else
+          # find common parent
+          p, ele1_p = ele1, [ele1]
+          ele1_p.unshift p while p.respond_to?(:parent) and p = p.parent
+          p, ele2_p = ele2, [ele2]
+          ele2_p.unshift p while p.respond_to?(:parent) and p = p.parent
+          common_parent = ele1_p.zip(ele2_p).select { |p1, p2| p1 == p2 }.flatten.last
+
+          child = nil
+          if ele1 == common_parent
+            child = ele2
+          elsif ele2 == common_parent
+            child = ele1
+          end
+
+          if child
+            ary = common_parent.children[0..(child.node_position+offset)]
+          end
+        end
+      end
+
+      return Elements[*ary]
+    end
+
+    def filter(expr)
+        nodes, = Elements.filter(self, expr)
+        nodes
+    end
+
+    def not(expr)
+        if expr.is_a? Traverse
+            nodes = self - [expr]
+        else
+            nodes, = Elements.filter(self, expr, false)
+        end
+        nodes
+    end
+
+    private
+    def copy_node(node, l)
+        l.instance_variables.each do |iv|
+            node.instance_variable_set(iv, l.instance_variable_get(iv))
+        end
+    end
+
+  end
+
+  module Traverse
+    def self.filter(tok, &blk)
+      define_method("filter[#{tok.is_a?(String) ? tok : tok.inspect}]", &blk)
+    end
+
+    filter '' do |name,i|
+      name == '*' || (self.respond_to?(:name) && self.name.downcase == name.downcase)
+    end
+
+    filter '#' do |id,i|
+      self.elem? and get_attribute('id').to_s == id
+    end
+
+    filter '.' do |name,i|
+      self.elem? and classes.include? name
+    end
+
+    filter :lt do |num,i|
+      self.position < num.to_i
+    end
+
+    filter :gt do |num,i|
+      self.position > num.to_i
+    end
+
+    nth = proc { |num,i| self.position == num.to_i }
+    nth_first = proc { |*a| self.position == 0 }
+    nth_last = proc { |*a| self == parent.children_of_type(self.name).last }
+
+    filter :nth, &nth
+    filter :eq, &nth
+    filter ":nth-of-type", &nth
+
+    filter :first, &nth_first
+    filter ":first-of-type", &nth_first
+
+    filter :last, &nth_last
+    filter ":last-of-type", &nth_last
+
+    filter :even do |num,i|
+      self.position % 2 == 0
+    end
+
+    filter :odd do |num,i|
+      self.position % 2 == 1
+    end
+
+    filter ':first-child' do |i|
+      self == parent.containers.first
+    end
+
+    filter ':nth-child' do |arg,i|
+      case arg 
+      when 'even'; (parent.containers.index(self) + 1) % 2 == 0
+      when 'odd';  (parent.containers.index(self) + 1) % 2 == 1
+      else         self == (parent.containers[arg.to_i - 1])
+      end
+    end
+
+    filter ":last-child" do |i|
+      self == parent.containers.last
+    end
+    
+    filter ":nth-last-child" do |arg,i|
+      self == parent.containers[-1-arg.to_i]
+    end
+
+    filter ":nth-last-of-type" do |arg,i|
+      self == parent.children_of_type(self.name)[-1-arg.to_i]
+    end
+
+    filter ":only-of-type" do |arg,i|
+      parent.children_of_type(self.name).length == 1
+    end
+
+    filter ":only-child" do |arg,i|
+      parent.containers.length == 1
+    end
+
+    filter :parent do |*a|
+      containers.length > 0
+    end
+
+    filter :empty do |*a|
+      containers.length == 0
+    end
+
+    filter :root do |*a|
+      self.is_a? Hpricot::Doc
+    end
+    
+    filter 'text' do |*a|
+      self.text?
+    end
+
+    filter 'comment' do |*a|
+      self.comment?
+    end
+
+    filter :contains do |arg, ignore|
+      html.include? arg
+    end
+    
+    
+
+    pred_procs =
+      {'text()' => proc { |ele, *_| ele.inner_text.strip },
+       '@'      => proc { |ele, attr, *_| ele.get_attribute(attr).to_s if ele.elem? }}
+    
+    oper_procs =
+      {'='      => proc { |a,b| a == b },
+       '!='     => proc { |a,b| a != b },
+       '~='     => proc { |a,b| a.split(/\s+/).include?(b) },
+       '|='     => proc { |a,b| a =~ /^#{Regexp::quote b}(-|$)/ },
+       '^='     => proc { |a,b| a.index(b) == 0 },
+       '$='     => proc { |a,b| a =~ /#{Regexp::quote b}$/ },
+       '*='     => proc { |a,b| idx = a.index(b) }}
+
+    pred_procs.each do |pred_n, pred_f|
+      oper_procs.each do |oper_n, oper_f|
+        filter "#{pred_n}#{oper_n}" do |*a|
+          qual = pred_f[self, *a]
+          oper_f[qual, a[-2]] if qual
+        end
+      end
+    end
+
+    filter 'text()' do |val,i|
+      self.children.grep(Hpricot::Text).detect { |x| x.content =~ /\S/ } if self.children
+    end
+
+    filter '@' do |attr,val,i|
+      self.elem? and has_attribute? attr
+    end
+
+    filter '[' do |val,i|
+      self.elem? and search(val).length > 0
+    end
+
+  end
+end