lzell-mapricot 0.0.1 → 0.0.2.1

data/lib/mapricot.rb

@@ -1,97 +1,110 @@
-require 'open-uri'
-begin
-  require 'hpricot'
-rescue LoadError
-  require 'rubygems'
-  require 'hpricot'
-end
-# singularize, constantize, camelize, classify; doc here: http://api.rubyonrails.com/classes/Inflector.html
+require 'rubygems'
 require 'active_support/inflector'
+require File.expand_path(File.dirname(__FILE__) + "/abstract_doc")
 
 module Mapricot
-
+  
+  
   # Inherit from base, e.g. class Animal < Mapricot::Base
   # Use either a string of xml or a url to initialize
   class Base
+    
     class << self
       # @associations is used to initialize instance variables
-      # creates a new HasOneAssociation and appends it to the @associations list
+      # creates a new HasOneAssociation and appends it to the @association_list
       def has_one(name, type = :string, opts = {})
-        ass = HasOneAssociation.new(name, type, opts)
-        self.name.match(/::/) && ass.namespace = self.name.match(/(.*)::[^:]+$/)[1]
-        associations << ass
+        association = HasOneAssociation.new(name, type, opts)
+        if self.name.match(/::/)
+          association.namespace = self.name.match(/(.*)::[^:]+$/)[1]
+        end
+        association_list << association
         class_eval "attr_reader :#{name}", __FILE__, __LINE__
       end
-      # creates a new HasManyAssociation and appends it to the @associations list
+      
+      # creates a new HasManyAssociation and appends it to the @association_list
       def has_many(name, type = :string, opts = {})
-        ass = HasManyAssociation.new(name, type, opts)
-        self.name.match(/::/) && ass.namespace = self.name.match(/(.*)::[^:]+$/)[1]
-        associations << ass
+        association = HasManyAssociation.new(name, type, opts)
+        if self.name.match(/::/)
+          association.namespace = self.name.match(/(.*)::[^:]+$/)[1]
+        end
+        association_list << association
         class_eval "attr_reader :#{name}", __FILE__, __LINE__
       end
-      def has_attribute(name)
-        attributes << name
+      
+      def has_attribute(name, type = :string)
+        attribute_list << Attribute.new(name, type)
         class_eval "attr_reader :#{name}", __FILE__, __LINE__
       end
-      def associations
-        @associations ||= []
+      
+      def association_list
+        @association_list ||= []
       end
-      def attributes
-        @attributes ||= []
+      
+      def attribute_list
+        @attribute_list ||= []
       end
     end
 
     # class SomeClass < Mapricot::Base; end;
     # SomeClass.new :url => "http://some_url"
     # SomeClass.new :xml => %(<hi></hi>)
+    # the class instance variable @association_list is duplicated in every instance of Feed, as the instance variable @associations.
+    # i.e. Feed.association_list is the template for feed.associations
     def initialize(opts)
-      @xml = Hpricot::XML(open(opts[:url])) if opts[:url]
-      @xml = Hpricot::XML(opts[:xml]) if opts[:xml]
-      load_associations   
-      load_attributes
+      @doc = AbstractDoc.from_url(opts[:url])     if opts[:url]
+      @doc = AbstractDoc.from_string(opts[:xml])  if opts[:xml]
+      dup_associations_and_attributes
+      map_associations
+      map_attributes
     end
     
-    # searches xml for a tag with association.name, sets association.value to the inner html of this tag and typecasts it
-    def load_has_one(has_one_association)
-      has_one_association.search(@xml)
+    def dup_associations_and_attributes
+      @associations = self.class.association_list.collect {|x| x.dup}   # do not do this: self.class.association_list.dup 
+      @attributes = self.class.attribute_list.collect {|x| x.dup}
     end
     
-    def load_has_many(has_many_association)
-      has_many_association.search(@xml)
-    end
-  
-    def load_associations
-      # loop through the class's instance variable @attributes, which holds all of our associations
-      association_list = self.class.instance_variable_get(:@associations)
-      association_list && association_list.each do |ass|
-        load_has_one(ass) if ass.is_a?(HasOneAssociation)
-        load_has_many(ass) if ass.is_a?(HasManyAssociation)
-        # set instance variables and create accessors for each
-        instance_variable_set("@#{ass.name}", ass.value)  
+    def map_associations
+      @associations.each do |association|
+        node_list = @doc.find(association.tag_name)
+        association.set_value_from_node_list(node_list)
+        instance_variable_set("@#{association.name}", association.value)
       end
     end
     
-    def load_attributes
-      attr_list = self.class.instance_variable_get(:@attributes)
-      attr_list && attr_list.each do |att|
-        val = (@xml/self.class.name.downcase.match(/[^:]+$/)[0]).first.attributes[att.to_s]
-        instance_variable_set("@#{att}", val)
+    def map_attributes
+      @attributes.each do |attribute|
+        node = @doc.find(tag_name).first
+        attribute.set_value_from_node(node)
+        instance_variable_set("@#{attribute.name}", attribute.value)
       end
     end
+    
+    # associations and base classes both have tag_name method
+    def tag_name
+      self.class.name.downcase.match(/[^:]+$/)[0]
+    end
   end
   
+
+
   # Abstract class; used to subclass HasOneAssociation and HasManyAssociation
   class Association
     VALID_TYPES = [:integer, :time, :xml, :string]
 
     attr_accessor :name, :type, :value
     attr_accessor :namespace
+    
     def initialize(name, type, opts = {})
       raise "Don't instantiate me" if abstract_class?
       @name, @type, @opts = name, type, opts
       @namespace = nil
     end
+
+    def tag_name
+      @opts[:tag_name] || singular_name
+    end
   
+    private
     def typecast
       raise "association type is invalid" unless VALID_TYPES.include?(@type)
       if [:integer, :time].include?(@type)
@@ -103,6 +116,7 @@ module Mapricot
       @value.is_a?(Array) ? @value.collect {|v| v.to_i} : @value.to_i
     end
     
+    # oh, forgot about this, need to add to readme
     def typecast_time
       if @value.is_a?(Array)
         @value.collect {|v| Time.parse(v) }
@@ -110,8 +124,7 @@ module Mapricot
         Time.parse(@value)
       end
     end
-    
-    private
+
     def abstract_class?
       self.class == Association
     end
@@ -129,46 +142,69 @@ module Mapricot
         singular_name.classify.constantize
       end
     end
+    
+    def set_value_from_node_list(node_list)
+    end
+    
   end
   
   
   class HasOneAssociation < Association
-    # searches xml for tag name, sets the inner xml as association value and typecasts it
-    def search(xml)
-      # if tag_name option was passed, use it:
-      element = (xml/"#{ @opts[:tag_name] || @name }").first      # class Hpricot::Elements
-      if element
+    
+    # pass a node list, depending on the type of association
+    def set_value_from_node_list(node_list)
+      if node_list.empty?
+        @value = nil
+      else
         if @type == :xml
-          @value = class_from_name.new(:xml => element.to_s)    # we want to include the tag, not just the inner_html
+         @value = class_from_name.new(:xml => node_list.first.to_s)
         else
-          @value = element.inner_html
+          @value = node_list.first.contents
+          typecast
         end
-        self.typecast
       end
     end
   end
   
-  
+
   class HasManyAssociation < Association
 
     def singular_name
-      # @name.to_s[0..-2]
       "#{@name}".singularize
     end
     
-    # searches xml for all occurrences of self.singular_name, the inner xml from each tag is stored in an array and set as the association value
-    # finally, each element in the array is typecast
-    def search(xml)
+    def set_value_from_node_list(node_list)
       @value = []
-      (xml/"#{@opts[:tag_name] || self.singular_name}").each do |tag|
+      node_list.each do |node|
         if @type == :xml
-          @value << class_from_name.new(:xml => tag.to_s)  # a bit of recursion if the inner xml is more xml
+          @value << class_from_name.new(:xml => node.to_s)
         else
-          @value << tag.inner_html   # in the case of a string, integer, etc.
+          @value << node.contents
         end
       end
+      typecast
     end
-    
   end
+  
+  
+  class Attribute
+    attr_accessor :name, :type, :value
 
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+    
+    def set_value_from_node(node)
+      @value = node.attributes[name.to_s]
+      typecast
+    end
+    
+    private
+    def typecast
+      if !@value.nil? && !@value.empty? && @type == :integer
+        @value = @value.to_i
+      end
+    end
+  end  
 end

data/mapricot.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "mapricot"
-  s.version  = "0.0.1"
-  s.date     = "2009-03-06"
+  s.version  = "0.0.2.1"
+  s.date     = "2009-03-17"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.summary  = "XML to object mapper"
   s.email    = "lzell11@gmail.com"
@@ -15,14 +15,27 @@ Gem::Specification.new do |s|
       "mapricot.gemspec",
       "examples/lastfm_api.rb",
       "examples/lastfm_api_no_request.rb",
+      "examples/facebook_api.rb",
       "examples/natural_inputs.rb",
       "examples/readme_examples.rb",
-      "test/mapricot_tests.rb",
-      "test/mapricot_spec.rb",
-      "lib/mapricot.rb"]
+      "examples/xml_with_attributes.rb",
+      "test/suite.rb",
+      "test/abstract_doc_spec.rb",
+      "test/test_mapricot.rb",
+      "test/test_mapricot_readme.rb",
+      "test/has_attribute/has_attribute_spec.rb",
+      "test/has_many/has_many_ids_spec.rb",
+      "test/has_many/has_many_nested_spec.rb",
+      "test/has_one/has_one_id_spec.rb",
+      "test/has_one/has_one_user_spec.rb",
+      "test/has_one/has_one_nested_spec.rb",
+      "lib/mapricot.rb",
+      "lib/abstract_doc.rb",
+      "benchmark/benchmarks.rb"]
   s.require_paths = ["lib"]
   s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--title", "Mapricot"]
   s.extra_rdoc_files = ["README.rdoc"]
   s.add_dependency("hpricot")
+  s.add_dependency("nokogiri")
+  s.add_dependency("libxml-ruby")
 end
-

data/test/abstract_doc_spec.rb

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/abstract_doc")
+
+
+include Mapricot
+
+
+share_examples_for "an abstract xml parser" do 
+  
+  it "should initialize from a url or a string" do 
+    AbstractDoc.should respond_to(:from_string)
+    AbstractDoc.should respond_to(:from_url)
+  end
+  
+  it "should be using libxml or hpricot or nokogiri" do
+    puts "using #{Mapricot.parser}..."
+    [:libxml, :hpricot, :nokogiri].include?(Mapricot.parser).should be_true
+  end
+
+  describe "creating a document from a string of xml" do 
+    before(:all) do 
+      @doc = AbstractDoc.from_string %(<user>bob</user>)
+    end
+    
+    it "should be able to find all the <user> nodes" do 
+      @doc.find(:user).should_not be_nil
+    end
+    
+    describe "the list of user nodes" do
+      
+      before(:all) do 
+        @user_nodes = @doc.find(:user)
+      end
+      
+      it "should be an abstract node list" do 
+        @user_nodes.should be_a(AbstractNodeList)
+      end
+
+      it "should be able to iterate over" do
+        @user_nodes.should respond_to(:each)
+        @user_nodes.should respond_to(:first)
+        @user_nodes.should respond_to(:[])
+      end
+      
+      describe "the first user node" do
+        
+        before(:all) do 
+          @user = @user_nodes.first
+        end
+        
+        it "should be a abstract node" do
+          @user.should be_a(AbstractNode)
+        end
+        
+        it "should be able to get the node contents" do
+          @user.contents.should == "bob"
+          @user.to_s.should == "<user>bob</user>"
+        end
+      end
+    end
+  end
+end
+
+describe "AbstractDoc using libxml" do 
+  before(:all) { Mapricot.parser = :libxml }
+  it_should_behave_like "an abstract xml parser"
+end
+
+describe "AbstractDoc useing hpricot" do 
+  before(:all) { Mapricot.parser = :hpricot }
+  it_should_behave_like "an abstract xml parser"
+end
+
+describe "AbstractDoc useing hpricot" do 
+  before(:all) { Mapricot.parser = :nokogiri }
+  it_should_behave_like "an abstract xml parser"
+end
+

data/test/has_attribute/has_attribute_spec.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + "/../../lib/mapricot")
+
+include Mapricot
+
+class Response < Mapricot::Base
+  has_one   :location, :xml
+end
+
+class Location < Mapricot::Base
+  has_one         :city
+  has_one         :state
+  has_attribute   :code
+  has_attribute   :id,    :integer
+end
+
+
+share_as :HasAttribute do 
+
+  describe "; response with location city, state, and code" do 
+  
+    before(:all) do 
+      @response = Response.new(:xml => %(
+        <response>
+          <location code='nyc' id='100'>
+            <city>New York</city>
+            <state>NY</state>
+          </location>
+        </response>
+      ))
+    end
+    
+    it "should have location code 'nyc'" do 
+      @response.location.city.should == "New York"
+      @response.location.state.should == "NY"
+      @response.location.code.should == 'nyc'
+      @response.location.id.should == 100
+    end
+  end
+end
+
+
+describe "has attribute, parsing with hpricot" do 
+  before(:all) { Mapricot.parser = :hpricot }
+  it_should_behave_like HasAttribute
+end
+
+describe "has many id, parsing with libxml" do 
+  before(:all) { Mapricot.parser = :libxml }
+  it_should_behave_like HasAttribute
+end
+
+describe "has many id, parsing with nokogiri" do 
+  before(:all) { Mapricot.parser = :nokogiri }
+  it_should_behave_like HasAttribute
+end

data/test/has_many/has_many_ids_spec.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + "/../../lib/mapricot")
+
+include Mapricot
+
+class ResponseWithManyIds < Mapricot::Base
+  has_many :ids,  :integer
+end
+
+
+share_as :HasManyIds do 
+  
+  before(:all) do 
+    @response = ResponseWithManyIds.new(:xml => %(
+      <response>
+        <id>10</id>
+        <id>20</id>
+        <id>30</id>
+      </response>
+    ))
+  end
+    
+  describe "Interface" do 
+
+    it "should have an array of ids" do 
+      @response.ids.should be_a(Array)
+      @response.ids[0].should == 10
+      @response.ids[1].should == 20
+      @response.ids[2].should == 30
+    end
+  end
+  
+
+  describe "Internals" do 
+  
+    it "should have an accessor on ids" do
+      @response.should respond_to(:ids)
+    end
+  
+    it "should have a class instance variable @association_list" do
+      ass_template = @response.class.association_list.first
+      ass_template.name.should == :ids
+      ass_template.type.should == :integer
+      ass_template.namespace.should   be_nil
+      ass_template.value.should       be_nil
+    end
+  
+    it "should have an instance variable @associations, duplicated from class ivar @association_list, with value now set" do
+      ass = @response.instance_variable_get(:@associations).first
+      ass.name.should == :ids
+      ass.type.should == :integer
+      ass.namespace.should be_nil
+      ass.value.should == [10,20,30]
+    end
+  end
+end
+
+
+describe "has many ids, parsing with hpricot" do 
+  before(:all) { Mapricot.parser = :hpricot }
+  it_should_behave_like HasManyIds
+end
+
+describe "has many id, parsing with libxml" do 
+  before(:all) { Mapricot.parser = :libxml }
+  it_should_behave_like HasManyIds
+end
+
+describe "has many id, parsing with nokogiri" do 
+  before(:all) { Mapricot.parser = :nokogiri }
+  it_should_behave_like HasManyIds
+end

data/test/has_many/has_many_nested_spec.rb

@@ -0,0 +1,116 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + "/../../lib/mapricot")
+
+include Mapricot
+
+class ResponseWithNesting < Mapricot::Base
+  has_many :users, :xml
+end
+
+class User < Mapricot::Base
+  has_one :id,    :integer
+  has_one :name
+end
+
+
+share_as :HasManyNested do 
+  
+  before(:all) do 
+    @response = ResponseWithNesting.new(:xml => %(
+      <response>
+        <user>
+          <id>10</id>
+          <name>bob</name>
+        </user>
+        <user>
+          <id>20</id>
+          <name>sally</name>
+        </user>
+      </response>
+    ))
+  end
+    
+  describe "Interface" do 
+
+    it "should have bob as the first user" do 
+      @response.users.first.id.should == 10
+      @response.users.first.name.should == "bob"
+    end
+    
+    it "should have sally as the second user" do
+      @response.users.last.id.should == 20
+      @response.users.last.name.should == "sally"
+    end
+  end
+  
+
+  describe "Internals" do 
+  
+    it "should have an accessor on users" do
+      @response.should respond_to(:users)
+    end
+  
+    it "should have a class instance variable @association_list" do
+      ass_template = @response.class.association_list.first
+      ass_template.name.should == :users
+      ass_template.type.should == :xml
+      ass_template.namespace.should   be_nil
+      ass_template.value.should       be_nil
+    end
+  
+    it "should have an instance variable @associations, duplicated from class ivar @association_list, with value now set" do
+      ass = @response.instance_variable_get(:@associations).first
+      ass.name.should == :users
+      ass.type.should == :xml
+      ass.namespace.should be_nil
+      ass.value.should_not be_nil  # should not
+    end
+    
+    describe "its users" do 
+
+      before(:all) do 
+        @users = @response.users
+      end
+
+      it "should be a an array of User objects, a subclass of Mapricot::Base" do
+        @users.should be_a(Array)
+        @users.first.should be_a(User)
+        @users.first.should be_a(Mapricot::Base)
+      end
+
+      it "should have a class instance variable @association_list, an array of HasMany and HasOne *instances*" do
+        ass_template = @users.first.class.association_list.first
+        ass_template.should be_a(HasOneAssociation)
+        ass_template.name.should == :id
+        ass_template.type.should == :integer
+        ass_template.namespace.should   be_nil
+        ass_template.value.should       be_nil
+      end
+
+      it "should have an instance variable @associations, duplicated from class ivar @association_list, with value now set" do
+        ass = @users.first.instance_variable_get(:@associations).first
+        ass.name.should == :id
+        ass.type.should == :integer
+        ass.namespace.should  be_nil
+        ass.value.should == 10
+      end
+    end
+  end
+end
+
+
+describe "has many ids, parsing with hpricot" do 
+  before(:all) { Mapricot.parser = :hpricot }
+  it_should_behave_like HasManyNested
+end
+
+describe "has many id, parsing with libxml" do 
+  before(:all) { Mapricot.parser = :libxml }
+  it_should_behave_like HasManyNested
+end
+
+describe "has many id, parsing with nokogiri" do 
+  before(:all) { Mapricot.parser = :nokogiri }
+  it_should_behave_like HasManyNested
+end

data/test/has_one/has_one_id_spec.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + "/../../lib/mapricot")
+
+include Mapricot
+
+class FeedWithOneId < Mapricot::Base
+  has_one :id,  :integer
+end
+
+
+share_as :HasOneId do 
+  
+  before(:all) do 
+    @feed = FeedWithOneId.new(:xml => "<id>10</id>")
+  end
+    
+  describe "Interface" do 
+
+    it "should have an id of 10" do 
+      @feed.id.should == 10
+    end
+  end
+  
+
+  describe "Internals" do 
+
+    it "should have an accessor on id" do
+      @feed.should respond_to(:id)
+    end
+
+    it "should have a class instance variable @association_list" do
+      ass_template = @feed.class.association_list.first
+      ass_template.name.should == :id
+      ass_template.type.should == :integer
+      ass_template.namespace.should   be_nil
+      ass_template.value.should       be_nil
+    end
+
+    it "should have an instance variable @associations, duplicated from class ivar @association_list, with value now set" do
+      ass = @feed.instance_variable_get(:@associations).first
+      ass.name.should == :id
+      ass.type.should == :integer
+      ass.namespace.should be_nil
+      ass.value.should == 10
+    end
+  end
+end
+
+
+describe "has one id, parsing with hpricot" do 
+  before(:all) { Mapricot.parser = :hpricot }
+  it_should_behave_like HasOneId
+end
+
+describe "has one id, parsing with libxml" do 
+  before(:all) { Mapricot.parser = :libxml }
+  it_should_behave_like HasOneId
+end
+
+describe "has one id, parsing with nokogiri" do 
+  before(:all) { Mapricot.parser = :nokogiri }
+  it_should_behave_like HasOneId
+end