peachy 0.3.2 → 0.3.3

data/History.txt

@@ -1,3 +1,10 @@
+== 0.3.3
+* Minor improvements
+  * Added some more documentation to methods.
+  * Removed whiny-ness from specs.
+  * Improvements to structure of internals, introducing some new classes.
+  * Added some guard clauses on specs that are impacted when Nokogiri is not installed.
+
 == 0.3.2
 * Minor improvements
   * Better support for Ruby 1.8.6

data/README.rdoc

@@ -26,10 +26,10 @@ Once you have a Proxy, it's straightforward to drill down through the XML by
 node name:
 
     puts 'Contents: ' + proxy.xml.node.value
-    -> Contents: Peachy
+    => Contents: Peachy
 
-Call #value on a childless node to get the contents the node, such as the example
-above.
+Call #value on a childless node to get the contents of the node, such as the
+example above.
 
 Peachy expects method names to be called in the Ruby convention of lowercase with
 underscores.  It will do it's best to match method names to elements and attributes
@@ -43,7 +43,7 @@ It's possible to call #to_s on any node in the tree to get the underlying XML at
 that point in the tree, such as:
 
     puts 'XML: ' + proxy.xml.node
-    -> <node>Peachy</node>
+    => <node>Peachy</node>
 
 The exact representation of the XML will depend on the underlying XML parser that 
 is being used, but the XML will be valid and correct.

data/lib/nothing_to_mimic.rb

@@ -1,2 +1,9 @@
 class NothingToMimic < Exception
-end
+  def initialize
+    super <<MESSAGE
+You aren't using Mimic correctly.  Call Mimic.make_a_mimic_of(to_mimic, subject)
+passing the object to mimic as to_mimic and the target of the mimic invocation as
+subject.  Shazaaam!
+MESSAGE
+  end
+end

data/lib/peachy.rb

@@ -12,15 +12,14 @@ require File.join(File.dirname(__FILE__), 'peachy/mimic')
 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/xml_node')
+require File.join(File.dirname(__FILE__), 'peachy/current_method_call')
 require File.join(File.dirname(__FILE__), 'peachy/simple_content')
 require File.join(File.dirname(__FILE__), 'peachy/parsers/parser_factory')
-require File.join(File.dirname(__FILE__), 'peachy/parsers/with_xpath')
 require File.join(File.dirname(__FILE__), 'peachy/parsers/parser_wrapper')
 require File.join(File.dirname(__FILE__), 'peachy/parsers/nokogiri_wrapper')
 require File.join(File.dirname(__FILE__), 'peachy/parsers/rexml_wrapper')
 require File.join(File.dirname(__FILE__), 'peachy/parsers/rexml_attribute_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')
 
 module Peachy

data/lib/peachy/childless_proxy_with_attributes.rb

@@ -1,5 +1,5 @@
 module Peachy
-  class ChildlessProxyWithAttributes < Proxy
+  module ChildlessProxyWithAttributes
     # Returns the text content of the XML node encapsulated by this instance.
     def value
       acts_as_only_child
@@ -7,9 +7,13 @@ module Peachy
     end
 
     private
+    # The implementation for Proxy#generate_method_for_xml is far more straightforward
+    # when the underlying element is a childless element that has attributes.
     def generate_method_for_xml method_name
       method_name.check_for_convention
-      create_method_for_attribute(method_name) {|match| no_matching_xml(method_name) if match.nil? }
+      CurrentMethodCall.new(self, method_name).create_method_for_attribute do |match|
+        no_matching_xml(method_name) if match.nil?
+      end
     end
   end
 end

data/lib/peachy/current_method_call.rb

@@ -0,0 +1,51 @@
+module Peachy
+  class CurrentMethodCall
+      extend MethodMask
+      include MyMetaClass, XmlNode
+
+      def initialize proxy, method
+        @method_name = method
+        @proxy = proxy
+      end
+
+      def create_method_for_child_or_content matches
+        return define_child_array(matches) if matches.size > 1
+        child = matches[0].create_from_element
+        define_child_as(child)
+      end
+
+      def create_attribute
+        create_method_for_attribute if @proxy.node.has_children_and_attributes?
+      end
+
+      def create_method_for_attribute
+        match = find_match_by_attributes
+        yield match if block_given?
+        define_child_as(match.content) unless match.nil?
+      end
+
+      [:find_matches, :find_match_by_attributes].each do |method|
+        define_method(method) { @proxy.node.send(method, @method_name) }
+      end
+
+      def define_child_array matches
+        define_child(@method_name) { return CurrentMethodCall.matches_to_array(matches) }
+      end
+
+      def define_child_as child
+        define_child(method_name) { return child }
+      end
+
+      def define_child method_name, &block
+        @proxy.eval_on_singleton_class { define_method(method_name.to_sym, &block) }
+        yield
+      end
+
+      private
+      attr_reader :method_name
+
+      def self.matches_to_array matches
+        matches.inject([]) {|array, child| array << child.create_from_element }
+      end
+  end
+end

data/lib/peachy/method_name.rb

@@ -2,6 +2,8 @@ module Peachy
   class MethodName
     include StringStyler
 
+    [:to_s, :to_sym].each {|method| define_method(method) { @method_name.send(method) }}
+    
     def initialize method_name
       @method_name = method_name.to_s
     end
@@ -15,6 +17,10 @@ module Peachy
       end).uniq
     end
 
+    def as_xpath
+      variations.map {|variation| "./#{variation}" } * '|'
+    end
+
     # Checks whether the method name is in the accepted convention, raising a
     # MethodNotInRubyConvention if it's not.  This check does not allow method
     # names to have question marks, exclamation marks or numbers, however.
@@ -22,14 +28,6 @@ module Peachy
       raise MethodNotInRubyConvention.new(self) unless matches_convention?
     end
 
-    def to_s
-      return @method_name
-    end
-
-    def to_sym
-      return @method_name.to_sym
-    end
-
     private
     def variation_methods
       Peachy::StringStyler.private_instance_methods
@@ -39,7 +37,7 @@ module Peachy
     # underscores.  This method does not allow question marks, excalmation marks
     # or numbers, however.
     def matches_convention?
-      !(@method_name =~ /^[a-z]+(?:_[a-z]+){0,}$/).nil?
+      @method_name =~ /^[a-z]+(?:_[a-z]+){0,}$/
     end
   end
 end

data/lib/peachy/mimic.rb

@@ -1,11 +1,29 @@
 module Peachy
   module Mimic
-    def mimic
+    # Use this method to make a mimic of an object.  The first argument passed is
+    # the object to be mimicked and the second is the subject of the mimic action.
+    # All previous methods defined on the subject will be buried.
+    def self.make_a_mimic_of to_mimic, subject
+      subject.instance_eval do
+        (class << self; self; end).class_eval do
+          define_method(:subject) { to_mimic }
+          include Mimic
+        end
+      end
+    end
+
+    # This method has been defined as a template.  If you just include Mimic as 
+    # a module on your class you will get a NothingToMimic error when calling #mimic.
+    # 
+    # Use Mimic#make_a_mimic_of to turn an object into a mimic.
+    def subject
       raise NothingToMimic.new
     end
-    
+
+    # Delegates the method_missing call to the underlying object that is being
+    # mimicked.
     def method_missing method_name, *args, &block
-      mimic.send(method_name, *args, &block)
+      subject.send(method_name, *args, &block)
     end
   end
 end

data/lib/peachy/morph_into_array.rb

@@ -9,18 +9,11 @@ module Peachy
       Array.instance_methods.include?(method_name.to_s)
     end
 
-    def mimic object_to_mimic
-      eval_on_singleton_class do
-        define_method(:mimic) { object_to_mimic }
-        include Mimic
-      end
-    end
-
     def morph_into_array to_add_to_array, method_to_invoke, *args, &block
       puts "[Peachy::Proxy] Currently acts as #{@acts_as}" if Peachy.whiny?
-      raise AlreadyAnOnlyChild.new(name) if is_an_only_child
+      raise AlreadyAnOnlyChild.new(name) if is_an_only_child?
       puts "[Peachy::Proxy] So #{name} should be an Array, then." if Peachy.whiny?
-      mimic [to_add_to_array]
+      Mimic.make_a_mimic_of [to_add_to_array], self
       return send(method_to_invoke, *args, &block)
     end
 
@@ -28,7 +21,7 @@ module Peachy
       @acts_as = :only_child
     end
 
-    def is_an_only_child
+    def is_an_only_child?
        @acts_as == :only_child
     end
   end

data/lib/peachy/my_meta_class.rb

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

data/lib/peachy/parsers/nokogiri_wrapper.rb

@@ -1,8 +1,8 @@
 module Peachy
   module Parsers
     class NokogiriWrapper < ParserWrapper
-      include WithXPath
-      
+      [:content, :name, :to_s].each{|method| define_method(method){ @nokogiri.send(method) }}
+
       def initialize nokogiri
         @nokogiri = nokogiri
       end
@@ -11,7 +11,7 @@ module Peachy
       # 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))
+        matches = xpath(method_name.as_xpath)
         matches.any? ? matches : nil
       end
 
@@ -26,6 +26,7 @@ module Peachy
         has_children? and has_attributes?
       end
 
+      private
       # 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.
@@ -37,19 +38,6 @@ module Peachy
         @nokogiri.attribute_nodes.size > 0
       end
 
-      def content
-        @nokogiri.content
-      end
-
-      def name
-        @nokogiri.name
-      end
-
-      def to_s
-        @nokogiri.to_s
-      end
-
-      private
       def xpath xpath
         @nokogiri.xpath(xpath).map{|noko_node| make_from(noko_node) }
       end

data/lib/peachy/parsers/parser_factory.rb

@@ -1,22 +1,35 @@
 module Peachy
   module Parsers
     class ParserFactory
+      # Loads the first available XML parser defined in the list of parsers that
+      # Peachy can use.  This requires the Gem for the parser and creates the method
+      # make_from, which will return a new instance of the ParserWrapper for that
+      # library.
+      # In order of preference, the Gems that Peachy can currently use for parsing
+      # XML are:
+      #   * Nokogiri
+      #   * REXML
       def load_parser
-        return load_up(:nokogiri) if Gem.available? /nokogiri/
-        require('rexml/document')
-        @parser = :rexml
-      end
-
-      def make_from raw_xml
-        return NokogiriWrapper.new(Nokogiri::XML(raw_xml)) if @parser == :nokogiri
-        return REXMLWrapper.new(REXML::Document.new(raw_xml)) if @parser == :rexml
+        preferred_parser = Parsers.find {|parser| Gem.available? parser[:gem] }
+        preferred_parser = DefaultParser if preferred_parser.nil?
+        puts "Loading #{preferred_parser[:gem]} as the XML parser to use" if Peachy.whiny?
+        set_the_parser preferred_parser
       end
 
       private
-      def load_up xml_parser
-        require(xml_parser.to_s)
-        @parser = xml_parser
+      def set_the_parser preferred_parser
+        self.class.class_eval { define_method(:make_from, preferred_parser[:implementation]) }
+        require(preferred_parser[:gem])
       end
+
+      Parsers =
+        [{:gem => 'nokogiri', :implementation => lambda {|xml| NokogiriWrapper.new(Nokogiri::XML(xml)) }}]
+      
+      DefaultParser =
+        {
+          :gem => 'rexml/document',
+          :implementation => lambda {|xml| REXMLWrapper.new(REXML::Document.new(xml)) }
+        }
     end
   end
 end

data/lib/peachy/parsers/parser_wrapper.rb

@@ -1,7 +1,29 @@
 module Peachy
   module Parsers
     class ParserWrapper
-      def initialize
+      def create_from_element 
+        return create_proxy if has_children?
+        return create_proxy_with_attributes if has_attributes?
+        return create_content_child
+      end
+
+      private
+      def create_content_child 
+        SimpleContent.new(self)
+      end
+
+      def create_proxy 
+        Proxy.new(self)
+      end
+
+      def create_proxy_with_attributes 
+        childless_proxy_with_attributes = Proxy.new(self)
+        childless_proxy_with_attributes.instance_eval do
+          (class << self; self; end).instance_eval do
+            include ChildlessProxyWithAttributes
+          end
+        end
+        return childless_proxy_with_attributes
       end
     end
   end

data/lib/peachy/parsers/rexml_wrapper.rb

@@ -1,14 +1,14 @@
 module Peachy
   module Parsers
     class REXMLWrapper < ParserWrapper
-      include WithXPath
+      [:name, :to_s].each{|method| define_method(method) { @rexml.send(method) }}
 
       def initialize rexml_element
         @rexml = rexml_element
       end
 
       def find_matches method_name
-        matches = REXML::XPath.match(@rexml, xpath_for(method_name))
+        matches = REXML::XPath.match(@rexml, method_name.as_xpath)
         return nil if matches.size < 1
         matches.map {|node| REXMLWrapper.new(node)}
       end
@@ -18,14 +18,6 @@ module Peachy
         match.nil? ? nil : REXMLAttributeWrapper.new(match)
       end
 
-      def has_children?
-        @rexml.elements.size > 0
-      end
-
-      def has_attributes?
-        @rexml.attributes.size > 0
-      end
-
       def has_children_and_attributes?
         has_children? and has_attributes?
       end
@@ -34,12 +26,13 @@ module Peachy
         @rexml.text
       end
 
-      def name
-        @rexml.name
+      private
+      def has_children?
+        @rexml.elements.size > 0
       end
 
-      def to_s
-        @rexml.to_s
+      def has_attributes?
+        @rexml.attributes.size > 0
       end
     end
   end

data/lib/peachy/proxy.rb

@@ -4,9 +4,9 @@ module Peachy
     include 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
-    # the time being.
-    hide_public_methods ['methods', 'nil?', 'respond_to?', 'inspect']
+    # 'respond_to?', 'inspect' and 'instance_eval', which I've found are too
+    # useful / fundamental / dangerous to hide.
+    hide_public_methods ['methods', 'nil?', 'respond_to?', 'inspect', 'instance_eval']
 
     # Takes either a string containing XML or a Nokogiri::XML::Element as the
     # single argument.
@@ -84,7 +84,7 @@ module Peachy
         child_proxy
       elsif array_can?(method_name)
         # morph into an array, as method is a zero-length array call
-        new_proxy = ProxyFactory.create_from_element(node)
+        new_proxy = node.create_from_element
         morph_into_array(new_proxy, method_name)
       else
         no_matching_xml(method_name)
@@ -94,45 +94,13 @@ module Peachy
     private
     def generate_method_for_xml method_name
       method_name.check_for_convention
-      attribute_content = create_attribute(method_name)
+      current_call = CurrentMethodCall.new(self, method_name)
+      attribute_content = current_call.create_attribute
       return attribute_content unless attribute_content.nil?
-      matches = node.find_matches(method_name)
-      matches.nil? ? nil : create_method_for_child_or_content(method_name, matches)
+      matches = current_call.find_matches
+      matches.nil? ? nil : current_call.create_method_for_child_or_content(matches)
     end
 
-    def create_method_for_child_or_content method_name, matches
-      return create_from_element_list(method_name, matches) if matches.size > 1
-      child = ProxyFactory.create_from_element(matches[0])
-      define_child(method_name, child)
-    end
-
-    def create_attribute method_name
-      create_method_for_attribute(method_name) if node.has_children_and_attributes?
-    end
-
-    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_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 << ProxyFactory.create_from_element(child) }
-    end
-
-    def define_child method_name, child
-      define_method(method_name) { return child }
-    end
-
-    def define_method method_name, &block
-      eval_on_singleton_class { define_method(method_name.to_sym, &block) }
-      yield
-    end
-    
     def variables_are_nil?
       @xml.nil? and @node.nil?
     end

data/lib/peachy/version.rb

@@ -1,3 +1,3 @@
 module Peachy
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end

data/lib/peachy/xml_node.rb

@@ -1,8 +1,16 @@
 module Peachy
   module XmlNode
+    protected
+    # 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?
+      @node ||= create
+    end
+
     private
     def clone
-      ProxyFactory.create_from_element(node)
+      node.create_from_element
     end
 
     # Returns the name of the encapsulated node.
@@ -10,13 +18,6 @@ module Peachy
       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?
-      @node ||= create
-    end
-
     def create
       load_factory unless defined? @factory
       @factory.make_from @xml

data/spec/inferring_a_method_from_element_name_spec.rb

@@ -46,6 +46,7 @@ describe "inferring a method from an element name" do
     @proxy.methods.should include('nil?')
     @proxy.methods.should include('respond_to?')
     @proxy.methods.should include('to_s')
+    @proxy.methods.should include('instance_eval')
     @proxy.methods.should_not include('id')
   end
 end

data/spec/mimc_spec.rb

@@ -15,7 +15,7 @@ describe "using a Mimic" do
   it "should call the underlying object" do
     to_mimic = "Hello"
     @mimic.instance_eval do
-      (class << self; self; end).instance_eval { define_method(:mimic) { to_mimic } }
+      (class << self; self; end).instance_eval { define_method(:subject) { to_mimic } }
     end
     
     @mimic.chomp('o').should == "Hell"

data/spec/nokogiri_is_the_available_xml_parser_spec.rb

@@ -1,40 +1,48 @@
 require 'spec_helper'
-require 'nokogiri'
 
-describe "nokogiri is the available XML parser" do
-  before(:each) do
-    @factory = Peachy::Parsers::ParserFactory.new
-    expectation = @factory.stubs(:require).with('nokogiri').returns(true)
-  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" do
-    parser_type = @factory.load_parser
-    parser_type.should == :nokogiri
-  end
+# this is to ignore this spec if the nokogiri gem is not available
+if Gem.available? 'nokogiri'
+  require 'nokogiri'
 
-  it "should load Nokogiri" do
-    expectation = @factory.expects(:require).with('nokogiri').returns(true)
-    parser_type = @factory.load_parser
-    expectation.satisfied?.should be_true
-  end
+  describe "nokogiri is the available XML parser" do
+    before(:each) do
+      @factory = Peachy::Parsers::ParserFactory.new
+      expectation = @factory.stubs(:require).with('nokogiri').returns(true)
+    end
 
-  it "should not load REXML" do
-    expectation = @factory.expects(:require).with('rexml/document').never.returns(true)
-    parser_type = @factory.load_parser
-    expectation.satisfied?.should be_true
-  end
+    it "should indicate that the parser has been loaded" do
+      @factory.load_parser.should be_true
+    end
 
-  it "should create a NokogiriWrapper from xml" do
-    @factory.load_parser
-    wrapper = @factory.make_from '<thing>Stuff</thing>'
-    wrapper.should be_a(Peachy::Parsers::NokogiriWrapper)
-    wrapper.content.should == 'Stuff'
-  end
-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 load Nokogiri" do
+      expectation = @factory.expects(:require).with('nokogiri').returns(true)
+      parser_type = @factory.load_parser
+      expectation.satisfied?.should be_true
+    end
+
+    it "should not load REXML" do
+      expectation = @factory.expects(:require).with('rexml/document').never.returns(true)
+      parser_type = @factory.load_parser
+      expectation.satisfied?.should be_true
+    end
 
+    it "should enable a way to a new NokogiriWrapper" do
+      @factory.load_parser
+      @factory.methods.should include('make_from')
+    end
+
+    it "should create a NokogiriWrapper from xml" do
+      @factory.load_parser
+      wrapper = @factory.make_from '<thing>Stuff</thing>'
+      wrapper.should be_a(Peachy::Parsers::NokogiriWrapper)
+      wrapper.content.should == 'Stuff'
+    end
+  end
+end

data/spec/only_rexml_is_available_spec.rb

@@ -5,12 +5,12 @@ describe "only REXML is available" do
   before(:each) do
     @factory = Peachy::Parsers::ParserFactory.new
     @factory.stubs(:require).with('rexml/document').returns(true)
-    Gem.stubs(:available?).with(/nokogiri/).returns(false)
+    Gem.stubs(:available?).with('nokogiri').returns(false)
+    Gem.stubs(:available?).with('rexml/document').returns(true)
   end
 
-  it "should return REXML if no other XML parser is available" do
-    parser = @factory.load_parser
-    parser.should == :rexml
+  it "should indicate that the parser has been loaded" do
+    @factory.load_parser.should be_true
   end
 
   it "should load REXML" do
@@ -20,7 +20,7 @@ describe "only REXML is available" do
   end
 
   it "should check whether other XML parsers are available" do
-    expectation = Gem.expects(:available?).with(/nokogiri/).returns(false)
+    expectation = Gem.expects(:available?).with('nokogiri').returns(false)
     @factory.load_parser
     expectation.satisfied?.should be_true
   end
@@ -31,11 +31,16 @@ describe "only REXML is available" do
     expectation.satisfied?.should be_true
   end
 
+  it "should enable a way to a new REXMLWrapper" do
+    @factory.load_parser
+    @factory.methods.should include('make_from')
+  end
+
   it "should create a REXMLWrapper from xml" do
     @factory.load_parser
     wrapper = @factory.make_from '<thing>Stuff</thing>'
     wrapper.should be_a(Peachy::Parsers::REXMLWrapper)
-    wrapper.has_children?.should be_true
+    wrapper.name.should == ''
   end
 end
 

data/spec/parsers/all_parser_wrappers_spec.rb

@@ -25,14 +25,6 @@ shared_examples_for "all parser wrappers" do
     matches.should be_nil
   end
 
-  it "should indicate that an element has children" do
-    @wrapper.has_children?.should be_true
-  end
-
-  it "should indicate that an element has an attributes" do
-    @wrapper.has_attributes?.should be_true
-  end
-
   it "should indicate that an element has both children and an attribute" do
     @wrapper.has_children_and_attributes?.should be_true
   end

data/spec/parsers/nokigiri_wrapper_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
-require 'nokogiri'
 require File.join(File.dirname(__FILE__), 'all_parser_wrappers_spec')
 
-describe "a Peachy::Parsers::NokogiriWrapper" do
-  before(:each) do
-    @raw_xml = "<root type=\"test\">\n  <child>Name</child>\n</root>"
-    noko = Nokogiri::XML(@raw_xml)
-    @wrapper = Peachy::Parsers::NokogiriWrapper.new((noko/'root')[0])
-    @expected_wrapper_class = Peachy::Parsers::NokogiriWrapper
-  end
+# this is to ignore this spec if the nokogiri gem is not available
+if Gem.available? 'nokogiri'
+  require 'nokogiri'
+  describe "a Peachy::Parsers::NokogiriWrapper" do
+    before(:each) do
+      @raw_xml = "<root type=\"test\">\n  <child>Name</child>\n</root>"
+      noko = Nokogiri::XML(@raw_xml)
+      @wrapper = Peachy::Parsers::NokogiriWrapper.new((noko/'root')[0])
+      @expected_wrapper_class = Peachy::Parsers::NokogiriWrapper
+    end
 
-  it_should_behave_like "all parser wrappers"
+    it_should_behave_like "all parser wrappers"
+  end
 end
-

data/spec/spec_helper.rb

@@ -2,6 +2,5 @@ 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

data/spec/using_peachy_proxy_incorrectly_spec.rb

@@ -4,7 +4,8 @@ describe "using Peachy::Proxy incorrectly" do
   end
 
   it 'should raise a well written error if the method does not map to anything in the underlying XML node' do
-    lambda { @proxy.missing }.should raise_error(NoMatchingXmlPart, 'missing is not contained as a child of the node document.')
+    root_name = Gem.available?('nokogiri') ? 'document' : ''
+    lambda { @proxy.missing }.should raise_error(NoMatchingXmlPart, "missing is not contained as a child of the node #{root_name}.")
   end
 
   it "should raise an error if the method name is not in Ruby convention" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 2
-  version: 0.3.2
+  - 3
+  version: 0.3.3
 platform: ruby
 authors: 
 - NJ Pearman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-31 00:00:00 +01:00
+date: 2010-06-05 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -36,14 +36,13 @@ files:
 - lib/peachy/method_name.rb
 - lib/peachy/mimic.rb
 - lib/peachy/method_mask.rb
-- lib/peachy/proxy_factory.rb
 - lib/peachy/simple_content.rb
+- lib/peachy/current_method_call.rb
 - lib/peachy/version.rb
 - lib/peachy/proxy.rb
 - lib/peachy/parsers/rexml_attribute_wrapper.rb
 - lib/peachy/parsers/nokogiri_wrapper.rb
 - lib/peachy/parsers/parser_factory.rb
-- lib/peachy/parsers/with_xpath.rb
 - lib/peachy/parsers/parser_wrapper.rb
 - lib/peachy/parsers/rexml_wrapper.rb
 - lib/peachy/morph_into_array.rb

data/lib/peachy/parsers/with_xpath.rb

@@ -1,10 +0,0 @@
-module Peachy
-  module Parsers
-    module WithXPath
-      # Gets the XPath for all variations of the MethodName instance
-      def xpath_for method_name
-        method_name.variations.map {|variation| "./#{variation}" } * '|'
-      end
-    end
-  end
-end

data/lib/peachy/proxy_factory.rb

@@ -1,23 +0,0 @@
-module Peachy
-  class ProxyFactory
-    class << self
-      def create_from_element match
-        return create_proxy(match) if match.has_children?
-        return create_proxy_with_attributes(match) if match.has_attributes?
-        return create_content_child(match)
-      end
-
-      def create_content_child match
-        SimpleContent.new(match)
-      end
-
-      def create_proxy match
-        Proxy.new(match)
-      end
-
-      def create_proxy_with_attributes match
-        ChildlessProxyWithAttributes.new(match)
-      end
-    end
-  end
-end