xmlmapper 0.5.9

data/spec/to_xml_with_namespaces_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+module ToXMLWithNamespaces
+
+  #
+  # Similar example as the to_xml but this time with namespacing
+  #
+  class Address
+    include HappyMapper
+
+    register_namespace 'address', 'http://www.company.com/address'
+    register_namespace 'country', 'http://www.company.com/country'
+
+    tag 'Address'
+    namespace 'address'
+
+    element :country, 'Country', :tag => 'country', :namespace => 'country'
+
+    attribute :location, String, :on_save => :when_saving_location
+
+    element :street, String
+    element :postcode, String
+    element :city, String
+
+    element :housenumber, String
+
+    #
+    # to_xml will default to the attr_accessor method and not the attribute,
+    # allowing for that to be overwritten
+    #
+    def housenumber
+      "[#{@housenumber}]"
+    end
+
+    def when_saving_location(loc)
+      loc + '-live'
+    end
+
+    #
+    # Write a empty element even if this is not specified
+    #
+    element :description, String, :state_when_nil => true
+
+    #
+    # Perform the on_save operation when saving
+    #
+    has_one :date_created, Time, :on_save => lambda {|time| DateTime.parse(time).strftime("%T %D") if time }
+
+    #
+    # Write multiple elements and call on_save when saving
+    #
+    has_many :dates_updated, Time, :on_save => lambda {|times|
+      times.compact.map {|time| DateTime.parse(time).strftime("%T %D") } if times }
+
+    #
+    # Class composition
+    #
+
+    def initialize(parameters)
+      parameters.each_pair do |property,value|
+        send("#{property}=",value) if respond_to?("#{property}=")
+      end
+    end
+
+  end
+
+  #
+  # Country is composed above the in Address class. Here is a demonstration
+  # of how to_xml will handle class composition as well as utilizing the tag
+  # value.
+  #
+  class Country
+    include HappyMapper
+
+    register_namespace 'countryName', 'http://www.company.com/countryName'
+
+    attribute :code, String, :tag => 'countryCode'
+    has_one :name, String, :tag => 'countryName', :namespace => 'countryName'
+
+    def initialize(parameters)
+      parameters.each_pair do |property,value|
+        send("#{property}=",value) if respond_to?("#{property}=")
+      end
+    end
+
+  end
+
+
+  #
+  # This class is an example of a class that has a default namespace
+  #xmlns="urn:eventis:prodis:onlineapi:1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  #
+  class Recipe
+    include HappyMapper
+
+    # this is the default namespace of the document
+    register_namespace 'xmlns', 'urn:eventis:prodis:onlineapi:1.0'
+    register_namespace 'xsi', "http://www.w3.org/2001/XMLSchema-instance"
+    register_namespace 'xsd', "http://www.w3.org/2001/XMLSchema"
+
+    has_many :ingredients, String
+
+    def initialize(parameters)
+      parameters.each_pair {|property,value| send("#{property}=",value) if respond_to?("#{property}=") }
+    end
+  end
+end
+
+describe "Saving #to_xml", "with xml namespaces" do
+
+  context "#to_xml", "with namespaces" do
+
+    let(:subject) do
+      address = ToXMLWithNamespaces::Address.new('street' => 'Mockingbird Lane',
+      'location' => 'Home',
+      'housenumber' => '1313',
+      'postcode' => '98103',
+      'city' => 'Seattle',
+      'country' => ToXMLWithNamespaces::Country.new(:name => 'USA', :code => 'us'),
+      'date_created' => '2011-01-01 15:00:00')
+
+
+      address.dates_updated = ["2011-01-01 16:01:00","2011-01-02 11:30:01"]
+
+      Nokogiri::XML(address.to_xml).root
+    end
+
+    it "saves elements" do
+      elements = { 'street' => 'Mockingbird Lane', 'postcode' => '98103', 'city' => 'Seattle' }
+
+      elements.each_pair do |property,value|
+        expect(subject.xpath("address:#{property}").text).to eq value
+      end
+    end
+
+    it "saves attributes" do
+      expect(subject.xpath('@location').text).to eq "Home-live"
+    end
+
+    context "when an element has a 'state_when_nil' parameter" do
+      it "saves an empty element" do
+        expect(subject.xpath('address:description').text).to eq ""
+      end
+    end
+
+    context "when an element has a 'on_save' parameter" do
+      context "with a symbol which represents a function" do
+        it "saves the element with the result of a function call and not the value of the instance variable" do
+          expect(subject.xpath("address:housenumber").text).to eq "[1313]"
+        end
+      end
+
+      context "with a lambda" do
+        it "saves the results" do
+          expect(subject.xpath('address:date_created').text).to eq "15:00:00 01/01/11"
+        end
+      end
+    end
+
+    context "when an attribute has a 'on_save' parameter" do
+      context "with a lambda" do
+        it "saves the result" do
+          expect(subject.xpath('@location').text).to eq "Home-live"
+        end
+      end
+    end
+
+    context "when a has_many has a 'on_save' parameter" do
+      context "with a lambda" do
+        it "saves the result" do
+          dates_updated = subject.xpath('address:dates_updated')
+          expect(dates_updated.length).to eq 2
+          expect(dates_updated.first.text).to eq "16:01:00 01/01/11"
+          expect(dates_updated.last.text).to eq "11:30:01 01/02/11"
+        end
+      end
+    end
+
+    context "when an element type is a HappyMapper subclass" do
+      it "saves attributes" do
+        expect(subject.xpath('country:country/@countryCode').text).to eq "us"
+      end
+
+      it "saves elements" do
+        expect(subject.xpath('country:country/countryName:countryName').text).to eq "USA"
+      end
+    end
+  end
+
+  context "with a default namespace" do
+    it "writes the default namespace to xml without repeating xmlns" do
+      recipe = ToXMLWithNamespaces::Recipe.new(:ingredients => ['One Cup Flour', 'Two Scoops of Lovin'])
+      expect(recipe.to_xml).to match /xmlns=\"urn:eventis:prodis:onlineapi:1\.0\"/
+    end
+  end
+
+  context 'namespace supplied by element declaration trumps namespace ' \
+          'specified by element class' do
+
+    let(:expected_xml) do
+      <<-XML.gsub(/^\s*\|/, '')
+        |<?xml version="1.0"?>
+        |<coffeemachine xmlns:coffee="http://coffee.org/Coffee/0.1" xmlns:beverage="http://beverages.org/Beverage/0.1">
+        |  <beverage:beverage name="coffee"/>
+        |</coffeemachine>
+      XML
+    end
+
+    class Beverage
+      include HappyMapper
+      namespace 'coffee'
+
+      attribute :name, String
+    end
+
+    class CoffeeMachine
+      include HappyMapper
+      register_namespace 'coffee', "http://coffee.org/Coffee/0.1"
+      register_namespace 'beverage', "http://beverages.org/Beverage/0.1"
+
+      element :beverage, 'beverage', namespace: 'beverage'
+    end
+
+    it 'uses the element declaration namespace on the element' do
+      machine = CoffeeMachine.new
+      machine.beverage = Beverage.new.tap {|obj| obj.name = 'coffee'}
+      machine.to_xml.should be == expected_xml
+    end
+  end
+
+end

data/spec/wilcard_tag_name_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe "Wildcard Root Tag" do
+
+  generic_class_xml = %{
+    <root>
+        <description>some description</description>
+        <blarg name='blargname1' href='http://blarg.com'/>
+        <blarg name='blargname2' href='http://blarg.com'/>
+        <jello name='jelloname' href='http://jello.com'/>
+        <subelement>
+          <jello name='subjelloname' href='http://ohnojello.com' other='othertext'/>
+        </subelement>
+      </root>}
+
+  module GenericBase
+    class Base
+      include Comparable
+      include HappyMapper
+
+      def initialize(params = {})
+        @name = params[:name]
+        @href = params[:href]
+        @other = params[:other]
+      end
+
+      tag '*'
+      attribute :name, String
+      attribute :href, String
+      attribute :other, String
+
+      def <=>(compared)
+        name <=> compared.name && href <=> compared.href && other <=> compared.other
+      end
+    end
+    class Sub
+      include HappyMapper
+      tag 'subelement'
+      has_one :jello, Base, :tag => 'jello'
+    end
+    class Root
+      include HappyMapper
+      tag 'root'
+      element :description, String
+      has_many :blargs, Base, :tag => 'blarg', :xpath => '.'
+      has_many :jellos, Base, :tag => 'jello', :xpath => '.'
+      has_many :subjellos, Base, :tag => 'jello', :xpath => 'subelement/.', :read_only => true
+      has_one :sub_element, Sub
+    end
+  end
+
+  describe "can have generic classes using tag '*'" do
+
+    let(:subject) { GenericBase::Root.parse(generic_class_xml) }
+    let(:xml) { Nokogiri::XML(subject.to_xml) }
+
+    it 'should map different elements to same class' do
+      subject.blargs.should_not be_nil
+      subject.jellos.should_not be_nil
+    end
+
+    it 'should filter on xpath appropriately' do
+      subject.blargs.should have(2).items
+      subject.jellos.should have(1).items
+      subject.subjellos.should have(1).items
+    end
+
+    def base_with(name,href,other)
+      GenericBase::Base.new(:name => name,:href => href,:other => other)
+    end
+
+    it 'should parse correct values onto generic class' do
+      expect(subject.blargs[0]).to eq base_with('blargname1','http://blarg.com',nil)
+      expect(subject.blargs[1]).to eq base_with('blargname2','http://blarg.com',nil)
+      expect(subject.jellos[0]).to eq base_with('jelloname','http://jello.com',nil)
+      expect(subject.subjellos[0]).to eq base_with('subjelloname','http://ohnojello.com','othertext')
+    end
+
+    def validate_xpath(xpath,name,href,other)
+      expect(xml.xpath("#{xpath}/@name").text).to eq name
+      expect(xml.xpath("#{xpath}/@href").text).to eq href
+      expect(xml.xpath("#{xpath}/@other").text).to eq other
+    end
+
+    it 'should #to_xml using parent element tag name' do
+      xml.xpath('/root/description').text.should == 'some description'
+      validate_xpath("/root/blarg[1]","blargname1","http://blarg.com","")
+      validate_xpath("/root/blarg[2]","blargname2","http://blarg.com","")
+      validate_xpath("/root/jello[1]","jelloname","http://jello.com","")
+    end
+
+    it "should properly respect child HappyMapper tags if tag isn't provided on the element defintion" do
+      xml.xpath('root/subelement').should have(1).item
+    end
+  end
+end

data/spec/wrap_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe "wrap which allows you to specify a wrapper element" do
+
+  module Wrap
+    class SubClass
+      include HappyMapper
+      tag 'subclass'
+      attribute :myattr, String
+      has_many :items, String, :tag => 'item'
+    end
+    class Root
+      include HappyMapper
+      tag 'root'
+      attribute :attr1, String
+      element :name, String
+      wrap 'mywraptag' do
+        element :description, String
+        has_one :subclass, SubClass
+      end
+      element :number, Integer
+    end
+  end
+
+  describe ".parse" do
+    context "when given valid XML" do
+      let(:subject) { Wrap::Root.parse fixture_file('wrapper.xml') }
+
+      it 'sets the values correctly' do
+        expect(subject.attr1).to eq 'somevalue'
+        expect(subject.name).to eq 'myname'
+        expect(subject.description).to eq 'some description'
+        expect(subject.subclass.myattr).to eq 'attrvalue'
+        expect(subject.subclass.items).to have(2).items
+        expect(subject.subclass.items[0]).to eq 'item1'
+        expect(subject.subclass.items[1]).to eq 'item2'
+        expect(subject.number).to eq 12345
+      end
+    end
+
+    context "when initialized without XML" do
+      let(:subject) { Wrap::Root.new }
+
+      it "anonymous classes are created so nil class values does not occur" do
+        expect { subject.description = 'anything' }.to_not raise_error
+      end
+    end
+  end
+
+  describe ".to_xml" do
+    let(:subject) do
+      root = Wrap::Root.new
+      root.attr1 = 'somevalue'
+      root.name = 'myname'
+      root.description = 'some description'
+      root.number = 12345
+
+      subclass = Wrap::SubClass.new
+      subclass.myattr = 'attrvalue'
+      subclass.items = []
+      subclass.items << 'item1'
+      subclass.items << 'item2'
+
+      root.subclass = subclass
+
+      root
+    end
+
+    it "generates the correct xml" do
+      xml = Nokogiri::XML(subject.to_xml)
+      expect(xml.xpath('/root/@attr1').text).to eq 'somevalue'
+      expect(xml.xpath('/root/name').text).to eq 'myname'
+      expect(xml.xpath('/root/mywraptag/description').text).to eq 'some description'
+      expect(xml.xpath('/root/mywraptag/subclass/@myattr').text).to eq 'attrvalue'
+      expect(xml.xpath('/root/mywraptag/subclass/item')).to have(2).items
+      expect(xml.xpath('/root/mywraptag/subclass/item[1]').text).to eq 'item1'
+      expect(xml.xpath('/root/mywraptag/subclass/item[2]').text).to eq 'item2'
+      expect(xml.xpath('/root/number').text).to eq '12345'
+    end
+
+  end
+end

data/spec/xpath_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe "Specifying elements and attributes with an xpath" do
+
+  class Item
+    include HappyMapper
+
+    tag 'item'
+    namespace 'amazing'
+
+    element :title, String
+    attribute :link, String, :xpath => 'amazing:link/@href'
+    has_one :different_link, String, :xpath => 'different:link/@href'
+    element :detail, String, :xpath => 'amazing:subitem/amazing:detail'
+    has_many :more_details_text, String, :xpath => 'amazing:subitem/amazing:more'
+    has_many :more_details, String, :xpath => 'amazing:subitem/amazing:more/@first|amazing:subitem/amazing:more/@alternative'
+    has_many :more_details_alternative, String, :xpath => 'amazing:subitem/amazing:more/@*'
+
+    has_one :baby, 'Baby', :name => 'baby', :namespace => 'amazing'
+
+  end
+
+  class Baby
+    include HappyMapper
+
+    has_one :name, String
+  end
+
+  let(:subject) { Item.parse(xml_string,:single => true) }
+
+  let(:xml_string) do
+    %{
+    <rss>
+      <amazing:item xmlns:amazing="http://www.amazing.com/amazing" xmlns:different="http://www.different.com/different">
+        <amazing:title>Test XML</amazing:title>
+        <different:link href="different_link" />
+        <amazing:link href="link_to_resources" />
+        <amazing:subitem>
+          <amazing:detail>I want to parse this</amazing:detail>
+          <amazing:more first="this one">more 1</amazing:more>
+          <amazing:more alternative="another one">more 2</amazing:more>
+        </amazing:subitem>
+        <amazing:baby>
+          <amazing:name>Jumbo</amazing:name>
+        </amazing:baby>
+      </amazing:item>
+    </rss>
+    }
+  end
+
+  it "should have a title" do
+    expect(subject.title).to eq "Test XML"
+  end
+
+  it "should find the link href value" do
+    expect(subject.link).to eq 'link_to_resources'
+  end
+
+  it "should find the link href value" do
+    expect(subject.different_link).to eq 'different_link'
+  end
+
+  it "should find this subitem based on the xpath" do
+    expect(subject.detail).to eq 'I want to parse this'
+  end
+
+  it "should find the subitems based on the xpath" do
+    expect(subject.more_details_text).to have(2).items
+    expect(subject.more_details_text.first).to eq  "more 1"
+    expect(subject.more_details_text.last).to eq "more 2"
+  end
+
+  it "should find the subitems based on the xpath" do
+    expect(subject.more_details).to have(2).items
+    expect(subject.more_details.first).to eq "this one"
+    expect(subject.more_details.last).to eq "another one"
+  end
+
+  it "should find the subitems based on the xpath" do
+    expect(subject.more_details_alternative).to have(2).items
+    expect(subject.more_details_alternative.first).to eq "this one"
+    expect(subject.more_details_alternative.last).to eq "another one"
+  end
+
+  it "should have a baby name" do
+    expect(subject.baby.name).to eq "Jumbo"
+  end
+
+end