peachy 0.2.1 → 0.3.0

data/History.txt

@@ -1,3 +1,22 @@
+== 0.3.0
+
+* Major improvements
+  * No longer hard-wired to Nokogiri, determining which XML parser is available
+    at first usage, defaulting to REXML if Nokogiri is not found.
+
+* Minor improvements
+  * Improved implementation of NokogiriWrapper.
+
+
+== 0.2.1
+
+* Major improvements
+  * Actually a breaking change from previous version, introducing NokogiriWrapper.
+    It's no longer possible to pass a Nokogiri node directly into Peachy.
+  * Only children can now be treated as if they are arrays in any way, morphing into
+    an array if treated as an array.
+
+
 == 0.2.0
 
 * Major improvements

data/README.rdoc

@@ -14,18 +14,14 @@ then
 
     require 'peachy'
 
-in irb/your codebase to get going.
+in irb / your codebase to get going.
 
 == Usage
 The Peachy::Proxy is the key class in Peachy.  Create a new instance of a
-Peachy::Proxy passing in either a raw XML string, or a Nokogiri::XML instance
+Peachy::Proxy by passing in a raw XML string
 
     proxy = Peachy::Proxy.new('<xml><node>Peachy</node></xml>')
 
-or
-
-    proxy = Peachy::Proxy.new(Nokogiri::XML('<xml><node>Peachy</node></xml>'))
-
 Once you have a Proxy, it's straightforward to drill down through the XML by
 node name:
 
@@ -43,8 +39,10 @@ More detailed usage examples can be found in the .rb files in the /test director
 
 === XML parsing
 
-Currently, Peachy is hard wired to use Nokogiri for XML parsing, but this will
-be abstracted out at some point.
+Peachy tries to determine which XML parser to load when it is first used.  Nokogiri
+is currently the first choice, defaulting to REXML if Nokogiri is not available.
+It's possible to extend this out so let me know if there are any other XML parsers
+that you'd like Peachy to support.
 
 === Elements and Attributes
 

data/lib/peachy.rb

@@ -4,7 +4,6 @@ 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')
@@ -13,14 +12,17 @@ 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/simple_content')
-require File.join(File.dirname(__FILE__), 'peachy/xml_parser_factory')
+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')
 
 # first up, load the underlying XML parser that Peachy will use
-Peachy::XmlParserFactory.new.load_parser
 
 module Peachy
   def self.whine
@@ -30,4 +32,16 @@ module Peachy
   def self.whiny?
     return @whine
   end
+
+  def self.proxy xml
+    create_factory unless defined? @factory
+    return Proxy.new(@factory.make_from(xml))
+  end
+
+  private
+  def self.create_factory
+    @factory ||= Peachy::Parsers::ParserFactory.new
+    @factory.load_parser
+    return @factory
+  end
 end

data/lib/peachy/parsers/nokogiri_wrapper.rb

@@ -1,6 +1,8 @@
 module Peachy
   module Parsers
-    class NokogiriWrapper
+    class NokogiriWrapper < ParserWrapper
+      include WithXPath
+      
       def initialize nokogiri
         @nokogiri = nokogiri
       end
@@ -10,32 +12,29 @@ module Peachy
       # 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
+        matches.any? ? matches : nil
       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)
+        match = @nokogiri.attribute_nodes.find do |attribute|
+          attribute if method_name.variations.include? attribute.name
+        end
+        match.nil? ? nil : make_from(match)
       end
 
       def has_children_and_attributes?
-        there_are_child_nodes? and node_has_attributes?
+        has_children? and 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 }
+      def has_children?
+        @nokogiri.children.any? {|child| child.kind_of? Nokogiri::XML::Element }
       end
 
-      def node_has_attributes?
-        attribute_nodes.size > 0
+      def has_attributes?
+        @nokogiri.attribute_nodes.size > 0
       end
 
       def content
@@ -47,26 +46,12 @@ module Peachy
       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) }
+        @nokogiri.xpath(xpath).map{|noko_node| make_from(noko_node) }
       end
 
-      def attribute attribute_name
-        noko = @nokogiri.attribute(attribute_name)
-        noko.nil?? nil : NokogiriWrapper.new(noko)
+      def make_from child
+        NokogiriWrapper.new(child)
       end
     end
   end

data/lib/peachy/parsers/parser_factory.rb

@@ -0,0 +1,22 @@
+module Peachy
+  module Parsers
+    class ParserFactory
+      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
+      end
+
+      private
+      def load_up xml_parser
+        require(xml_parser.to_s)
+        @parser = xml_parser
+      end
+    end
+  end
+end

data/lib/peachy/parsers/parser_wrapper.rb

@@ -0,0 +1,8 @@
+module Peachy
+  module Parsers
+    class ParserWrapper
+      def initialize
+      end
+    end
+  end
+end

data/lib/peachy/parsers/rexml_attribute_wrapper.rb

@@ -0,0 +1,17 @@
+module Peachy
+  module Parsers
+    class REXMLAttributeWrapper < ParserWrapper
+      def initialize array
+        @attribute = array
+      end
+
+      def content
+        @attribute.last
+      end
+
+      def name
+        @attribute.first
+      end
+    end
+  end
+end

data/lib/peachy/parsers/rexml_wrapper.rb

@@ -0,0 +1,42 @@
+module Peachy
+  module Parsers
+    class REXMLWrapper < ParserWrapper
+      include WithXPath
+
+      def initialize rexml_element
+        @rexml = rexml_element
+      end
+
+      def find_matches method_name
+        matches = REXML::XPath.match(@rexml, xpath_for(method_name))
+        return nil if matches.size < 1
+        matches.map {|node| REXMLWrapper.new(node)}
+      end
+
+      def find_match_by_attributes method_name
+        match = @rexml.attributes.find {|attribute| method_name.variations.include? attribute.first }
+        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
+
+      def content
+        @rexml.text
+      end
+
+      def name
+        @rexml.name
+      end
+    end
+  end
+end

data/lib/peachy/parsers/with_xpath.rb

@@ -0,0 +1,10 @@
+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.rb

@@ -13,7 +13,7 @@ module Peachy
     # single argument.
     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
+      @node = xml_node if xml_node.kind_of? Peachy::Parsers::ParserWrapper
     end
 
     # Overloaded so that calls to methods representative of an XML element or
@@ -113,7 +113,7 @@ module Peachy
     end
 
     def create_from_element_list method_name, matches
-        define_method(method_name) { return matches_to_array(matches) }
+      define_method(method_name) { return matches_to_array(matches) }
     end
 
     def matches_to_array matches
@@ -130,7 +130,7 @@ module Peachy
     end
     
     def variables_are_nil?
-      @xml.nil? and @nokogiri_node.nil?
+      @xml.nil? and @node.nil?
     end
 
     def no_matching_xml method_name

data/lib/peachy/proxy_factory.rb

@@ -2,22 +2,11 @@ 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_proxy(match) if match.has_children?
+        return create_proxy_with_attributes(match) if match.has_attributes?
         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

data/lib/peachy/version.rb

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

data/lib/peachy/xml_node.rb

@@ -14,7 +14,18 @@ module Peachy
     # variable.
     def node
       raise InvalidProxyParameters.new(:xml => nil, :nokogiri => nil) if variables_are_nil?
-      @nokogiri_node ||= Peachy::Parsers::NokogiriWrapper.new(Nokogiri::XML(@xml))
+      @node ||= create
+    end
+
+    def create
+      load_factory unless defined? @factory
+      @factory.make_from @xml
+    end
+
+    private
+    def load_factory
+      @factory = Peachy::Parsers::ParserFactory.new
+      @factory.load_parser
     end
   end
 end

data/spec/attributes_on_a_parent_node_spec.rb

@@ -2,7 +2,7 @@ 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>'
+    @proxy = Peachy::Proxy.new '<root><test_node name="Test"><child>Check meh.</child></test_node></root>'
   end
 
   it "should return the child when accessing it by name" do

data/spec/camel_case_names_spec.rb

@@ -5,7 +5,7 @@ describe "interpreting element and attribute names that are defined in camelCase
 <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>
+  <thirdNode id="2" recordLabel="Wall of Sound"><child>Nested</child></thirdNode>
 </root>
 XML
   end

data/spec/nokogiri_is_the_available_xml_parser_spec.rb

@@ -1,8 +1,10 @@
 require 'spec_helper'
+require 'nokogiri'
 
 describe "nokogiri is the available XML parser" do
   before(:each) do
-    @factory = Peachy::XmlParserFactory.new
+    @factory = Peachy::Parsers::ParserFactory.new
+    expectation = @factory.stubs(:require).with('nokogiri').returns(true)
   end
 
   it "should check whether Nokogiri is available" do
@@ -11,15 +13,28 @@ describe "nokogiri is the available XML parser" do
     expectation.satisfied?.should be_true
   end
   
-  it "should return Nokogiri if Nokogiri is an available gem" do
+  it "should return Nokogiri" do
     parser_type = @factory.load_parser
     parser_type.should == :nokogiri
   end
 
-  it "should load Nokogiri if Nokogiri is an available gem" do
+  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 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
 

data/spec/only_rexml_is_available_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'rexml/document'
+
+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)
+  end
+
+  it "should return REXML if no other XML parser is available" do
+    parser = @factory.load_parser
+    parser.should == :rexml
+  end
+
+  it "should load REXML" do
+    expectation = @factory.expects(:require).with('rexml/document').returns(true)
+    @factory.load_parser
+    expectation.satisfied?.should be_true
+  end
+
+  it "should check whether other XML parsers are available" do
+    expectation = Gem.expects(:available?).with(/nokogiri/).returns(false)
+    @factory.load_parser
+    expectation.satisfied?.should be_true
+  end
+
+  it "should not load any other XML parsers" do
+    expectation = @factory.expects(:require).with('nokogiri').never.returns(false)
+    @factory.load_parser
+    expectation.satisfied?.should be_true
+  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
+  end
+end
+

data/spec/parsers/all_parser_wrappers_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+shared_examples_for "all parser wrappers" do
+  it "should be able to find the correct matches in the underlying XML" do
+    matches = @wrapper.find_matches(Peachy::MethodName.new('child'))
+    matches.size.should == 1
+    matches[0].name.should == 'child'
+    matches[0].content.should == 'Name'
+    matches[0].should be_a @expected_wrapper_class
+  end
+
+  it "should return no matches for a child name that doesn't exist" do
+    matches = @wrapper.find_matches(Peachy::MethodName.new('not_a_child'))
+    matches.should be_nil
+  end
+
+  it "should be able to find the correct attribute matches in the underlying XML" do
+    match = @wrapper.find_match_by_attributes(Peachy::MethodName.new('type'))
+    match.name.should == 'type'
+    match.content.should == 'test'
+  end
+
+  it "should return no matches for an attribute name that doesn't exist" do
+    matches = @wrapper.find_match_by_attributes(Peachy::MethodName.new('attrbiute'))
+    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
+end
+
+describe "the Nokogiri parser wrapper class" do
+  before(:each) do
+    noko = Nokogiri::XML('<root type="test"><child>Name</child></root>')
+    @wrapper = Peachy::Parsers::NokogiriWrapper.new((noko/'root')[0])
+    @expected_wrapper_class = Peachy::Parsers::NokogiriWrapper
+  end
+
+  it_should_behave_like "all parser wrappers"
+end
+
+require 'rexml/document'
+
+describe "the REXML parser wrapper class" do
+  before(:each) do
+    rexml = REXML::Document.new('<root type="test"><child>Name</child></root>')
+    @wrapper = Peachy::Parsers::REXMLWrapper.new rexml.root
+    @expected_wrapper_class = Peachy::Parsers::REXMLWrapper
+  end
+
+  it_should_behave_like "all parser wrappers"
+end

data/spec/pascal_case_names_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
+
 describe "interpreting element and attribute names that are defined in PascalCase" do
   before(:each) do
     @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>
+  <ThirdNode Id="2" RecordLabel="Wall of Sound"><Child>Check meh again.</Child></ThirdNode>
 </Root>
 XML
   end

data/spec/peachy_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Peachy do
+  it "should allow the creation of a new Proxy" do
+    proxy = Peachy.proxy '<test>Hello</test>'
+    proxy.test.value.should == 'Hello'
+  end
+end
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - NJ Pearman
@@ -14,26 +14,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-18 00:00:00 +01:00
+date: 2010-05-26 00:00:00 +01:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 3
-        - 3
-        version: 1.3.3
-  type: :runtime
-  version_requirements: *id001
+dependencies: []
+
 description: |
   Peachy is an XML slurper that sits on top of existing XML parsers.  It dynamically
-  creates object-style hierachies for simple integration of XML data sources.
+  creates object-trees for simple integration of XML data sources.
 
 email: 
 - n.pearman@gmail.com
@@ -48,18 +35,21 @@ files:
 - 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/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
 - lib/peachy/my_meta_class.rb
 - lib/peachy/string_styler.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
@@ -67,20 +57,20 @@ files:
 - 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
+- spec/peachy_spec.rb
+- spec/only_rexml_is_available_spec.rb
+- spec/parsers/all_parser_wrappers_spec.rb
 - spec/inferring_a_method_from_element_name_spec.rb
 - spec/spec_helper.rb
 - spec/nested_elements_spec.rb
@@ -102,8 +92,10 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="

data/lib/no_xml_parser_available.rb

@@ -1,10 +0,0 @@
-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/xml_parser_factory.rb

@@ -1,15 +0,0 @@
-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/spec/libxml_is_the_available_xml_parser_spec.rb

@@ -1,30 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/peachy_parsers_nokogiri_spec.rb

@@ -1,28 +0,0 @@
-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
-