peachy 0.1.2 → 0.2.0

data/History.txt

@@ -0,0 +1,7 @@
+== 0.2.0
+
+* Major improvements
+  * Can now treat only children as if they are the first element in an array.
+  * Console output is now configurable.
+  * Test specs are now included in gem.
+

data/README.rdoc

@@ -6,26 +6,34 @@ on the fly to match the elements and attributes of the XML.
 Source available at http://github.com/njpearman/Peachy
 
 == Install
-There is no gem available for Peachy yet.  This is the next bit of work to
-complete. In the meantime, if you wish to mess around with Peachy, download and
-include the source files in /lib within your project.
+The Peachy Ruby gem is available as you would expect.  Run:
+
+    gem install peachy
+
+then
+
+    require 'peachy'
+
+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
 
-    proxy = Peachy::Proxy.new :xml => '<xml><node>Peachy</node></xml>'
+    proxy = Peachy::Proxy.new('<xml><node>Peachy</node></xml>')
 
 or
 
-    proxy = Peachy::Proxy.new :nokogiri => Nokogiri::XML('<xml><node>Peachy</node></xml>')
+    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:
 
-    puts 'Contents: ' + proxy.xml.node
+    puts 'Contents: ' + proxy.xml.node.value
     -> Contents: Peachy
 
+Either .value or .to_s can be called to get the contents of the current node.
+
 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
 following different conventions (currently, this is camelCaseNames, PascalCaseNames
@@ -40,12 +48,21 @@ be abstracted out at some point.
 
 === Elements and Attributes
 
-Currently, elements and attributes are accessed in exactly the same way; that is,
+Currently, elements and attributes are accessed in almost exactly the same way;
 call a method on your current node matching the attribute or element name that
-is required next.
-As Peachy is just for slurping XML, it makes it easy to know how to access
-the property that you're after if the conventions are the same for noth elements
-and attributes.
+is required next.  Elements need to have .value or .to_s called on them to get
+the contents of the element, however.
+
+E.g.
+
+    proxy = Peachy::Proxy.new('<peachy version="1.0.0"><node>Peachy is here.</node></peachy>')
+    puts "Element contents: " + proxy.peachy.node.value
+    => Element contents: Peachy is here
+    puts "Element attribute: " + proxy.peachy.version
+    => Element attribute: 1.0.0
+
+Peachy is just for slurping XML, so this convention should make it easy to know
+how to access the property that you're after, be they elements or attributes.
 
 === No method name match
 

data/lib/already_an_only_child.rb

@@ -0,0 +1,8 @@
+class AlreadyAnOnlyChild < Exception
+  def initialize node_name
+    super <<MESSAGE
+The '#{node_name}' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MESSAGE
+  end
+end

data/lib/no_matching_xml_part.rb

@@ -1,5 +1,5 @@
 class NoMatchingXmlPart < Exception
-  def initialize method_name
-    super "#{method_name} is not contained as a child of this node."
+  def initialize method_name, node_name
+    super "#{method_name} is not contained as a child of the node #{node_name}."
   end
 end

data/lib/peachy.rb

@@ -1,3 +1,4 @@
+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')
@@ -5,8 +6,19 @@ 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/simple_content')
 require File.join(File.dirname(__FILE__), 'peachy/proxy')
 require File.join(File.dirname(__FILE__), 'peachy/childless_proxy_with_attributes')
 
 module Peachy
+  def self.whine
+    @whine = true
+  end
+
+  def self.whiny?
+    return @whine
+  end
 end

data/lib/peachy/childless_proxy_with_attributes.rb

@@ -1,6 +1,7 @@
 module Peachy
   class ChildlessProxyWithAttributes < Proxy
     def value
+      acts_as_only_child
       @nokogiri_node.content
     end
 
@@ -8,13 +9,8 @@ module Peachy
     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 if match.nil?
-      return create_content_child(match) {|child| define_child method_name, child }
-    end
-
-    def find_match_by_attributes method_name, node
-      mapped = method_name.variations.map {|variation| node.attribute variation }
-      mapped.find {|match| match != nil }
+      raise NoMatchingXmlPart.new method_name, node_name if match.nil?
+      return create_value(match) {|child| define_child method_name, child }
     end
   end
 end

data/lib/peachy/morph_into_array.rb

@@ -0,0 +1,38 @@
+module Peachy
+  module MorphIntoArray
+    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
+      Array.instance_methods.include?(method_name.to_s)
+    end
+
+    def mimic object_to_mimic
+      eval_on_singleton_class do
+        # NetBeans complains about this syntax, but it's fine.
+        define_method(:method_missing) do |method_name, *args, &block|
+          puts "[Peachy::Proxy] #{node_name} can only do '#{method_name}' with '#{args}' if an Array can.  You see, really, #{node_name} is an array now." if Peachy.whiny?
+          return object_to_mimic.send(method_name, *args, &block)
+        end
+      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(node_name) if is_an_only_child
+      puts "[Peachy::Proxy] So #{node_name} should be an Array, then." if Peachy.whiny?
+      mimic [to_add_to_array]
+      return send(method_to_invoke, *args, &block)
+    end
+
+    def acts_as_only_child
+      @acts_as = :only_child
+    end
+
+    def is_an_only_child
+       @acts_as == :only_child
+    end
+  end
+end

data/lib/peachy/my_meta_class.rb

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

data/lib/peachy/node_child_matcher.rb

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

data/lib/peachy/proxy.rb

@@ -5,23 +5,18 @@ module Peachy
   class Proxy
     alias_method :original_method_missing, :method_missing
     extend MethodMask
-    include ConventionChecks
+    include ConventionChecks, MorphIntoArray, MyMetaClass, NodeChildMatcher
 
-    # This hides all public methods on the class except for 'methods' and
+    # 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', 'respond_to?', 'inspect']
-
-    # Takes a hash as an argument.  Valid keys are:
-    #   :xml -
-    #       used to pass raw XML into the Proxy, and the XML parser will be
-    #       created on the fly.
-    #   :nokogiri -
-    #       can be used to pass in a Nokogiri::XML instance, if one has
-    #       already been created.
+    hide_public_methods ['methods', 'nil?', 'respond_to?', 'inspect']
+
+    # Takes either a string containing XML or a Nokogiri::XML::Element as the
+    # single argument.
     def initialize arguments
-      @nokogiri_node = arguments[:nokogiri]
-      @xml = arguments[:xml]
+      @xml = arguments if arguments.kind_of? String
+      @nokogiri_node = arguments if arguments.kind_of? Nokogiri::XML::Element
     end
 
     # Overloaded so that calls to methods representative of an XML element or
@@ -39,53 +34,82 @@ module Peachy
     # is made to call a method on a Peachy::Proxy that breaks this convention,
     # Peachy will simply raise a MethodNotInRubyConvention error.
     #
+    # Collections are referenced as an array following the name of the individual
+    # items of the collection.
+    #
+    # e.g.
+    # xml = <<XML
+    # <feed>
+    #   <items>
+    #     <item>Story 1</item>
+    #     <item>Story 2</item>
+    #     <item>Story 3</item>
+    #   </items>
+    # </feed>
+    # XML
+    # 
+    # @proxy = Peachy::Proxy xml
+    # @proxy.feed.items.item[0]
+    # => Story 1
+    # @proxy.feed.items.item[2]
+    # => Story 3
+    #
+    # Note that Peachy will try to manage the case where a
+    # single node is treated as the the first and only element in a collection.
+    # In this case, the pattern above will apply.  Also, if an element is treated
+    # as a single child, but later treated as if it should be part of a
+    # collection, then an AlreadyASingleChild error will be raised.  You can't
+    # expect a node to be both a single child AND a single element in a
+    # collection.
+    #
     # Any calls to undefined methods that include arguments or a block will be
     # deferred to the default implementation of method_missing.
-    def method_missing method_name_symbol, *args, &block
-      original_method_missing method_name_symbol, args, &block if args.any? or block_given?
-      generate_method_for_xml MethodName.new(method_name_symbol)
+    #
+    def method_missing method_name, *args, &block
+      # check whether an Array method is called with arguments or a block
+      if you_use_me_like_an_array(method_name, block_given?, *args)
+        return morph_into_array(clone, method_name, *args, &block)
+      end
+
+      # standard method_missing for any other call with arguments or a block
+      original_method_missing method_name, args if args.any? or block_given?
+
+      # try to create a method for the element
+      child_proxy = generate_method_for_xml(MethodName.new(method_name))
+
+      if !child_proxy.nil?
+        # found a match, so flag as only child
+        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_array(new_proxy, method_name)
+      else
+        # no matches, so throw
+        raise NoMatchingXmlPart.new(method_name, node_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_from_parent_with_attribute(method_name, nokogiri_node)
       return attribute_content unless attribute_content.nil?
-      create_method_for_child_or_content method_name, nokogiri_node
-    end
-
-    def nokogiri_node
-      raise InvalidProxyParameters.new(:xml => nil, :nokogiri => nil) if variables_are_nil?
-      @nokogiri_node ||= Nokogiri::XML(@xml)
-    end
-
-    def variables_are_nil?
-      @xml.nil? and @nokogiri_node.nil?
+      matches = find_matches(method_name, nokogiri_node)
+      matches.nil? ? nil : create_method_for_child_or_content(method_name, matches)
     end
 
-    def create_method_for_child_or_content method_name, node
-      matches = find_matches(method_name, node)
-      return create_from_element_list method_name, matches if matches.size > 1
+    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
 
-    # Runs the xpath for the method name against the underlying XML DOM, raising
-    # a NoMatchingXmlPart 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))
-      raise NoMatchingXmlPart.new(method_name) if matches.length < 1
-      return matches
-    end
-
-    def xpath_for method_name
-      method_name.variations.map {|variation| "./#{variation}" } * '|'
-    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_content_child(match) {|child| define_child method_name, child } unless match.nil?
+        create_value(match) {|child| define_child(method_name, child) } unless match.nil?
       end
     end
 
@@ -98,9 +122,9 @@ module Peachy
     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
+      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)
     end
 
     def node_has_attributes? match
@@ -114,16 +138,20 @@ module Peachy
       match.children.any? {|child| child.kind_of? Nokogiri::XML::Element }
     end
 
+    def create_value match, &block
+      create_child(match.content, &block)
+    end
+    
     def create_content_child match, &block
-      create_child match.content, &block
+      create_child(SimpleContent.new(match.content, match.name), &block)
     end
 
     def create_proxy match, &block
-      create_child Proxy.new(:nokogiri => match), &block
+      create_child(Proxy.new(match), &block)
     end
 
     def create_proxy_with_attributes match, &block
-      create_child ChildlessProxyWithAttributes.new(:nokogiri => match), &block
+      create_child ChildlessProxyWithAttributes.new(match), &block
     end
 
     def create_child child
@@ -135,16 +163,26 @@ module Peachy
       define_method(method_name) { return child }
     end
 
-    # I don't like this hacky way of getting hold of the singleton class to define
-    # a method, but it's better than instance_eval'ing a dynamic string to define
-    # a method.
     def define_method method_name, &block
-      get_my_singleton_class.class_eval { define_method method_name.to_sym, &block }
+      eval_on_singleton_class { define_method(method_name.to_sym, &block) }
       yield
     end
+    
+    def variables_are_nil?
+      @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 get_my_singleton_class
-      (class << self; self; end)
+    def clone
+      create_from_element(nokogiri_node)
     end
   end
 end

data/lib/peachy/simple_content.rb

@@ -0,0 +1,26 @@
+module Peachy
+  class SimpleContent
+    alias_method :original_method_missing, :method_missing
+    attr_reader :node_name
+    include MorphIntoArray, MyMetaClass
+    [:to_s, :name].each {|method_name| define_method(method_name) { value } }
+
+    def initialize value, node_name
+      @value = value
+      @node_name = node_name
+    end
+
+    def value
+      acts_as_only_child
+      @value
+    end
+
+    def method_missing method_name, *args, &block
+      if you_use_me_like_an_array(method_name, block_given?, *args)
+        new_content = SimpleContent.new(@value, @node_name)
+        return morph_into_array(new_content, method_name, *args, &block)
+      end
+      original_method_missing method_name, *args
+    end
+  end
+end

data/lib/peachy/version.rb

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

data/spec/attributes_on_a_parent_node_spec.rb

@@ -0,0 +1,18 @@
+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>'
+  end
+
+  it "should return the child when accessing it by name" do
+    @proxy.root.test_node.child.value.should == 'Check meh.'
+  end
+
+  it "should return the parent attribute by name" do
+    @proxy.root.test_node.name.should == 'Test'
+  end
+
+  it "should define the attribute name as a method" do
+    @proxy.root.test_node.name
+    @proxy.root.test_node.methods.should include 'name'
+  end
+end

data/spec/camel_case_names_spec.rb

@@ -0,0 +1,24 @@
+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>'
+  end
+
+  it "should match a method to an element by camel case" do
+    @proxy.root.test_node.value.should == 'Check meh.'
+  end
+
+  it "should define a method from a camel cased element name" do
+    @proxy.root.test_node.value.should == 'Check meh.'
+    @proxy.root.methods.should include 'test_node'
+  end
+
+  it "should match a method to an attribute by camel case" do
+    @proxy.root.second_node.record_label.should == "Wall of Sound"
+  end
+
+  it "should define a method from camel cased attribute name" do
+    @proxy.root.second_node.record_label
+    @proxy.root.second_node.methods.should include 'record_label'
+  end
+end
+

data/spec/childless_elements_referenced_as_collections_spec.rb

@@ -0,0 +1,48 @@
+describe "a childless element with attributes referenced as the first part of a collection" do
+  before(:each) do
+    xml = <<XML
+<xml>
+  <list>
+    <item id="1">Hello</item>
+  </list>
+</xml>
+XML
+    @proxy = Peachy::Proxy.new xml
+  end
+
+  it "should infer that the element matches the first index of an array" do
+    @proxy.xml.list.item[0].value.should == 'Hello'
+  end
+
+  it "should make attributes available on the single child" do
+    @proxy.xml.list.item[0].id.should == '1'
+  end
+
+  it "should quack like an array" do
+    @proxy.xml.list.item[0]
+
+    element_as_array = @proxy.xml.list.item
+    element_as_array.any?.should be_true
+    element_as_array.one?.should be_true
+    element_as_array.empty?.should be_false
+    element_as_array.size.should == 1
+    element_as_array[0].value.should == 'Hello'
+  end
+
+  it "should raise an error if the element value has already been accessed as an only child" do
+    @proxy.xml.list.item.value
+    lambda { @proxy.xml.list.item[0] }.should raise_error AlreadyAnOnlyChild, <<MSG
+The 'item' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MSG
+  end
+
+  it "should raise an error if the element's attributes have already been accessed as an only child" do
+    @proxy.xml.list.item.id
+    lambda { @proxy.xml.list.item[0] }.should raise_error AlreadyAnOnlyChild, <<MSG
+The 'item' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MSG
+  end
+end
+

data/spec/collections_with_children_as_arrays_spec.rb

@@ -0,0 +1,36 @@
+describe "collections with children as arrays" do
+  before(:each) do
+    xml = <<STR
+<xml>
+  <list>
+    <item>
+      <child>one</child>
+    </item>
+    <item>
+      <child>two</child>
+    </item>
+    <item>
+      <child>three</child>
+    </item>
+  </list>
+</xml>
+STR
+    @peachy_proxy = Peachy::Proxy.new xml
+  end
+
+  it "should create an array with the correct size" do
+    @peachy_proxy.xml.list.item.size.should == 3
+  end
+
+  it "should define a method for the name of the list items" do
+    @peachy_proxy.xml.list.item
+    @peachy_proxy.xml.list.methods.should include 'item'
+  end
+
+  it "should create the children as expected" do
+    @peachy_proxy.xml.list.item[0].child.value.should == "one"
+    @peachy_proxy.xml.list.item[1].child.value.should == "two"
+    @peachy_proxy.xml.list.item[2].child.value.should == "three"
+  end
+end
+

data/spec/elements_referenced_as_collections_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "an element referenced as the first part of a collection" do
+  before(:each) do
+    xml = <<XML
+<xml>
+  <list>
+    <item id="1">
+      <child>one</child>
+    </item>
+  </list>
+</xml>
+XML
+    @proxy = Peachy::Proxy.new xml
+  end
+
+  it "should infer that the element matches the first index of an array" do
+    @proxy.xml.list.item[0].child.value.should == 'one'
+  end
+
+  it "should make attributes available on the single child" do
+    @proxy.xml.list.item[0].id.should == '1'
+  end
+
+  it "should quack like an Array after an array element is referenced" do
+    @proxy.xml.list.item[0]
+
+    element_as_array = @proxy.xml.list.item
+    element_as_array.any?.should be_true
+    element_as_array.one?.should be_true
+    element_as_array.empty?.should be_false
+    element_as_array.size.should == 1
+    (element_as_array.map {|item| item.child.value }).should == ['one']
+    element_as_array[0].child.value.should == 'one'
+  end
+
+  it "should quack like an array when an Array method is sent to node with a block" do
+    @values = []
+    @proxy.xml.list.item.each {|node| @values << node.id}
+    @values.should == ['1']
+  end
+
+  it "should quack like an array when an Array method is sent to node with no arguments" do
+    @values = []
+    @proxy.xml.list.item.size.should == 1
+  end
+
+  it "should raise an error if the element has already been accessed as a single child" do
+    @proxy.xml.list.item.child
+    lambda { @proxy.xml.list.item[0] }.should raise_error AlreadyAnOnlyChild, <<MSG
+The 'item' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MSG
+  end
+end
+

data/spec/hyphen_separated_names_spec.rb

@@ -0,0 +1,15 @@
+describe "interpretting element names that contain hyphens" do
+  before(:each) do
+    @proxy = Peachy::Proxy.new '<test-node>Check meh.</test-node>'
+  end
+
+  it "should try to match a method to a node with hyphens" do
+    @proxy.test_node.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
+end
+

data/spec/inferring_a_method_from_an_attribute_spec.rb

@@ -0,0 +1,23 @@
+describe "inferring a method from an attribute" do
+  before(:each) do
+    @proxy = Peachy::Proxy.new '<test-node id="1" another="yellow">Check meh.</test-node>'
+  end
+
+  it "should be able to access node contents by 'value'" do
+    @proxy.test_node.value.should == 'Check meh.'
+  end
+
+  it "should be able to generate a method representing an attribute" do
+    @proxy.test_node.id.should == '1'
+  end
+
+  it "should define a method for the attribute name" do
+    @proxy.test_node.another
+    @proxy.test_node.methods.should include 'another'
+  end
+
+  it "should raise an error if method name doesn't match an attribute name" do
+    lambda { @proxy.test_node.missing }.should raise_error NoMatchingXmlPart, "missing is not contained as a child of the node test-node."
+  end
+end
+

data/spec/inferring_a_method_from_element_name_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+describe "inferring a method from an element name" do
+  before(:each) do
+    xml = '<testnode>Check meh.</testnode>'
+    @proxy = Peachy::Proxy.new xml
+    @another_proxy = Peachy::Proxy.new xml
+  end
+
+  it "should defer method_missing to the base class implementation if arguments are passed with the missing method" do
+    lambda { @proxy.my_call "argument" }.should raise_error NoMethodError
+  end
+
+  it "should defer method_missing to the base class implementation if block is given with method_missing" do
+    lambda { @proxy.my_call() { puts "Blockhead." } }.should raise_error NoMethodError
+  end
+
+  it "should not expose the original method_missing alias publically" do
+    @proxy.methods.include?('original_method_missing').should be_false
+  end
+
+  it 'should add a reader for the method to the underlying class if the method does map to underlying XML node' do
+    @proxy.testnode
+    @proxy.methods.include?('testnode').should be_true
+  end
+
+  it 'should define the method on an instance, not on the class' do
+    @proxy.testnode
+    @proxy.methods.should include 'testnode'
+    @another_proxy.methods.should_not include 'testnode'
+  end
+
+  it "should return the node contents when the node isn't defined as a method and the contents of the node is at the lowest point of the tree" do
+    @proxy.testnode.value.should == 'Check meh.'
+  end
+
+  it "should define a method that returns the node contents is at the lowest point of the tree" do
+    contents_when_not_defined = @proxy.testnode.value
+    contents_after_defined = @proxy.testnode.value
+    contents_after_defined.should == 'Check meh.'
+    contents_after_defined.should == contents_when_not_defined
+  end
+
+  it "should only contain the expected public and protected methods" do
+    @proxy.methods.should include('inspect')
+    @proxy.methods.should include('methods')
+    @proxy.methods.should include('nil?')
+    @proxy.methods.should include('respond_to?')
+    @proxy.methods.should_not include('id')
+  end
+end

data/spec/method_name_spec.rb

@@ -0,0 +1,49 @@
+describe "how to use Peachy::MethodName" do
+  before(:each) do
+    @method_name = Peachy::MethodName.new 'method_name'
+  end
+
+  it "should return the original string as to_s" do
+    @method_name.to_s.should == "method_name"
+  end
+
+  it "should return the expected symbol as to_sym" do
+    @method_name.to_sym.should == :method_name
+  end
+
+  it "should return the expected number of variations in format" do
+    @method_name.variations.size.should == 4
+  end
+
+  it "should return the expected variation formats" do
+    variations = @method_name.variations
+
+    variations.should include 'method_name'
+    variations.should include 'methodName'
+    variations.should include 'method-name'
+    variations.should include 'MethodName'
+  end
+
+  it "should be possible to create a MethodName from a symbol" do
+    @method_name = Peachy::MethodName.new :this_method
+    variations = @method_name.variations
+
+    @method_name.to_s.should == 'this_method'
+    @method_name.to_sym.should == :this_method
+    
+    variations.should include 'this_method'
+    variations.should include 'thisMethod'
+    variations.should include 'this-method'
+    variations.should include 'ThisMethod'
+  end
+
+  it "should not include duplicates in variations" do
+    @method_name = Peachy::MethodName.new :method
+    variations = @method_name.variations
+
+    variations.size.should == 2
+    variations.should include 'method'
+    variations.should include 'Method'
+  end
+end
+

data/spec/nested_elements_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'ruby-debug'
+
+describe "nested elements should be handled corectly by Peachy" do
+  before(:each) do
+    @proxy = Peachy::Proxy.new '<root><first><second>Check meh.</second></first></root>'
+  end
+
+  it "should be able to dot through the DOM hierachy" do
+    @proxy.root.first.second.value.should == 'Check meh.'
+  end
+
+  it "should define methods for the ancestors" do
+    @proxy.root.first.second
+    @proxy.root.methods.should include 'first'
+    @proxy.root.first.methods.should include 'second'
+  end
+end
+

data/spec/nodes_with_children_spec.rb

@@ -0,0 +1,22 @@
+describe "nodes with multiple children should be handled correctly" do
+  before(:each) do
+    @peachy_proxy = Peachy::Proxy.new '<testnode><child>Check meh.</child><second_child><ancestor>Check meh two times.</ancestor></second_child></testnode>'
+    @node_to_test = @peachy_proxy.testnode
+  end
+
+  it "should recurse the Proxy to children so that a child will have the correct value" do
+    @node_to_test.child.value.should == "Check meh."
+  end
+
+  it "should define a method with the child name on the proxy" do
+    @node_to_test.child
+    @node_to_test.second_child
+    @node_to_test.methods.should include 'child'
+    @node_to_test.methods.should include 'second_child'
+  end
+
+  it "should recurse the Proxy to ancestors so that a child will have the correct value" do
+    @node_to_test.second_child.ancestor.value.should == "Check meh two times."
+  end
+end
+

data/spec/pascal_case_names_spec.rb

@@ -0,0 +1,24 @@
+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>'
+  end
+
+  it "should match a method to an element by pascal case" do
+    @proxy.root.test_node.value.should == 'Check meh.'
+  end
+
+  it "should define a method from a pascal cased element name" do
+    @proxy.root.test_node.value.should == 'Check meh.'
+    @proxy.root.methods.should include 'test_node'
+  end
+
+  it "should match a method to an attribute by pascal case" do
+    @proxy.root.second_node.record_label.should == "Wall of Sound"
+  end
+
+  it "should define a method from pascal cased attribute name" do
+    @proxy.root.second_node.record_label
+    @proxy.root.second_node.methods.should include 'record_label'
+  end
+end
+

data/spec/simple_content_wrapper_for_Peachy_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+describe "Peachy::SimpleContent wrapper for the contents of a simple XML element" do
+  before(:each) do
+    @node_name = 'parent_node'
+    @content = Peachy::SimpleContent.new 'the value', @node_name
+  end
+
+  it "should return the expected content" do
+    @content.value.should == 'the value'
+  end
+
+  it "should to_s in the expected way" do
+    @content.to_s.should == 'the value'
+  end
+
+  it "should return the value from the index of 0" do
+    item = @content[0]
+    item.value.should == 'the value'
+  end
+
+  it "should make the name of the parent node available" do
+    @content.node_name.should == @node_name
+  end
+
+  it "should raise an error if the SimpleContent is treated as an Array after being treated as SimpleContent" do
+    @content.value
+    lambda { @content[0].value }.should raise_error AlreadyAnOnlyChild, <<MESSAGE
+The 'parent_node' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MESSAGE
+  end
+
+  it "should behave as other objects when a method does not exist" do
+    lambda { @content.how_random }.should raise_error NoMethodError
+  end
+
+  it "should behave as other objects when a method with a parameter does not exist" do
+    lambda { @content.how_random("Hello") }.should raise_error NoMethodError
+  end
+
+  it "should behave as other objects when a method with a block does not exist" do
+    lambda { @content.how_random() { puts "Boo!" } }.should raise_error NoMethodError
+  end
+end
+

data/spec/simple_element_referenced_as_collections_spec.rb

@@ -0,0 +1,36 @@
+describe "a simple element referenced as the first part of a collection" do
+  before(:each) do
+    xml = <<XML
+<xml>
+  <list>
+    <item>Hello</item>
+  </list>
+</xml>
+XML
+    @proxy = Peachy::Proxy.new xml
+  end
+
+  it "should infer that the element matches the first index of an array" do
+    @proxy.xml.list.item[0].value.should == 'Hello'
+  end
+
+  it "should quack like an array" do
+    @proxy.xml.list.item[0]
+
+    element_as_array = @proxy.xml.list.item
+    element_as_array.any?.should be_true
+    element_as_array.one?.should be_true
+    element_as_array.empty?.should be_false
+    element_as_array.size.should == 1
+    (element_as_array.map {|item| item.value }).should == ['Hello']
+    element_as_array[0].value.should == 'Hello'
+  end
+
+  it "should raise an error if the element value has already been accessed as an only child" do
+    @proxy.xml.list.item.value
+    lambda { @proxy.xml.list.item[0] }.should raise_error AlreadyAnOnlyChild, <<MSG
+The 'item' node has already been accessed as a single child, but you are now trying to use it as a collection.
+Do not try to access Peachy::Proxies in a mixed manner in your implementation.
+MSG
+  end
+end

data/spec/simple_xml_collections_as_arrays_spec.rb

@@ -0,0 +1,22 @@
+describe "a simple XML collection should be interpretted as an array" do
+  before(:each) do
+    xml = "<xml><stuff><item>first</item><item>second</item><item>third</item></stuff></xml>"
+    @proxy = Peachy::Proxy.new xml
+  end
+
+  it "should set the correct sized array for a collection" do
+    @proxy.xml.stuff.item.size.should == 3
+  end
+
+  it "should define a method for the item list name" do
+    @proxy.xml.stuff.item
+    @proxy.xml.stuff.methods.should include 'item'
+  end
+
+  it "should set each array item to the content for the list item" do
+    @proxy.xml.stuff.item[0].value.should == 'first'
+    @proxy.xml.stuff.item[1].value.should == 'second'
+    @proxy.xml.stuff.item[2].value.should == 'third'
+  end
+end
+

data/spec/spec_helper.rb

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

data/spec/using_peachy_proxy_incorrectly_spec.rb

@@ -0,0 +1,26 @@
+describe "using Peachy::Proxy incorrectly" do
+  before(:each) do
+    @proxy = Peachy::Proxy.new '<testnode>Check meh.</testnode>'
+  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.')
+  end
+
+  it "should raise an error if the method name is not in Ruby convention" do
+    lambda { @proxy.testNode }.should raise_error MethodNotInRubyConvention, <<EOF
+You've tried to infer testNode using Peachy, but Peachy doesn't currently like defining methods that break Ruby convention.
+Please use methods matching ^[a-z]+(?:_[a-z]+)?{0,}$ and Peachy will try to do the rest with your XML.*/
+EOF
+  end
+
+  it "should throw an InvalidProxyParameters error if an incorrect type of parameter was passed as the initializer argument" do
+    invalid_proxy = Peachy::Proxy.new Hash.new
+    lambda { invalid_proxy.boom }.should raise_error InvalidProxyParameters, <<EOF
+The parameters that you passed to the Proxy were invalid.
+:nokogiri = nil
+:xml = nil
+EOF
+  end
+end
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - NJ Pearman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-05 00:00:00 +01:00
+date: 2010-05-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,8 +32,8 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 description: |
-  Peachy is an XML slurper that sits on to of existing XML parsers.  It dynamically 
-  creates object-style hierachies for simple ingration of XML data sources.
+  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.
 
 email: 
 - n.pearman@gmail.com
@@ -48,14 +48,37 @@ files:
 - lib/peachy/childless_proxy_with_attributes.rb
 - lib/peachy/method_name.rb
 - lib/peachy/method_mask.rb
+- lib/peachy/simple_content.rb
 - lib/peachy/version.rb
 - lib/peachy/proxy.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/invalid_proxy_parameters.rb
 - lib/method_not_in_ruby_convention.rb
+- lib/already_an_only_child.rb
 - lib/peachy.rb
+- spec/hyphen_separated_names_spec.rb
+- spec/elements_referenced_as_collections_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/using_peachy_proxy_incorrectly_spec.rb
+- spec/inferring_a_method_from_an_attribute_spec.rb
+- spec/camel_case_names_spec.rb
+- spec/attributes_on_a_parent_node_spec.rb
+- spec/pascal_case_names_spec.rb
+- spec/inferring_a_method_from_element_name_spec.rb
+- spec/spec_helper.rb
+- spec/nested_elements_spec.rb
+- spec/nodes_with_children_spec.rb
 - README.rdoc
+- History.txt
 has_rdoc: true
 homepage: http://github.com/njpearman/peachy
 licenses: []