mapricot 0.0.4

data/lib/mapricot/abstract_doc.rb

@@ -0,0 +1,119 @@
+require 'open-uri'
+require 'hpricot'
+require 'libxml'
+require 'nokogiri'
+
+
+module Mapricot
+  @parser = :hpricot
+  class << self; attr_accessor :parser; end
+  
+  # AbstractDoc should be able to find tags, get inner tag content. Find all tags (return an array)
+  # I think I will also need AbstractNode
+
+  class AbstractDoc
+
+    def self.from_url(url)
+      adoc = new
+      adoc.url = url
+      adoc
+    end
+
+    def self.from_string(string)
+      adoc = new
+      adoc.string = string
+      adoc
+    end
+
+    def url=(url)
+      if Mapricot.parser == :libxml
+        @udoc = LibXML::XML::Parser.file(url).parse
+      elsif Mapricot.parser == :hpricot
+        @udoc = Hpricot::XML(open(url))
+      elsif Mapricot.parser == :nokogiri
+        @udoc = Nokogiri::HTML(open(url))
+      end
+    end
+
+    def string=(string)
+      if Mapricot.parser == :libxml
+        @udoc = LibXML::XML::Parser.string(string).parse
+      elsif Mapricot.parser == :hpricot
+        @udoc = Hpricot::XML(string)
+      elsif Mapricot.parser == :nokogiri
+        @udoc = Nokogiri::XML(string)
+      end
+    end
+
+
+    def find(tagname)
+      if Mapricot.parser == :libxml
+        AbstractNodeList.new(@udoc.find("//#{tagname}"))  # hmm...
+      elsif Mapricot.parser == :hpricot
+        # AbstractNodeList.new(@udoc/tagname)
+        AbstractNodeList.new(@udoc/"//#{tagname}")
+      elsif Mapricot.parser == :nokogiri
+        AbstractNodeList.new(@udoc.search(tagname))
+        # AbstractNodeList.new(@udoc.xpath("//#{tagname}"))
+      end
+    end
+    
+  end
+  
+  
+  
+  class AbstractNodeList
+    include Enumerable
+    
+    def initialize(node_list)
+      @unode_list = node_list
+    end
+
+    def each(&block)
+      @unode_list.each {|unode| yield(AbstractNode.new(unode))}
+    end
+
+    def [](i)
+      AbstractNode.new(@unode_list[i])
+    end
+    
+    def first
+      AbstractNode.new(@unode_list.first)
+    end
+    
+    def empty?
+      @unode_list.empty?
+    end
+  end
+  
+
+  class AbstractNode
+    attr_reader :unode
+
+    def initialize(unode) 
+      @unode = unode        # unresolved node
+    end
+    
+    def to_s
+      @unode.to_s
+    end
+    
+    def attributes
+      if Mapricot.parser != :nokogiri
+        @unode.attributes
+      else
+        atts = {}
+        @unode.attributes.each {|k,v| atts[k] = v.value}
+        atts
+      end
+    end
+    
+    def contents
+      if Mapricot.parser == :libxml || Mapricot.parser == :nokogiri
+        @unode.content
+      else
+        @unode.inner_html
+      end
+    end
+  end
+end

data/lib/mapricot/associations.rb

@@ -0,0 +1,100 @@
+module Mapricot
+  # 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)
+        @value = self.send("typecast_#{@type}")
+      end
+    end
+    
+    def typecast_integer
+      @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) }
+      else
+        Time.parse(@value)
+      end
+    end
+
+    def abstract_class?
+      self.class == Association
+    end
+    
+    def singular_name
+      @name.to_s
+    end
+    
+    def class_from_name
+      # ok, first we have to find how the class that inherited from Mapricot::Base is namespaced
+      # the class will an @associations class instance var, that will hold an instance of 
+      if @namespace
+        "#{@namespace}::#{singular_name.classify}".constantize
+      else
+        singular_name.classify.constantize
+      end
+    end
+    
+    def set_value_from_node_list(node_list)
+    end
+  end
+  
+  
+  class HasOneAssociation < Association
+    
+    # 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 => node_list.first.to_s)
+        else
+          @value = node_list.first.contents
+          typecast
+        end
+      end
+    end
+  end
+  
+
+  class HasManyAssociation < Association
+
+    def singular_name
+      "#{@name}".singularize
+    end
+    
+    def set_value_from_node_list(node_list)
+      @value = []
+      node_list.each do |node|
+        if @type == :xml
+          @value << class_from_name.new(:xml => node.to_s)
+        else
+          @value << node.contents
+        end
+      end
+      typecast
+    end
+  end
+  
+end

data/lib/mapricot/attribute.rb

@@ -0,0 +1,22 @@
+module Mapricot
+  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/lib/mapricot/base.rb

@@ -0,0 +1,81 @@
+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 @association_list
+      def has_one(name, type = :string, opts = {})
+        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 @association_list
+      def has_many(name, type = :string, opts = {})
+        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, type = :string)
+        attribute_list << Attribute.new(name, type)
+        class_eval "attr_reader :#{name}", __FILE__, __LINE__
+      end
+      
+      def association_list
+        @association_list ||= []
+      end
+      
+      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)
+      @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
+    
+    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 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 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
+end

data/lib/mapricot.rb

@@ -0,0 +1,12 @@
+require 'active_support/inflector'
+
+module Mapricot
+  VERSION = "0.0.4"
+end
+
+path = File.expand_path(File.join(File.dirname(__FILE__), 'mapricot'))
+
+require File.join(path, 'base')
+require File.join(path, 'abstract_doc')
+require File.join(path, 'associations')
+require File.join(path, 'attribute')

data/mapricot.gemspec

@@ -0,0 +1,40 @@
+Gem::Specification.new do |s|
+  s.name     = "mapricot"
+  s.version  = "0.0.4"
+  s.summary  = "XML to object mapper"
+  s.email    = "lzell11@gmail.com"
+  s.homepage = "http://github.com/lzell/mapricot"
+	s.description = "XML to object mapper with an interface similar to ActiveRecord associations."
+  s.has_rdoc = true
+  s.authors  = ["Lou Zell"]
+  s.files    = ["README.rdoc", 
+      "History.txt",
+      "License.txt",
+      "mapricot.gemspec",
+      "examples/facebook_api.rb",
+      "examples/lastfm_api.rb",
+      "examples/lastfm_api_no_request.rb",
+      "examples/readme_examples.rb",
+      "examples/xml_with_attributes.rb",
+      "test/suite.rb",
+      "test/test_abstract_doc.rb",
+      "test/test_mapricot.rb",
+      "test/test_mapricot_readme.rb",
+      "test/has_attribute/test_has_attribute.rb",
+      "test/has_many/test_has_many_ids.rb",
+      "test/has_many/test_has_many_nested.rb",
+      "test/has_one/test_has_one_id.rb",
+      "test/has_one/test_has_one_nested.rb",
+      "lib/mapricot.rb",
+      "lib/mapricot/abstract_doc.rb",
+      "lib/mapricot/associations.rb",
+      "lib/mapricot/attribute.rb",
+      "lib/mapricot/base.rb",
+      "benchmark/benchmarks.rb"]
+  s.require_paths = ["lib"]
+  s.rdoc_options = ["--main", "README.rdoc", "--title", "Mapricot"]
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.add_dependency("hpricot")
+  s.add_dependency("nokogiri")
+  s.add_dependency("libxml-ruby")
+end

data/test/has_attribute/test_has_attribute.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', '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
+
+class TestResponse < Test::Unit::TestCase
+  
+  def setup
+    @parsers = [:hpricot, :nokogiri, :libxml]
+    @xml = %(
+      <response>
+        <location code='nyc' id='100'>
+          <city>New York</city>
+          <state>NY</state>
+        </location>
+      </response>
+    )
+  end
+  
+  def test_response
+    @parsers.each do |parser|
+      Mapricot.parser = parser
+      response = Response.new(:xml => @xml)
+      assert_equal  "New York",     response.location.city
+      assert_equal  "NY",           response.location.state
+      assert_equal  "nyc",          response.location.code
+      assert_equal  100,            response.location.id
+    end
+  end
+  
+end
+

data/test/has_many/test_has_many_ids.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mapricot'))
+
+
+class ResponseWithManyIds < Mapricot::Base
+  has_many :ids,  :integer
+end
+
+
+class TestResponseWithManyIds < Test::Unit::TestCase
+  
+  def setup
+    @parsers = [:hpricot, :nokogiri, :libxml]
+    @xml = %(
+      <response>
+        <id>10</id>
+        <id>20</id>
+        <id>30</id>
+      </response>
+    )
+  end
+  
+  def test_response
+    @parsers.each do |parser|
+      Mapricot.parser = parser
+      response = ResponseWithManyIds.new(:xml => @xml)
+      assert_equal  10,     response.ids[0]
+      assert_equal  20,     response.ids[1]
+      assert_equal  30,     response.ids[2]
+    end
+  end
+  
+  # ---------------- stop reading here ---------------- # 
+  
+  
+  
+  
+  
+  
+  
+  def test_internals
+    response = ResponseWithManyIds.new(:xml => @xml)
+    template = response.class.association_list.first
+    assert_equal  :ids,       template.name
+    assert_equal  :integer,   template.type
+    assert_nil                template.namespace
+    assert_nil                template.value
+
+    ass = response.instance_variable_get(:@associations).first
+    assert_equal  :ids,         ass.name
+    assert_equal  :integer,     ass.type
+    assert_nil                  ass.namespace
+    assert_equal  [10,20,30],   ass.value
+  end
+end

data/test/has_many/test_has_many_nested.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mapricot'))
+
+class ResponseWithNesting < Mapricot::Base
+  has_many :users, :xml
+end
+
+class User < Mapricot::Base
+  has_one :id,    :integer
+  has_one :name
+end
+
+class TestResponseWithNesting < Test::Unit::TestCase
+  
+  def setup
+    @parsers = [:hpricot, :nokogiri, :libxml]
+    @xml = %(
+      <response>
+        <user>
+          <id>10</id>
+          <name>bob</name>
+        </user>
+        <user>
+          <id>20</id>
+          <name>sally</name>
+        </user>
+      </response>
+    )
+  end
+  
+  
+  def test_response
+    @parsers.each do |parser|
+      Mapricot.parser = parser
+      response = ResponseWithNesting.new(:xml => @xml)
+      assert_equal  10,       response.users[0].id
+      assert_equal  "bob",    response.users[0].name
+      assert_equal  20,       response.users[1].id
+      assert_equal  "sally",  response.users[1].name
+    end
+  end
+
+  # ---------------- stop reading here ---------------- # 
+
+
+
+
+
+  
+  def test_response_internals
+    response = ResponseWithNesting.new(:xml => @xml)
+    template = response.class.association_list.first
+
+    assert_equal  :users,     template.name
+    assert_equal  :xml,       template.type
+    assert_nil                template.namespace
+    assert_nil                template.value
+  
+    ass = response.instance_variable_get(:@associations).first
+    assert_equal  :users,     ass.name
+    assert_equal  :xml,       ass.type
+    assert_nil                ass.namespace
+    assert_not_nil            ass.value
+  end
+  
+  def test_response_users_internals
+    response = ResponseWithNesting.new(:xml => @xml)
+    template = response.users.first.class.association_list.first
+    assert_equal  :id,        template.name
+    assert_equal  :integer,   template.type
+    assert_nil                template.namespace
+    assert_nil                template.value
+
+    ass = response.users.first.instance_variable_get(:@associations).first
+    assert_equal  :id,        ass.name
+    assert_equal  :integer,   ass.type
+    assert_nil                ass.namespace
+    assert_equal  10,         ass.value
+  end
+
+end

data/test/has_one/test_has_one_id.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mapricot'))
+
+class ResponseWithOneId < Mapricot::Base
+  has_one :id,  :integer
+end
+
+
+class TestReponseWithOneId < Test::Unit::TestCase
+  
+  def setup
+    @parsers = [:hpricot, :nokogiri, :libxml]
+    @xml = %(
+      <id>10</id>
+    )
+  end
+  
+  def test_response
+    @parsers.each do |parser|
+      Mapricot.parser = parser
+      response = ResponseWithOneId.new(:xml => @xml)
+      assert_equal  10,     response.id
+    end
+  end
+end

data/test/has_one/test_has_one_nested.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mapricot'))
+
+class ResponseWithNesting < Mapricot::Base
+  has_one :user, :xml
+end
+
+class User < Mapricot::Base
+  has_one :name
+end
+
+
+class TestReponseWithNesting < Test::Unit::TestCase
+  
+  def setup
+    @parsers = [:hpricot, :nokogiri, :libxml]
+    @xml = %(
+      <user>
+        <name>bob</name>
+      </user>
+    )
+  end
+  
+  def test_response
+    @parsers.each do |parser|
+      Mapricot.parser = parser
+      response = ResponseWithNesting.new(:xml => @xml)
+      assert_equal  "bob",     response.user.name
+    end
+  end
+end

data/test/suite.rb

@@ -0,0 +1,20 @@
+# Usage:
+# ruby suite.rb
+# OR
+# ruby suite.rb rg
+# ^^^ that one is for color, and requires the redgreen gem
+
+path = File.expand_path(File.dirname(__FILE__))
+
+test_glob = File.join(path, "**", "test_*.rb")
+tests = Dir.glob(test_glob)
+
+if ARGV[0] != 'rg'
+  tests.each {|test| system("ruby #{test}")}
+else
+  tests.each {|test| system("rg #{test}")}
+end
+
+# spec_glob = File.join(path, "**", "*_spec.rb")
+# specs = Dir.glob(spec_glob)
+# specs.each {|spec| system("spec --format progress --color #{spec}")}

data/test/test_abstract_doc.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'mapricot'))
+
+
+class TestAbstractDoc < Test::Unit::TestCase
+  
+  def test_initialize_from_string_or_url
+    assert_respond_to Mapricot::AbstractDoc,   :from_string
+    assert_respond_to Mapricot::AbstractDoc,   :from_url
+  end
+  
+  def test_getting_node_contents
+    [:libxml, :nokogiri, :hpricot].each do |parser|
+      Mapricot.parser = parser
+      @doc = Mapricot::AbstractDoc.from_string('<user>bob</user>')
+      @node = @doc.find(:user).first
+      assert_equal "bob",                   @node.contents
+      assert_equal "<user>bob</user>",      @node.to_s
+    end
+  end
+  
+  def test_node_list
+    [:libxml, :nokogiri, :hpricot].each do |parser|
+      Mapricot.parser = parser
+      @doc = Mapricot::AbstractDoc.from_string('<response><user>sally</user><user>bob</user></response>')
+      @node_list = @doc.find(:user)
+      assert_instance_of Mapricot::AbstractNodeList, @node_list
+      assert_respond_to @node_list,   :each
+      assert_respond_to @node_list,   :first
+      assert_respond_to @node_list,   :[]
+
+      @node_list.each do |node|
+        assert_instance_of Mapricot::AbstractNode,  node
+      end
+    
+      assert_equal "sally", @node_list[0].contents
+      assert_equal "bob",   @node_list[1].contents
+    end
+  end
+  
+end