representable 0.0.1.alpha1

data/spec/examples/active_record_spec.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+require_relative './../spec_helper'
+require_relative './../../examples/rails'
+
+describe ROXML, "under ActiveRecord" do
+  before do
+    @route = Route.from_xml(xml_for('active_record'))
+  end
+
+  before(:all) do
+    FileUtils.rm(DB_PATH) if File.exists?(DB_PATH)
+  end
+
+  it "should be parsed" do
+    @route.should_not == nil
+    @route.should be_an_instance_of(Route)
+  end
+
+  describe "xml attributes" do
+    it "should extract xml attributes" do
+      @route.totalHg.should == "640"
+      @route.lonlatx.should == "357865"
+      @route.lonlaty.should == "271635"
+      @route.grcenter.should == "SH 71635 57865"
+      @route.totalMins.should == "235.75000000000003"
+      @route.totalDist.should == "11185.321521477119"
+    end
+  end
+
+  describe "xml sub-objects" do
+    it "should extract xml sub-objects" do
+      @route.should have(6).waypoints
+      @route.waypoints.each {|waypoint| waypoint.should be_an_instance_of(Waypoint)}
+    end
+    it "should be usable as a ActiveRecord object" do
+      Waypoint.count.should == 0
+      @route.save!
+      Waypoint.count.should == 6
+    end
+  end
+end

data/spec/examples/amazon_spec.rb

@@ -0,0 +1,54 @@
+require_relative './../spec_helper'
+require_relative './../../examples/amazon'
+
+describe PITA::ItemSearchResponse do
+  before do
+    @response = PITA::ItemSearchResponse.from_xml(xml_for('amazon'))
+  end
+
+  describe "#total_results" do
+    it "should be parsed as a number" do
+      @response.total_results.should > 0
+    end
+  end
+
+  describe "#total_pages" do
+    it "should be parsed as a number" do
+      @response.total_pages.should > 0
+    end
+  end
+
+  describe "#items" do
+    it "should return a collection of items" do
+      @response.items.should be_an_instance_of(Array)
+      @response.items.size.should > 0
+      @response.items.each {|item| item.should be_an_instance_of(PITA::Item) }
+    end
+
+    it "should have the some number less than or equal to #total_results" do
+      @response.items.size.should > 0
+      @response.items.size.should <= @response.total_results
+    end
+  end
+end
+
+describe PITA::Item do
+  before do
+    @items = PITA::ItemSearchResponse.from_xml(xml_for('amazon')).items
+  end
+
+  it "should extract asin" do
+    @items.each {|item| item.asin.should be_an_instance_of(String) }
+    @items.each {|item| item.asin.should_not be_empty }
+  end
+
+  it "should extract detail_page_url" do
+    @items.each {|item| item.detail_page_url.should be_an_instance_of(String) }
+    @items.each {|item| item.detail_page_url.should_not be_empty }
+  end
+
+  it "should extract manufacturer" do
+    @items.each {|item| item.manufacturer.should be_an_instance_of(String) }
+    @items.each {|item| item.manufacturer.should_not be_empty }
+  end
+end

data/spec/examples/current_weather_spec.rb

@@ -0,0 +1,37 @@
+require_relative './../spec_helper'
+require_relative './../../examples/current_weather'
+
+describe Weather do
+  before do
+    @weather = Weather.from_xml(xml_for('current_weather'))
+  end
+
+  it "should extract observations" do
+    @weather.observation.should be_an_instance_of(WeatherObservation)
+  end
+end
+
+describe WeatherObservation do
+  before do
+    @observation = Weather.from_xml(xml_for('current_weather')).observation
+  end
+
+  it "should extract temperature" do
+    @observation.temperature.should > 0
+  end
+
+  it "should extract feels_like" do
+    @observation.feels_like.should > 0
+  end
+
+  describe "#current_condition" do
+    it "should extract current_condition" do
+      @observation.current_condition.should_not be_empty
+    end
+
+    it "should extract icon attribute" do
+      pending "need to think options through for HappyMapper-style :attributes extensions"
+      @observation.current_condition.icon.should_not be_empty
+    end
+  end
+end

data/spec/examples/dashed_elements_spec.rb

@@ -0,0 +1,20 @@
+require_relative './../spec_helper'
+require_relative './../../examples/dashed_elements'
+
+describe GitHub::Commit do
+  before do
+    @commit = GitHub::Commit.from_xml(xml_for('dashed_elements'))
+  end
+
+  it "should extract committed date" do
+    @commit.committed_date.should be_an_instance_of(Date)
+  end
+
+  it "should extract url" do
+    @commit.url.should_not be_empty
+  end
+
+  it "should extract id" do
+    @commit.id.should_not be_empty
+  end
+end

data/spec/examples/library_spec.rb

@@ -0,0 +1,46 @@
+require_relative './../spec_helper'
+require_relative './../../examples/library'
+
+describe Library do
+  before :all do
+    book = Novel.new
+    book.isbn = "0201710897"
+    book.title = "The PickAxe"
+    book.description = "Best Ruby book out there!"
+    book.author = "David Thomas, Andrew Hunt, Dave Thomas"
+    book.publisher = Publisher.new('Addison Wesley Longman, Inc.')
+
+    @lib = Library.new
+    @lib.name = "Favorite Books"
+    @lib.novels = [book]
+  end
+
+  describe "#to_xml" do
+    it "should contain the expected information" do
+      @lib.to_xml.to_s.should == ROXML::XML.parse_string(%{<library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).root.to_s
+    end
+
+    context "when written to a file" do
+      before :all do
+        @path = "spec/examples/library.xml"
+        @doc = ROXML::XML::Document.new
+        @doc.root = @lib.to_xml
+        ROXML::XML.save_doc(@doc, @path)
+      end
+
+     after :all do
+       FileUtils.rm @path
+     end
+
+     it "should be contain the expected xml" do
+        ROXML::XML.parse_string(File.read(@path)).to_s.should == ROXML::XML.parse_string(%{<?xml version="1.0"?><library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).to_s
+      end
+
+      it "should be re-parsable via .from_xml" do
+        File.open("spec/examples/library.xml") do |file|
+          Library.from_xml(file).should == @lib
+        end
+      end
+    end
+  end
+end

data/spec/examples/post_spec.rb

@@ -0,0 +1,24 @@
+require_relative './../spec_helper'
+require_relative './../../examples/posts'
+
+describe Post do
+  before do
+    @posts = Posts.from_xml(xml_for('posts')).posts
+  end
+
+  it "should extract description" do
+    @posts.each {|post| post.description.should_not be_empty }
+  end
+
+  it "should extract href" do
+    @posts.each {|post| post.href.should_not be_empty }
+  end
+
+  it "should extract extended" do
+    @posts.each {|post| post.extended.should_not be_empty }
+  end
+
+  it "should extract time" do
+    @posts.each {|post| post.created_at.should be_an_instance_of(DateTime) }
+  end
+end

data/spec/examples/twitter_spec.rb

@@ -0,0 +1,32 @@
+require_relative './../spec_helper'
+require_relative './../../examples/twitter'
+
+describe Statuses do
+  describe Status do
+    before do
+      @statuses = Statuses.from_xml(xml_for('twitter')).statuses
+    end
+
+    it "should extract text" do
+      @statuses.each {|status| status.text.should_not be_empty }
+    end
+
+    it "should extract source" do
+      @statuses.each {|status| status.source.should_not be_empty }
+    end
+
+    describe User do
+      before do
+        @users = @statuses.map(&:user)
+      end
+
+      it "should extract name" do
+        @users.each {|user| user.name.should == "John Nunemaker" }
+      end
+
+      it "should extract screen_name" do
+        @users.each {|user| user.screen_name.should == "jnunemaker" }
+      end
+    end
+  end
+end

data/spec/roxml_integration_test.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+
+require 'test_xml/spec'
+
+describe Representable, "#xml" do
+  class Contributor
+    include Representable
+
+    xml_accessor :role, :from => :attr
+    xml_accessor :name
+  end
+  
+  class Band
+    include Representable
+    xml_accessor :name
+  end
+  
+  class Label
+    def to_xml
+      "<label>Fat Wreck</label>"
+    end
+  end
+    
+  
+  describe "generic tests" do
+    context ".from_xml" do
+      it "works with empty string" do
+        album = Album.from_xml("")
+        album.band.should == []
+      end
+    end
+  end
+  
+  
+  describe ":from => @rel" do
+    class Link
+      include Representable
+      xml_accessor :href,   :from => "@href"
+      xml_accessor :title,  :from => "@title"
+    end
+    
+    context ".from_xml" do
+      it "creates correct accessors" do
+        link = Link.from_xml(%{
+          <a href="http://apotomo.de" title="Home, sweet home" />
+        })
+        link.href.should == "http://apotomo.de"
+        link.title.should == "Home, sweet home"
+      end
+    end
+    
+    context "#to_xml" do
+      it "serializes correctly" do
+        link = Link.new
+        link.href = "http://apotomo.de/"
+        
+        link.to_xml.to_s.should equal_xml %{<link href="http://apotomo.de/">}
+      end
+    end
+  end
+  
+  
+  describe ":as => Item" do
+    class Albumy
+      include Representable
+      xml_accessor :band, :as => Band
+      xml_accessor :label, :as => Label
+    end
+    
+    context ".from_xml" do
+      it "creates one Item instance" do
+        album = Albumy.from_xml(%{
+          <album>
+            <band><name>Bad Religion</name></band>
+          </album>
+        })
+        album.band.name.should == "Bad Religion"
+      end
+    end
+    
+    context "#to_xml" do
+      it "doesn't escape xml from Band#to_xml" do
+        band = Band.new
+        band.name = "Bad Religion"
+        album = Albumy.new
+        album.band = band
+        
+        album.to_xml.to_s.should equal_xml %{<album>
+         <band>
+           <name>Bad Religion</name>
+         </band>
+       </album>}
+      end
+      
+      it "doesn't escape and wrap string from Label#to_xml" do
+        album = Albumy.new
+        album.label = Label.new
+        
+        album.to_xml.to_s.should equal_xml %{<album>
+          <label>Fat Wreck</label>
+        </album>}
+      end
+    end
+  end
+  
+
+  describe "collections" do
+    context ":as => [Item]" do
+      class Book
+        include Representable
+
+
+        xml_accessor :contributors, :as => [Contributor], :tag => :contributor
+      end
+
+      it ".from_xml pushes collection items to array" do
+        book = Book.from_xml(%{
+          <book>
+            <contributor><name>David Thomas</name></contributor>
+            <contributor><name>Andrew Hunt</name></contributor>
+            <contributor><name>Chad Fowler</name></contributor>
+          </book>
+        })
+        book.contributors.map(&:name).sort.should == ["David Thomas","Andrew Hunt","Chad Fowler"].sort
+      end
+      
+      it "collections can be empty" do
+        book = Book.from_xml(%{
+          <book>
+          </book>
+        })
+        book.contributors.should == []
+      end
+      
+      it "responds to #to_xml" do
+        book = Book.new
+        david = Contributor.new
+        david.name= "David Thomas"
+        chad = Contributor.new
+        chad.name= "Chad Fowler"
+        book.contributors = [david, chad]
+        
+        book.to_xml.to_s.should equal_xml %{<book>
+            <contributor><name>David Thomas</name></contributor>
+            <contributor><name>Chad Fowler</name></contributor>
+          </book>}
+      end
+    end
+    
+    
+    context ":as => []" do
+      class Album
+        include Representable
+        
+        xml_accessor :songs, :as => [], :tag => :song
+      end
+
+      it "collects untyped items" do
+        album = Album.from_xml(%{
+          <album>
+            <song>Two Kevins</song>
+            <song>Wright and Rong</song>
+            <song>Laundry Basket</song>
+          </album>
+        })
+        album.songs.sort.should == ["Laundry Basket", "Two Kevins", "Wright and Rong"].sort
+      end
+    end
+  end
+  
+  def parse_xml(xml); Nokogiri::XML::Node.from(xml); end
+  
+  describe "Reference" do
+    context "ObjectRef with []" do
+      subject do
+        Representable::XMLObjectRef.new(Representable::Definition.new(:songs, :as => [Album]))
+      end
+      
+      it "responds to #default" do
+        subject.send(:default).should == []
+      end
+    end
+    
+    
+    
+    
+    context "TextRef#value_in" do
+      subject do
+        Representable::XMLTextRef.new(Representable::Definition.new(:song))
+      end
+      
+      it "returns found value" do
+        subject.value_in(parse_xml("<a><song>Unkoil</song></a>")).should == "Unkoil"
+      end
+      
+    end
+  end    
+  
+  
+  describe "Definition" do
+    context "generic API" do
+      subject do
+        Representable::Definition.new(:songs)
+      end
+      
+      it "responds to #typed?" do
+        subject.typed? == false
+        Representable::Definition.new(:songs, :as => Album).typed? == true
+        Representable::Definition.new(:songs, :as => [Album]).typed? == true
+      end
+      
+      
+      context "#apply" do
+        subject do
+          Representable::Definition.new(:song)
+        end
+        
+        it "works with a single item" do
+          subject.apply(1) { |v| v+1 }.should == 2
+        end
+        
+        it "works with collection" do
+          d = Representable::Definition.new(:song, :as => [])
+          d.apply([1,2,3]) { |v| v+1 }.should == [2,3,4]
+        end
+        
+        it "skips with collection and nil" do
+          d = Representable::Definition.new(:song, :as => [])
+          d.apply(nil) { |v| v+1 }.should == nil
+        end
+        
+      end
+    end
+    
+    context ":as => []" do
+      subject do
+        Representable::Definition.new(:songs, :as => [], :tag => :song)
+      end
+      
+      it "responds to #accessor" do
+        subject.accessor.should == "songs"
+      end
+      
+      it "responds to #array?" do
+        subject.array?.should be_true
+      end
+      
+      it "responds to #name" do
+        subject.accessor.should == "songs"
+      end
+      
+      it "responds to #instance_variable_name" do
+        subject.instance_variable_name.should == :"@songs"
+      end
+      
+      it "responds to #setter" do
+        subject.setter.should == :"songs="
+      end
+      
+      it "responds to #sought_type" do
+        subject.sought_type.should == :text
+      end
+    end
+    
+    
+    context ":as => [Item]" do
+      subject do
+        class Song; end
+        Representable::Definition.new(:songs, :as => [Song])
+      end
+      
+      it "responds to #sought_type" do
+        subject.sought_type.should == Song
+      end
+    end
+    
+    
+    context ":as => Item" do
+      subject do
+        class Song; end
+        Representable::Definition.new(:songs, :as => Song)
+      end
+      
+      it "responds to #sought_type" do
+        subject.sought_type.should == Song
+      end
+    end
+  end
+end