ayril 0.1.0

data/CHANGES

@@ -0,0 +1,4 @@
+v 0.1.0
+===============================
+* Added a sanity check and fixed a bug where text nodes caused massive fail
+* Gemified source from https://github.com/kourge/ayril

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    ayril (1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    MacSpec (0.4.5)
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  MacSpec (~> 0.4.5)
+  ayril!
+  bundler (~> 1.0.0)
+  rake

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Robert Lowe <rob[!]iblargz.com>
+
+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:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Ayril
+
+Ayril is an XML library in MacRuby that uses Cocoa NSXML classes. It thus has a 
+very specific audience; for now, Cocoa developers on Mac OS X Leopard. This may
+change in the future as MacRuby expands its targeted platforms.
+
+Ayril subclasses all NSXML classes (with the exception of NSXMLParser) and 
+enhances them with useful methods and paradigms inspired by the Prototype 
+JavaScript framework and other Ruby XML libraries such as Hpricot and REXML.
+
+MacRuby developers have had numerous options when it comes to processing XML. 
+One could use REXML, the pure Ruby core library; Hpricot, the mostly-C library; 
+LibXML, a Ruby binding for the libxml2 toolkit written in C; or the Cocoa NSXML 
+classes, written in pure Objective-C and accessible directly through MacRuby. 
+Now, developers have yet another option: Ayril, which takes advantage of the 
+speed of NSXML classes and employs more Ruby-isms than the NSXML classes do.
+
+## Copyright (C) 2009-2011 by Wilson Lee <kourge[!]gmail.com>, Robert Lowe <rob[!]iblargz.com> - MIT
+
+* Programming by Wilson Lee on May 03, 2009
+* Packaging by Robert Lowe on June 16, 2011
+
+## Tests (not many right now):
+
+To test sanity:
+
+Install macruby 0.10
+
+1. Run in a terminal: `macruby test/test_sanity.rb`
+
+To test selectors:
+
+Install rhino
+Install macruby 0.10
+
+1. Run in a terminal: `macruby test/test_selector.rb`
+
+        PASS "body"
+        PASS "div"
+        PASS "body div"
+        PASS "div p"
+        PASS "div > p"
+        PASS "div + p"
+        PASS "div ~ p"
+        PASS "div[class^=exa][class$=mple]"
+        PASS "div p a"
+        PASS "div, p, a"
+        PASS ".note"
+        PASS "div.example"
+        PASS "div.dialog.emphatic"
+        PASS "ul .tocline2"
+        PASS "div.example, div.note"
+        PASS "#title"
+        PASS "h1#title"
+        PASS "div #title"
+        PASS "ul.toc li.tocline2"
+        PASS "ul.toc > li.tocline2"
+        PASS "h1#title + div > p"
+        PASS "h1[id]:contains(Selectors)"
+        PASS "a[href][lang][class]"
+        PASS "div[class]"
+        PASS "div[class=example]"
+        PASS "div[class^=exa]"
+        PASS "div[class$=mple]"
+        PASS "div[class*=e]"
+        PASS "div[class|=dialog]"
+        PASS "div[class!=made_up]"
+        PASS "div[class~=example]"
+        PASS "div:not(.example)"
+        PASS "p:contains(selectors)"
+        PASS "p:nth-child(even)"
+        PASS "p:nth-child(2n)"
+        PASS "p:nth-child(odd)"
+        PASS "p:nth-child(2n+1)"
+        PASS "p:nth-child(n)"
+        PASS "p:only-child"
+        PASS "p:last-child"
+        PASS "p:first-child"
+
+
+===
+
+TODOS:
+
+ * Passing tests for sets of xml docs (valid, invalid and the ugly.)
+ * Passing tests for utility methods
+ * Handle delegation of errors
+

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake/clean'
+require 'rake/testtask'
+require 'fileutils'
+require 'date'
+
+require 'lib/ayril/version.rb'
+
+# task :default => :test
+# task :spec => :test
+
+# PACKAGING ============================================================
+
+if defined?(Gem)
+  # Load the gemspec using the same limitations as github
+  def spec
+    require 'rubygems' unless defined? Gem::Specification
+    @spec ||= eval(File.read('ayril.gemspec'))
+  end
+
+  def package(ext='')
+    "pkg/ayril-#{spec.version}" + ext
+  end
+
+  desc 'Build packages'
+  task :package => %w[.gem].map {|e| package(e)}
+
+  desc 'Build and install as local gem'
+  task :install => package('.gem') do
+    `gem install #{package('.gem')}`
+  end
+
+  directory 'pkg/'
+  CLOBBER.include('pkg')
+
+  file package('.gem') => %w[pkg/ ayril.gemspec] + spec.files do |f|
+    `gem build ayril.gemspec`
+    mv File.basename(f.name), f.name
+  end
+
+end

data/ayril.gemspec

@@ -0,0 +1,55 @@
+require 'lib/ayril/version'
+
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.name = %q{ayril}
+  s.version = "#{Ayril::Version::STRING}"
+  s.authors = ["Wilson Lee", "Rob Lowe"]
+  s.date = %q{2011-06-16}
+  s.description = %q{An XML library for MacRuby that is built on top of Cocoa NSXML classes}
+  s.email = ['kourge@gmail.com', 'rob@iblargz.com']
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "CHANGES",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "ayril.gemspec",
+    "lib/ayril.rb",
+    "lib/ayril/version.rb",
+    "lib/ayril/core_ext/core_ext.rb",
+    "lib/ayril/selector.rb",
+    "lib/ayril/xml_document.rb",
+    "lib/ayril/xml_node.rb",
+    "lib/ayril/xml_node/node_traversal.rb",
+    "lib/ayril/xml_node/node_manipulation.rb",
+    "lib/ayril/xml_element.rb",
+    "lib/ayril/xml_element/element_attribute_manipulation.rb",
+    "lib/ayril/xml_element/element_classname_manipulation.rb",
+    "lib/ayril/xml_element/element_style_manipulation.rb",
+    "lib/ayril/xml_element/element_manipulation.rb",
+    "lib/ayril/xml_element/xml_attribute_hash.rb",
+    "lib/ayril/xml_element/xml_css_hash.rb",
+    "test/test_sanity.rb",
+    "test/sanity.xml",
+    "test/invoke_ayril_selector.rb",
+    "test/invoke_prototype_selector.js",
+    "test/selector.js",
+    "test/test_selector.rb"
+  ]
+  s.homepage = %q{http://github.com/RobertLowe/ayril}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{An XML library for MacRuby built on top of Cocoa NSXML classes}
+  s.add_development_dependency(%q<rake>, [">= 0"])
+  s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+  s.add_development_dependency(%q<MacSpec>, ["~> 0.4.5"])
+end 

data/lib/ayril.rb

@@ -0,0 +1,48 @@
+# Copyright (C) 2011 by Wilson Lee <kourge[!]gmail.com>, Robert Lowe <rob[!]iblargz.com>
+# 
+# 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:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+unless RUBY_ENGINE =~ /macruby/
+  raise NotImplementedError, "Ayril only runs on macruby! ;)"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+framework 'Cocoa'
+
+# core extensions to load right away
+require File.dirname(__FILE__) + '/ayril/core_ext/core_ext'
+
+module Ayril
+  autoload :Version,       'ayril/version'
+
+  autoload :Selector,      'ayril/selector'
+
+  autoload :XMLNode,       'ayril/xml_node'
+  autoload :XMLElement,    'ayril/xml_element'
+  autoload :XMLDocument,   'ayril/xml_document'
+
+  class XMLDTD < NSXMLDTD
+    include XMLNode::NodeManipulation
+  end
+
+  class XMLDTDNode < NSXMLDTDNode
+    include XMLNode::NodeManipulation
+  end
+end
+

data/lib/ayril/core_ext/core_ext.rb

@@ -0,0 +1,96 @@
+# Copyright (C) 2011 by Wilson Lee <kourge[!]gmail.com>, Robert Lowe <rob[!]iblargz.com>
+# 
+# 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:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+class NilClass
+  def maybe(*a); self; end if not NilClass.method_defined? :maybe
+  def intern; self; end if not NilClass.method_defined? :intern
+end
+
+
+class Object
+  alias :maybe :send
+end
+
+class Module
+  # MacRuby still cannot alias some Cocoa methods.
+  def forward(new, old) define_method(new) { |*args| self.send old, *args } end
+end
+
+
+class Array
+  def any?; not self.empty? end
+  def invoke(*args) self.map { |item| item.send *args } end
+  def invoke!(*args) self.map! { |item| item.send *args } end
+
+  alias :send_all :invoke
+  alias :send_all! :invoke!
+  alias :pluck :invoke
+  alias :pluck! :invoke!
+end
+
+
+class String
+  def interpolate(object, pattern=/(^|.|\r|\n)(#\{(.*?)\})/)
+    self.gsub(pattern) do |match|
+      return '' if object.nil?
+
+      before = $1 || ''
+      return $2 if before == '\\'
+
+      ctx = object; expr = $3
+      pattern = /^([^.\[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/
+      match = pattern.match(expr)
+      return before if match.nil?
+      
+      while not match.nil?
+        comp = match[1].start_with?('[') ? match[2].gsub('\\\\]', ']') : match[1]
+        if ctx.kind_of?(Array) or ctx.kind_of?(MatchData)
+          ctx = ctx[comp.to_i]
+        elsif ctx.kind_of?(Hash)
+          types = ctx.keys.invoke(:class)
+          
+          major_type = types.uniq.map do |type| 
+            [type, types.find_all { |i| i == type }.length]
+          end.max { |a, b| a[1] <=> b[1] }[0]
+          
+          method = {
+            Symbol => :to_sym,
+            String => :to_s
+          }[major_type]
+
+          ctx = ctx[comp.send method]
+        else
+          ctx = ctx[comp]
+        end
+        break if ctx.nil? or match[3] == ''
+        expr = expr[(match[3] == '[' ? match[1].length : match[0].length)..-1]
+        match = pattern.match expr
+      end
+      
+      before + ctx.to_s
+    end
+  end
+
+  def start_with?(string) self.index(string) == 0 end
+  def end_with?(string) self.index(string) == (self.length - string.length) end
+
+  def to_elem; Ayril::XMLElement.new self end
+end
+

data/lib/ayril/selector.rb

@@ -0,0 +1,250 @@
+module Ayril
+  class Selector
+    attr_reader :expr, :xpath
+    @@cache = {}
+
+    def initialize(expr)
+      @expr = expr.strip
+      self.compile_xpath_matcher
+    end
+  
+    def compile_xpath_matcher
+      e = @expr.dup; le = nil
+      return (@xpath = @@cache[e]) if @@cache.include? e
+
+      @matcher = [".//*"]
+      while (e != '') and (le != e) and (e =~ /\S/)
+        le = e.dup
+        Selector::Patterns.each do |pattern|
+          n = Selector::XPath[pattern[:name]]
+          if m = e.match(pattern[:re])
+            m = m.to_a unless m.nil?
+            @matcher << (n.kind_of?(Proc) ? n.call(m) : n.interpolate(m))
+            e.sub! m[0], ''
+            break
+          end
+        end
+      end
+
+      @xpath = @matcher.join
+      @@cache[@expr] = @xpath.gsub! %r{\*?\[name\(\)='([a-zA-Z]+)'\]}, '\1'
+    end
+
+    def find_elements(root)
+      root.select_by_xpath @xpath
+    end
+
+    def match?(element)
+      @tokens = []
+    
+      e = @expr.dup; le = nil
+      while (e != '') and (le != e) and (e =~ /\S/)
+        le = e.dup
+        Selector::Patterns.each do |pattern|
+          if m = e.patch(pattern[:re])
+            m = m.to_a unless m.nil?
+            if Selector::Assertions.include? name
+              @tokens << [pattern[:name], m.clone]
+              e.sub! m[0], ''
+            else # resort to whole document
+              return self.find_elements(element.rootDocument).include? element
+            end
+          end
+        end
+      end
+
+      match = true
+      @tokens.each do |token|
+        name, matches = token[0..1]
+        if not Selector::Assertions[name].call self, matches
+          match = false
+          break
+        end
+      end
+      match
+    end
+
+    def to_s
+      @expr
+    end
+
+    def inspect
+      "#<Selector:#{@expr.inspect}>"
+    end
+  
+
+    XPath = {
+      :descendant =>   "//*",
+      :child =>        "/*",
+      :adjacent =>     "/following-sibling::*[1]",
+      :laterSibling => '/following-sibling::*',
+      :tagName =>      lambda { |m|
+        return '' if m[1] == '*'
+        "[name()='" + m[1] + "']"
+      },
+      :className =>    "[contains(concat(' ', @class, ' '), ' \#{1} ')]",
+      :id =>           "[@id='\#{1}']",
+      :attrPresence => lambda { |m|
+        m[1].downcase!
+        "[@\#{1}]".interpolate(m)
+      },
+      :attr => lambda { |m|
+        m[1].downcase!
+        m[3] = m[5] || m[6]
+        Selector::XPath[:operators][m[2]].interpolate(m)
+      },
+      :pseudo => lambda { |m|
+        h = Selector::XPath[:pseudos][m[1]]
+        return '' if h.nil?
+        return h.call(m) if h.kind_of? Proc
+        Selector::XPath[:pseudos][m[1]].interpolate(m)
+      },
+      :operators => {
+        '='  => "[@\#{1}='\#{3}']",
+        '!=' => "[@\#{1}!='\#{3}']",
+        '^=' => "[starts-with(@\#{1}, '\#{3}')]",
+        '$=' => "[substring(@\#{1}, (string-length(@\#{1}) - string-length('\#{3}') + 1))='\#{3}']",
+        '*=' => "[contains(@\#{1}, '\#{3}')]",
+        '~=' => "[contains(concat(' ', @\#{1}, ' '), ' \#{3} ')]",
+        '|=' => "[contains(concat('-', @\#{1}, '-'), '-\#{3}-')]"
+      },
+      :pseudos => {
+        'first-child' => '[not(preceding-sibling::*)]',
+        'last-child' =>  '[not(following-sibling::*)]',
+        'only-child' =>  '[not(preceding-sibling::* or following-sibling::*)]',
+        'empty' =>       "[count(*) = 0 and (count(text()) = 0)]",
+        'checked' =>     "[@checked]",
+        'disabled' =>    "[(@disabled) and (@type!='hidden')]",
+        'enabled' =>     "[not(@disabled) and (@type!='hidden')]",
+        'not' => lambda { |m|
+          e = m[6]; le = nil; exclusion = []
+          while (e != '') and (le != e) and (e =~ /\S/)
+            le = e.dup
+            Selector::Patterns.each do |pattern|
+              n = Selector::XPath[pattern[:name]]
+              if m = e.match(pattern[:re])
+                v = n.kind_of?(Proc) ? n.call(m) : n.interpolate(m)
+                exclusion << ('(' + v[1, v.length - 2] + ')')
+                e.gsub! m[0], ''
+                break
+              end
+            end
+          end      
+          "[not(" + exclusion.join(" and ") + ")]"
+        },
+        'nth-child' =>      lambda { |m| 
+          Selector::XPath[:pseudos]['nth'].call("(count(./preceding-sibling::*) + 1) ", m)
+        },
+        'nth-last-child' => lambda { |m|
+          Selector::XPath[:pseudos]['nth'].call("(count(./following-sibling::*) + 1) ", m)
+        },
+        'nth-of-type' =>    lambda { |m|
+          Selector::XPath[:pseudos]['nth'].call("position() ", m)
+        },
+        'nth-last-of-type' => lambda { |m|
+          Selector::XPath[:pseudos]['nth'].call("(last() + 1 - position()) ", m)
+        },
+        'first-of-type' =>  lambda { |m| 
+          m[6] = "1"; Selector::XPath[:pseudos]['nth-of-type'].call(m)
+        },
+        'last-of-type' =>   lambda { |m|
+          m[6] = "1"; Selector::XPath[:pseudos]['nth-last-of-type'].call(m)
+        },
+        'only-of-type' =>   lambda { |m|
+          p = Selector::XPath[:pseudos]
+          p['first-of-type'].call(m) + p['last-of-type'].call(m)
+        },
+        'nth' => lambda { |fragment, m|
+          mm = nil; formula = m[6]; predicate = nil
+          formula = '2n+0' if formula == 'even'
+          formula = '2n+1' if formula == 'odd'
+          return "[#{fragment}= #{mm[1]}]" if mm = formula.match(/^(\d+)$/) # digit only
+          if mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/).to_a # an+b
+            mm[1] = -1 if mm[1] == '-'
+            # in JS: mm => ['n', undefined, undefined, undefined, undefined]
+            # in RB: mm => ['n', '', nil, nil, nil]
+            mm[1] = nil if mm[0] == 'n' # edge case
+            a = mm[1] ? mm[1].to_i : 1
+            b = mm[2] ? mm[2].to_i : 0
+            "[((#{fragment} - #{b}) mod #{a} = 0) and ((#{fragment} - #{b}) div #{a} >= 0)]"
+          end
+        }
+      }    
+    }
+
+    Patterns = [
+      # combinators must be listed first
+      # (and descendant needs to be last combinator)
+      { :name => :laterSibling, :re => %r{^\s*~\s*}  },
+      { :name => :child,        :re => %r{^\s*>\s*}  },
+      { :name => :adjacent,     :re => %r{^\s*\+\s*}  },
+      { :name => :descendant,   :re => %r{^\s}  },
+
+      # selectors follow
+      { :name => :tagName,      :re => %r{^\s*(\*|[\w\-]+)(\b|$)?}  },
+      { :name => :id,           :re => %r{^#([\w\-\*]+)(\b|$)}  },
+      { :name => :className,    :re => %r{^\.([\w\-\*]+)(\b|$)}  },
+      { :name => :pseudo,       :re => %r{^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))}  },
+      { :name => :attrPresence, :re => %r{^\[((?:[\w-]+:)?[\w-]+)\]}  },
+      { :name => :attr,         :re => %r{\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]} }
+    ]
+
+    Assertions = {
+      "tagName" => lambda { |element, matches|
+         matches[1].upcase == element.name.upcase
+      },
+
+      "className" => lambda { |element, matches|
+         element.has_class_name? matches[1]
+      },
+
+      "id" => lambda { |element, matches|
+         element.read_attribute("id") == matches[1]
+      },
+
+      "attrPresence" => lambda { |element, matches|
+         element.has_attribute? matches[1]
+      },
+
+      "attr" => lambda { |element, matches|
+        value = element.read_attribute matches[1]
+        value and Selector::Operators[matches[2]].call(value, matches[5] || matches[6])
+      }
+    }
+
+    Operators = {
+      '=' =>  lambda { |nv, v| nv == v },
+      '!=' => lambda { |nv, v| nv != v },
+      '^=' => lambda { |nv, v| nv == v or (nv and nv.start_with? v) },
+      '$=' => lambda { |nv, v| nv == v or (nv and nv.end_with? v) },
+      '*=' => lambda { |nv, v| nv == v or (nv and nv.include? v) },
+      '~=' => lambda { |nv, v| " #{nv} ".include? " #{v} " },
+      '|=' => lambda { |nv, v| "-#{(nv || '').upcase}-".include? "-#{(v || '').upcase}-" }    
+    }
+
+    def self.split(expression)
+      expressions = []
+      expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/) do |m|
+        expressions << m[1].strip
+      end
+      expressions
+    end
+
+    def self.match_elements(elements, expression)
+      elements & elements[0].rootDocument.select(expression)
+    end
+
+    def self.find_element(elements, *rest)
+      expression, index = rest[0], rest[1]
+      (expression = nil; index = expression) if expression.kind_of? Integer
+      Selector::match_elements(elements, expression || '*')[index || 0]
+    end
+
+    def self.find_child_elements(element, expressions)
+      Selector::split(expressions.join(',')).map do |expression|
+        Selector.new(expression.strip).find_elements(element)
+      end.uniq.flatten
+    end
+  end
+end
+