peachy 0.2.0 → 0.2.1

data/lib/no_xml_parser_available.rb

@@ -0,0 +1,10 @@
+class NoXmlParserAvailable < Exception
+  def initialize
+    super <<MESSAGE
+Peachy was unable to find any XML parser gems.  PEachy expects one of the following
+gems to be installed before use:
+Nokogiri
+LibXML
+MESSAGE
+  end
+end

data/lib/peachy/childless_proxy_with_attributes.rb

@@ -1,16 +1,15 @@
 module Peachy
   class ChildlessProxyWithAttributes < Proxy
+    # Returns the text content of the XML node encapsulated by this instance.
     def value
       acts_as_only_child
-      @nokogiri_node.content
+      node.content
     end
 
     private
     def generate_method_for_xml method_name
       check_for_convention(method_name)
-      match = find_match_by_attributes method_name, nokogiri_node
-      raise NoMatchingXmlPart.new method_name, node_name if match.nil?
-      return create_value(match) {|child| define_child method_name, child }
+      create_method_for_attribute(method_name) {|match| no_matching_xml(method_name) if match.nil? }
     end
   end
 end

data/lib/peachy/convention_checks.rb

@@ -1,9 +1,15 @@
 module Peachy
   module ConventionChecks
+    private
+    # Checks whether the provided method name is in the accepted convention,
+    # raising a MethodNotInRubyConvention if it's not.
     def check_for_convention method_name
       raise MethodNotInRubyConvention.new(method_name) unless matches_convention(method_name)
     end
 
+    # Checks whether the given method name matches the Ruby convention of
+    # lowercase with underscores.  This method does not allow question marks,
+    # excalmation marks or numbers, however.
     def matches_convention method_name
       method_name.to_s =~ /^[a-z]+(?:_[a-z]+){0,}$/
     end

data/lib/peachy/method_mask.rb

@@ -1,5 +1,6 @@
 module Peachy
   module MethodMask
+    private
     def hide_public_methods exceptions
       methods_to_hide = public_instance_methods.clone
       exceptions.each do |to_stay_public|

data/lib/peachy/morph_into_array.rb

@@ -1,8 +1,8 @@
 module Peachy
   module MorphIntoArray
+    private
     def you_use_me_like_an_array method_name, block_given, *args
       return ((block_given or args.size > 0) and array_can?(method_name))
-      #method_name == :[] and args.one? and args.first == 0
     end
 
     def array_can? method_name

data/lib/peachy/my_meta_class.rb

@@ -1,6 +1,7 @@
 module Peachy
   # MyMetaClass is a convenience Module for meta programming within a Class.
   module MyMetaClass
+    private
     def eval_on_singleton_class &block
       (class << self; self; end).class_eval &block
     end

data/lib/peachy/parsers/nokogiri_wrapper.rb

@@ -0,0 +1,73 @@
+module Peachy
+  module Parsers
+    class NokogiriWrapper
+      def initialize nokogiri
+        @nokogiri = nokogiri
+      end
+
+      # Runs the XPath for the method name against the underlying XML DOM,
+      # returning nil if no element or attribute matching the method name is found
+      # in the children of the current location in the DOM.
+      def find_matches method_name
+        matches = xpath(xpath_for(method_name))
+        return nil if matches.length < 1
+        return matches
+      end
+
+      def find_match_by_attributes method_name
+        mapped = method_name.variations.map {|variation| attribute(variation) }
+        mapped.find {|match| match != nil }
+      end
+
+      def find_attribute method_name
+        attribute(method_name.to_s)
+      end
+
+      def has_children_and_attributes?
+        there_are_child_nodes? and node_has_attributes?
+      end
+
+      # Determines whether the given element contains any child elements or not.
+      # The choice of implementation is based on performance tests between using
+      # XPath and a Ruby iterator.
+      def there_are_child_nodes?
+        children.any? {|child| child.kind_of? Peachy::Parsers::NokogiriWrapper }
+      end
+
+      def node_has_attributes?
+        attribute_nodes.size > 0
+      end
+
+      def content
+        @nokogiri.content
+      end
+
+      def name
+        @nokogiri.name
+      end
+
+      private
+      def attribute_nodes
+        @nokogiri.attribute_nodes.map {|attribute| attribute.content }
+      end
+
+      def children
+        @nokogiri.children.map {|child| NokogiriWrapper.new(child) if child.kind_of? Nokogiri::XML::Element }
+      end
+
+      # Gets the XPath for all variations of the MethodName instance
+      def xpath_for method_name
+        method_name.variations.map {|variation| "./#{variation}" } * '|'
+      end
+
+      def xpath xpath
+        @nokogiri.xpath(xpath).map{|noko_node| NokogiriWrapper.new(noko_node) }
+      end
+
+      def attribute attribute_name
+        noko = @nokogiri.attribute(attribute_name)
+        noko.nil?? nil : NokogiriWrapper.new(noko)
+      end
+    end
+  end
+end

data/lib/peachy/proxy.rb

@@ -1,11 +1,8 @@
-require 'rubygems'
-require 'nokogiri'
-
 module Peachy
   class Proxy
     alias_method :original_method_missing, :method_missing
     extend MethodMask
-    include ConventionChecks, MorphIntoArray, MyMetaClass, NodeChildMatcher
+    include ConventionChecks, MorphIntoArray, MyMetaClass, XmlNode
 
     # This hides all public methods on the class except for 'methods', 'nil?'
     # 'respond_to?' and 'inspect', which I've found are too useful to hide for
@@ -14,9 +11,9 @@ module Peachy
 
     # Takes either a string containing XML or a Nokogiri::XML::Element as the
     # single argument.
-    def initialize arguments
-      @xml = arguments if arguments.kind_of? String
-      @nokogiri_node = arguments if arguments.kind_of? Nokogiri::XML::Element
+    def initialize xml_node
+      @xml = xml_node if xml_node.kind_of? String
+      @nokogiri_node = xml_node if xml_node.kind_of? Peachy::Parsers::NokogiriWrapper #Nokogiri::XML::Element
     end
 
     # Overloaded so that calls to methods representative of an XML element or
@@ -82,81 +79,45 @@ module Peachy
         acts_as_only_child
         child_proxy
       elsif array_can?(method_name)
-        # if child doesn't exist, see if the call might be a zero-argument
-        # Array call.
-        new_proxy = create_from_element(nokogiri_node)
+        # morph into an array, as method is a zero-length array call
+        new_proxy = ProxyFactory.create_from_element(node)
         morph_into_array(new_proxy, method_name)
       else
-        # no matches, so throw
-        raise NoMatchingXmlPart.new(method_name, node_name)
+        no_matching_xml(method_name)
       end
     end
 
     private
     def generate_method_for_xml method_name
       check_for_convention(method_name)
-      attribute_content = create_from_parent_with_attribute(method_name, nokogiri_node)
+      attribute_content = create_attribute method_name
       return attribute_content unless attribute_content.nil?
-      matches = find_matches(method_name, nokogiri_node)
+      matches = node.find_matches(method_name)
       matches.nil? ? nil : create_method_for_child_or_content(method_name, matches)
     end
 
     def create_method_for_child_or_content method_name, matches
       return create_from_element_list(method_name, matches) if matches.size > 1
-      return create_from_element(matches[0]) {|child| define_child method_name, child }
-    end
-
-    def create_from_parent_with_attribute method_name, node
-      if there_are_child_nodes?(node) and node_has_attributes?(node)
-        match = node.attribute(method_name.to_s)
-        create_value(match) {|child| define_child(method_name, child) } unless match.nil?
-      end
-    end
-
-    def create_from_element_list method_name, matches
-        define_method(method_name) { return matches_to_array matches }
-    end
-
-    def matches_to_array matches
-      matches.inject([]) {|array, child| array << create_from_element(child) }
-    end
-
-    def create_from_element match, &block
-      return create_proxy(match, &block) if there_are_child_nodes?(match)
-      return create_proxy_with_attributes(match, &block) if node_has_attributes?(match)
-      return create_content_child(match, &block)
+      child = ProxyFactory.create_from_element(matches[0])
+      define_child(method_name, child)
     end
 
-    def node_has_attributes? match
-      match.attribute_nodes.size > 0
+    def create_attribute method_name
+      create_method_for_attribute(method_name) if node.has_children_and_attributes?
     end
 
-    # Determines whether the given element contains any child elements or not.
-    # The choice of implementation is based on performance tests between using
-    # XPath and a Ruby iterator.
-    def there_are_child_nodes? match
-      match.children.any? {|child| child.kind_of? Nokogiri::XML::Element }
+    def create_method_for_attribute method_name
+      match = node.find_match_by_attributes(method_name)
+      yield match if block_given?
+      define_child(method_name, match.content) unless match.nil?
     end
 
-    def create_value match, &block
-      create_child(match.content, &block)
-    end
-    
-    def create_content_child match, &block
-      create_child(SimpleContent.new(match.content, match.name), &block)
-    end
-
-    def create_proxy match, &block
-      create_child(Proxy.new(match), &block)
-    end
-
-    def create_proxy_with_attributes match, &block
-      create_child ChildlessProxyWithAttributes.new(match), &block
+    def create_from_element_list method_name, matches
+        define_method(method_name) { return matches_to_array(matches) }
     end
 
-    def create_child child
-      yield child if block_given?
-      return child
+    def matches_to_array matches
+      matches.inject([]) {|array, child| array << ProxyFactory.create_from_element(child) }
     end
 
     def define_child method_name, child
@@ -172,17 +133,8 @@ module Peachy
       @xml.nil? and @nokogiri_node.nil?
     end
 
-    def node_name
-      nokogiri_node.name
-    end
-
-    def nokogiri_node
-      raise InvalidProxyParameters.new(:xml => nil, :nokogiri => nil) if variables_are_nil?
-      @nokogiri_node ||= Nokogiri::XML(@xml)
-    end
-
-    def clone
-      create_from_element(nokogiri_node)
+    def no_matching_xml method_name
+      raise NoMatchingXmlPart.new(method_name, node_name)
     end
   end
 end

data/lib/peachy/proxy_factory.rb

@@ -0,0 +1,34 @@
+module Peachy
+  class ProxyFactory
+    class << self
+      def create_from_element match
+        return create_proxy(match) if there_are_child_nodes?(match)
+        return create_proxy_with_attributes(match) if node_has_attributes?(match)
+        return create_content_child(match)
+      end
+
+      def node_has_attributes? match
+        match.node_has_attributes?
+      end
+
+      # Determines whether the given element contains any child elements or not.
+      # The choice of implementation is based on performance tests between using
+      # XPath and a Ruby iterator.
+      def there_are_child_nodes? match
+        match.there_are_child_nodes?
+      end
+
+      def create_content_child match
+        SimpleContent.new(match.content, match.name)
+      end
+
+      def create_proxy match
+        Proxy.new(match)
+      end
+
+      def create_proxy_with_attributes match
+        ChildlessProxyWithAttributes.new(match)
+      end
+    end
+  end
+end

data/lib/peachy/version.rb

@@ -1,3 +1,3 @@
 module Peachy
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/lib/peachy/xml_node.rb

@@ -0,0 +1,20 @@
+module Peachy
+  module XmlNode
+    private
+    def clone
+      ProxyFactory.create_from_element(node)
+    end
+
+    # Returns the name of the encapsulated node.
+    def node_name
+      node.name
+    end
+
+    # The encapsulated Nokogiri node, which is lazy loaded from the @xml instance
+    # variable.
+    def node
+      raise InvalidProxyParameters.new(:xml => nil, :nokogiri => nil) if variables_are_nil?
+      @nokogiri_node ||= Peachy::Parsers::NokogiriWrapper.new(Nokogiri::XML(@xml))
+    end
+  end
+end

data/lib/peachy/xml_parser_factory.rb

@@ -0,0 +1,15 @@
+module Peachy
+  class XmlParserFactory
+    def load_parser
+      return load_up(:nokogiri) if Gem.available? /nokogiri/
+      return load_up(:libxml) if Gem.available? /libxml/
+      raise NoXmlParserAvailable.new
+    end
+
+    private
+    def load_up xml_parser
+      require(xml_parser.to_s)
+      return xml_parser
+    end
+  end
+end

data/lib/peachy.rb

@@ -1,18 +1,27 @@
+require 'rubygems'
+
 require File.join(File.dirname(__FILE__), 'already_an_only_child')
 require File.join(File.dirname(__FILE__), 'invalid_proxy_parameters')
 require File.join(File.dirname(__FILE__), 'method_not_in_ruby_convention')
 require File.join(File.dirname(__FILE__), 'no_matching_xml_part')
+require File.join(File.dirname(__FILE__), 'no_xml_parser_available')
 require File.join(File.dirname(__FILE__), 'peachy/convention_checks')
 require File.join(File.dirname(__FILE__), 'peachy/string_styler')
 require File.join(File.dirname(__FILE__), 'peachy/method_name')
 require File.join(File.dirname(__FILE__), 'peachy/method_mask')
 require File.join(File.dirname(__FILE__), 'peachy/morph_into_array')
 require File.join(File.dirname(__FILE__), 'peachy/my_meta_class')
-require File.join(File.dirname(__FILE__), 'peachy/node_child_matcher')
+require File.join(File.dirname(__FILE__), 'peachy/xml_node')
 require File.join(File.dirname(__FILE__), 'peachy/simple_content')
+require File.join(File.dirname(__FILE__), 'peachy/xml_parser_factory')
+require File.join(File.dirname(__FILE__), 'peachy/parsers/nokogiri_wrapper')
 require File.join(File.dirname(__FILE__), 'peachy/proxy')
+require File.join(File.dirname(__FILE__), 'peachy/proxy_factory')
 require File.join(File.dirname(__FILE__), 'peachy/childless_proxy_with_attributes')
 
+# first up, load the underlying XML parser that Peachy will use
+Peachy::XmlParserFactory.new.load_parser
+
 module Peachy
   def self.whine
     @whine = true

data/spec/attributes_on_a_parent_node_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 describe "attributes on a parent node" do
   before(:each) do
     @proxy = Peachy::Proxy.new '<root><test_node name="Test"><child>Check meh.</child><test_node></root>'
@@ -15,4 +17,8 @@ describe "attributes on a parent node" do
     @proxy.root.test_node.name
     @proxy.root.test_node.methods.should include 'name'
   end
+
+  it "should raise an error if the attirbute does not exist" do
+    lambda { @proxy.root.test_node.other }.should raise_error NoMatchingXmlPart
+  end
 end

data/spec/camel_case_names_spec.rb

@@ -1,6 +1,13 @@
+require 'spec_helper'
 describe "interpreting element and attribute names that are defined in camelCase" do
   before(:each) do
-    @proxy = Peachy::Proxy.new '<root><testNode>Check meh.</testNode><secondNode id="2" recordLabel="Wall of Sound">Check meh, too.</secondNode></root>'
+    @proxy = Peachy::Proxy.new <<XML
+<root>
+  <testNode>Check meh.</testNode>
+  <secondNode id="2" recordLabel="Wall of Sound">Check meh, too.</secondNode>
+  <thirdNode id="2" recordLabel="Wall of Sound"><child>Nested</child></secondNode>
+</root>
+XML
   end
 
   it "should match a method to an element by camel case" do
@@ -20,5 +27,10 @@ describe "interpreting element and attribute names that are defined in camelCase
     @proxy.root.second_node.record_label
     @proxy.root.second_node.methods.should include 'record_label'
   end
+
+  it "should match parent attribute names" do
+    @proxy.root.third_node.record_label.should == 'Wall of Sound'
+    @proxy.root.third_node.methods.should include 'record_label'
+  end
 end
 

data/spec/collections_with_children_as_arrays_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 describe "collections with children as arrays" do
   before(:each) do
     xml = <<STR

data/spec/hyphen_separated_names_spec.rb

@@ -1,15 +1,42 @@
+require 'spec_helper'
+
 describe "interpretting element names that contain hyphens" do
   before(:each) do
-    @proxy = Peachy::Proxy.new '<test-node>Check meh.</test-node>'
+    @proxy = Peachy::Proxy.new <<XML
+<test-node>
+  <first-child>Check meh.</first-child>
+  <second-child record-label="Rough Trade">Check meh, too.</second-child>
+  <third-child record-label="Rough Trade"><text-node>Check meh again.</text-node></third-child>
+</test-node>
+XML
   end
 
   it "should try to match a method to a node with hyphens" do
-    @proxy.test_node.value.should == 'Check meh.'
+    @proxy.test_node.first_child.value.should == 'Check meh.'
   end
 
   it "should define a method for the element name" do
     @proxy.test_node
     @proxy.methods.should include 'test_node'
   end
+
+  it "should match a method to an attribute by pascal case" do
+    @proxy.test_node.second_child.record_label.should == 'Rough Trade'
+  end
+
+  it "should define a method from pascal cased attribute name" do
+    @proxy.test_node.second_child.record_label
+    @proxy.test_node.second_child.methods.should include 'record_label'
+  end
+
+  it "should define a method on a parent with attributes" do
+    @proxy.test_node.third_child.record_label.should == 'Rough Trade'
+    @proxy.test_node.third_child.methods.should include 'record_label'
+  end
+
+  it "should allow child nodes to be selected after an attrbiute is selected on a parent node" do
+    @proxy.test_node.third_child.record_label.should == 'Rough Trade'
+    @proxy.test_node.third_child.text_node.value.should == 'Check meh again.'
+  end
 end
 

data/spec/libxml_is_the_available_xml_parser_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Peachy::XmlParserFactory do
+  before(:each) do
+    Gem.stubs(:available?).with(/libxml/).returns(true)
+    Gem.stubs(:available?).with(/nokogiri/).returns(false)
+    @factory = Peachy::XmlParserFactory.new
+    @factory.stubs(:require).with('libxml').returns(true)
+  end
+
+  it "should return LibXML if Nokogiri is not an available gem" do
+    parser_type = @factory.load_parser
+    parser_type.should == :libxml
+  end
+
+  it "should load LibXML if Nokogiri is not an available gem, but LibXML is" do
+    first_expectation = Gem.expects(:available?).with(/nokogiri/).returns(false)
+    second_expectation = @factory.expects(:require).with('libxml').returns(true)
+    parser_type = @factory.load_parser
+    first_expectation.satisfied?.should be_true
+    second_expectation.satisfied?.should be_true
+  end
+
+  it "should not load Nokogiri if Nokogiri is not an available gem" do
+    expectation = @factory.expects(:require).with('nokogiri').returns(true).never()
+    parser_type = @factory.load_parser
+    expectation.satisfied?.should be_true
+  end
+end
+

data/spec/no_xml_parsers_are_available_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "no xml parsers are available" do
+  before(:each) do
+    Gem.stubs(:available?).returns(false)
+    @factory = Peachy::XmlParserFactory.new
+  end
+
+  it "should blow up if no XML parsing library is available" do
+    lambda { @factory.load_parser }.should raise_error NoXmlParserAvailable
+  end
+end
+

data/spec/nokogiri_is_the_available_xml_parser_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "nokogiri is the available XML parser" do
+  before(:each) do
+    @factory = Peachy::XmlParserFactory.new
+  end
+
+  it "should check whether Nokogiri is available" do
+    expectation = Gem.expects(:available?).with(/nokogiri/).returns(true)
+    parser_type = @factory.load_parser
+    expectation.satisfied?.should be_true
+  end
+  
+  it "should return Nokogiri if Nokogiri is an available gem" do
+    parser_type = @factory.load_parser
+    parser_type.should == :nokogiri
+  end
+
+  it "should load Nokogiri if Nokogiri is an available gem" do
+    expectation = @factory.expects(:require).with('nokogiri').returns(true)
+    parser_type = @factory.load_parser
+    expectation.satisfied?.should be_true
+  end
+end
+

data/spec/pascal_case_names_spec.rb

@@ -1,6 +1,13 @@
+require 'spec_helper'
 describe "interpreting element and attribute names that are defined in PascalCase" do
   before(:each) do
-    @proxy = Peachy::Proxy.new '<Root><TestNode>Check meh.</TestNode><SecondNode Id="2" RecordLabel="Wall of Sound">Check meh, too.</SecondNode></Root>'
+    @proxy = Peachy::Proxy.new <<XML
+<Root>
+  <TestNode>Check meh.</TestNode>
+  <SecondNode Id="2" RecordLabel="Wall of Sound">Check meh, too.</SecondNode>
+  <ThirdNode Id="2" RecordLabel="Wall of Sound"><Child>Check meh again.</Child></SecondNode>
+</Root>
+XML
   end
 
   it "should match a method to an element by pascal case" do
@@ -20,5 +27,15 @@ describe "interpreting element and attribute names that are defined in PascalCas
     @proxy.root.second_node.record_label
     @proxy.root.second_node.methods.should include 'record_label'
   end
+
+  it "should define a method on a parent with attributes" do
+    @proxy.root.third_node.record_label.should == 'Wall of Sound'
+    @proxy.root.third_node.methods.should include 'record_label'
+  end
+
+  it "should allow child nodes to be selected after an attrbiute is selected on a parent node" do
+    @proxy.root.third_node.record_label.should == 'Wall of Sound'
+    @proxy.root.third_node.child.value.should == 'Check meh again.'
+  end
 end
 

data/spec/peachy_parsers_nokogiri_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "nokogiri wrapper" do
+  before(:each) do
+    @nokogiri_xml = Nokogiri::XML <<XML
+<root identity="1234" category="awesomeness">
+  <child id="1">Hello</child>
+  <second_child  attribute_one="one" attribute_two="two">Contents</second_child>
+</root>
+XML
+    @nokogiri = Peachy::Parsers::NokogiriWrapper.new @nokogiri_xml
+  end
+
+  it "should have all of the methods that I expect" do
+    @nokogiri.methods.should include 'content'
+    @nokogiri.methods.should include 'name'
+  end
+
+  it "should return the expected content" do
+    @simple_noko = Peachy::Parsers::NokogiriWrapper.new(Nokogiri::XML('<xml>Hello</xml>'))
+    @simple_noko.content.should == 'Hello'
+  end
+
+  it "should return the expected name" do
+    @nokogiri.name.should == 'document'
+  end
+end
+

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../lib/peachy'))
+require 'mocha'
 
 Spec::Runner.configure do |config|
   Peachy.whine
+  config.mock_with :mocha
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - NJ Pearman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-12 00:00:00 +01:00
+date: 2010-05-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,32 +44,40 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- lib/peachy/xml_node.rb
 - lib/peachy/convention_checks.rb
 - lib/peachy/childless_proxy_with_attributes.rb
 - lib/peachy/method_name.rb
+- lib/peachy/xml_parser_factory.rb
 - lib/peachy/method_mask.rb
+- lib/peachy/proxy_factory.rb
 - lib/peachy/simple_content.rb
 - lib/peachy/version.rb
 - lib/peachy/proxy.rb
+- lib/peachy/parsers/nokogiri_wrapper.rb
 - lib/peachy/morph_into_array.rb
 - lib/peachy/my_meta_class.rb
 - lib/peachy/string_styler.rb
-- lib/peachy/node_child_matcher.rb
 - lib/no_matching_xml_part.rb
+- lib/no_xml_parser_available.rb
 - lib/invalid_proxy_parameters.rb
 - lib/method_not_in_ruby_convention.rb
 - lib/already_an_only_child.rb
 - lib/peachy.rb
+- spec/nokogiri_is_the_available_xml_parser_spec.rb
 - spec/hyphen_separated_names_spec.rb
 - spec/elements_referenced_as_collections_spec.rb
+- spec/peachy_parsers_nokogiri_spec.rb
 - spec/simple_content_wrapper_for_Peachy_spec.rb
 - spec/collections_with_children_as_arrays_spec.rb
 - spec/method_name_spec.rb
 - spec/childless_elements_referenced_as_collections_spec.rb
 - spec/simple_xml_collections_as_arrays_spec.rb
 - spec/simple_element_referenced_as_collections_spec.rb
+- spec/no_xml_parsers_are_available_spec.rb
 - spec/using_peachy_proxy_incorrectly_spec.rb
 - spec/inferring_a_method_from_an_attribute_spec.rb
+- spec/libxml_is_the_available_xml_parser_spec.rb
 - spec/camel_case_names_spec.rb
 - spec/attributes_on_a_parent_node_spec.rb
 - spec/pascal_case_names_spec.rb

data/lib/peachy/node_child_matcher.rb

@@ -1,22 +0,0 @@
-module Peachy
-  module NodeChildMatcher
-    # Runs the XPath for the method name against the underlying XML DOM,
-    # returning nil if no element or attribute matching the method name is found
-    # in the children of the current location in the DOM.
-    def find_matches method_name, node #=nokogiri_node
-      matches = node.xpath(xpath_for(method_name))
-      return nil if matches.length < 1
-      return matches
-    end
-
-    def find_match_by_attributes method_name, node
-      mapped = method_name.variations.map {|variation| node.attribute variation }
-      mapped.find {|match| match != nil }
-    end
-
-    # Gets the XPath for all variations of the MethodName instance
-    def xpath_for method_name
-      method_name.variations.map {|variation| "./#{variation}" } * '|'
-    end
-  end
-end