xmlmapper 0.5.9

data/spec/has_many_empty_array_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module Sheep
+  class Item
+    include HappyMapper
+  end
+
+  class Navigator
+    include HappyMapper
+    tag 'navigator'
+
+    # This is purposefully set to have the name 'items' with the tag 'item'.
+    # The idea is that it should not find the empty items contained within the
+    # xml and return an empty array. This exercises the order of how nodes
+    # are searched for within an XML document.
+    has_many :items, Item, tag: 'item'
+
+    has_many :items_with_a_different_name, Item, tag: 'item'
+
+  end
+end
+
+describe "emptyness" do
+  let(:xml) do
+    <<-EOF
+    <navigator>
+      <items/>
+    </navigator>
+    EOF
+  end
+
+  let(:navigator) do
+    Sheep::Navigator.parse(xml)
+  end
+
+  it "returns an empty array" do
+    navigator.items_with_a_different_name.should be_empty
+  end
+
+  it "returns an empty array" do
+    navigator.items.should be_empty
+  end
+end

data/spec/ignay_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+class CatalogTree
+  include HappyMapper
+
+  tag 'CatalogTree'
+  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'
+
+  attribute :code, String
+
+  has_many :nodes, 'CatalogNode', :tag => 'Node', :xpath => '.'
+
+end
+
+
+class CatalogNode
+  include HappyMapper
+
+  tag 'Node'
+
+  attribute :back_office_id, String, :tag => 'vodBackOfficeId'
+
+  has_one :name, String, :tag => 'Name'
+  # other important fields
+
+  has_many :translations, 'CatalogNode::Translations', :tag => 'Translation', :xpath => 'child::*'
+
+  class Translations
+    include HappyMapper
+    tag 'Translation'
+
+    attribute :language, String, :tag => 'Language'
+    has_one :name, String, :tag => 'Name'
+
+  end
+
+  has_many :nodes, CatalogNode, :tag => 'Node', :xpath => 'child::*'
+
+end
+
+describe HappyMapper do
+
+  it "should not be nil" do
+    catalog_tree.should_not be_nil
+  end
+
+  it "should have the attribute code" do
+    catalog_tree.code.should == "NLD"
+  end
+
+  it "should have many nodes" do
+    catalog_tree.nodes.should_not be_empty
+    catalog_tree.nodes.length.should == 2
+  end
+
+  context "first node" do
+
+    it "should have a name" do
+      first_node.name.should == "Parent 1"
+    end
+
+    it "should have translations" do
+      first_node.translations.length.should == 2
+
+      first_node.translations.first.language.should == "en-GB"
+
+      first_node.translations.last.name.should == "Parent 1 de"
+    end
+
+    it "should have subnodes" do
+      first_node.nodes.should be_kind_of(Enumerable)
+      first_node.nodes.should_not be_empty
+      first_node.nodes.length.should == 1
+    end
+
+    it "first node - first node name" do
+      first_node.nodes.first.name.should == "First"
+    end
+
+    def first_node
+      @first_node = catalog_tree.nodes.first
+    end
+
+  end
+
+
+  def catalog_tree ; @catalog_tree ; end
+
+  before(:all) do
+    xml_reference = "#{File.dirname(__FILE__)}/fixtures/inagy.xml"
+    @catalog_tree = CatalogTree.parse(File.read(xml_reference), :single => true)
+  end
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe "Using inheritance to share elements and attributes" do
+
+  class Genetics
+    include HappyMapper
+    content :dna, String
+  end
+
+  class Parent
+    include HappyMapper
+    attribute :love, Integer
+    element :genetics, Genetics
+  end
+
+  class Child < Parent
+    include HappyMapper
+    attribute :naivety, String
+    has_many :immunities, String
+  end
+
+  class Overwrite < Parent
+    include HappyMapper
+
+    attribute :love, String
+    element :genetics, Integer
+  end
+
+  describe "Overwrite" do
+    let(:subject) do
+      xml = '<overwrite love="love" naivety="trusting"><genetics>1001</genetics><immunities>Chicken Pox</immunities></overwrite>'
+      Overwrite.parse(xml, single: true)
+    end
+
+    it 'overrides the parent elements and attributes' do
+      expect(Overwrite.attributes.count).to be == Parent.attributes.count
+      expect(Overwrite.elements.count).to be == Parent.elements.count
+    end
+
+    context "when parsing xml" do
+      it 'parses the new overwritten attribut' do
+        expect(subject.love).to be == "love"
+      end
+
+      it 'parses the new overwritten element' do
+        expect(subject.genetics).to be == 1001
+      end
+    end
+
+    context "when saving to xml" do
+      subject do
+        overwrite = Overwrite.new
+        overwrite.genetics = 1
+        overwrite.love = "love"
+        Nokogiri::XML(overwrite.to_xml).root
+      end
+
+      it 'has only 1 genetics element' do
+        expect(subject.xpath('//genetics').count).to be == 1
+      end
+
+      it 'has only 1 love attribute' do
+        expect(subject.xpath('@love').text).to be == "love"
+      end
+    end
+  end
+
+  describe "Child", "a subclass of the Parent" do
+    let(:subject) do
+      xml = '<child love="99" naivety="trusting"><genetics>ABBA</genetics><immunities>Chicken Pox</immunities></child>'
+      Child.parse(xml)
+    end
+
+    context "when parsing xml" do
+      it 'should be possible to deserialize XML into a Child class instance' do
+        expect(subject.love).to eq 99
+        expect(subject.genetics.dna).to eq "ABBA"
+        expect(subject.naivety).to eq "trusting"
+        expect(subject.immunities).to have(1).item
+      end
+    end
+
+    context "when saving to xml" do
+      let(:subject) do
+        child = Child.new
+        child.love = 100
+        child.naivety = 'Bright Eyed'
+        child.immunities = [ "Small Pox", "Chicken Pox", "Mumps" ]
+        genetics = Genetics.new
+        genetics.dna = "GATTACA"
+        child.genetics = genetics
+        Nokogiri::XML(child.to_xml).root
+      end
+
+      it "saves both the Child and Parent attributes" do
+        expect(subject.xpath("@naivety").text).to eq "Bright Eyed"
+        expect(subject.xpath("@love").text).to eq "100"
+      end
+
+      it "saves both the Child and Parent elements" do
+        expect(subject.xpath("genetics").text).to eq "GATTACA"
+        expect(subject.xpath("immunities")).to have(3).items
+      end
+    end
+
+  end
+end

data/spec/mixed_namespaces_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "A document with mixed namespaces" do
+
+  #
+  # Note that the parent element of the xml has the namespacing. The elements
+  # contained within the xml do not share the parent element namespace so a
+  # user of the library would likely need to clear the namespace on each of
+  # these child elements.
+  #
+  let(:xml_document) do
+    %{<prefix:address location='home' xmlns:prefix="http://www.unicornland.com/prefix"
+        xmlns:different="http://www.trollcountry.com/different">
+        <street>Milchstrasse</street>
+        <street>Another Street</street>
+        <housenumber>23</housenumber>
+        <different:postcode>26131</different:postcode>
+        <city>Oldenburg</city>
+      </prefix:address>}
+  end
+
+  module MixedNamespaces
+    class Address
+      include HappyMapper
+
+      namespace :prefix
+      tag :address
+
+      # Here each of the elements have their namespace set to nil to reset their
+      # namespace so that it is not the same as the prefix namespace
+
+      has_many :streets, String, tag: 'street', namespace: nil
+
+      has_one :house_number, String, tag: 'housenumber', namespace: nil
+      has_one :postcode, String, namespace: 'different'
+      has_one :city, String, namespace: nil
+    end
+  end
+
+  let(:address) do
+    MixedNamespaces::Address.parse(xml_document, single: true)
+  end
+
+
+  it "has the correct streets" do
+    expect(address.streets).to eq [ "Milchstrasse", "Another Street" ]
+  end
+
+  it "house number" do
+    expect(address.house_number).to eq "23"
+  end
+
+  it "postcode" do
+    expect(address.postcode).to eq "26131"
+  end
+
+  it "city" do
+    expect(address.city).to eq "Oldenburg"
+  end
+
+end

data/spec/parse_with_object_to_update_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe "Updating existing objects with .parse and #parse" do
+
+  let(:subject) { ParseInstanceSpec::Root.parse(parse_instance_initial_xml) }
+
+  let(:parse_instance_initial_xml) do
+     %{<root attr1="initial">
+      <item attr1="initial">
+        <description>initial</description>
+        <subitem attr1="initial">
+          <name>initial</name>
+        </subitem>
+        <subitem attr1="initial">
+          <name>initial</name>
+        </subitem>
+      </item>
+      <item attr1="initial">
+        <description>initial</description>
+        <subitem attr1="initial">
+          <name>initial</name>
+        </subitem>
+        <subitem attr1="initial">
+          <name>initial</name>
+        </subitem>
+      </item>
+    </root>}
+  end
+
+  let(:parse_instance_updated_xml) do
+    %{<root attr1="updated">
+      <item attr1="updated">
+        <description>updated</description>
+        <subitem attr1="updated">
+          <name>updated</name>
+        </subitem>
+        <subitem attr1="updated">
+          <name>updated</name>
+        </subitem>
+      </item>
+      <item attr1="updated">
+        <description>updated</description>
+        <subitem attr1="updated">
+          <name>updated</name>
+        </subitem>
+        <subitem attr1="updated">
+          <name>updated</name>
+        </subitem>
+      </item>
+    </root>}
+  end
+
+  module ParseInstanceSpec
+    class SubItem
+      include HappyMapper
+      tag 'subitem'
+      attribute :attr1, String
+      element :name, String
+    end
+    class Item
+      include HappyMapper
+      tag 'item'
+      attribute :attr1, String
+      element :description, String
+      has_many :sub_items, SubItem
+    end
+    class Root
+      include HappyMapper
+      tag 'root'
+      attribute :attr1, String
+      has_many :items, Item
+    end
+  end
+
+  def item_is_correctly_defined(item,value='initial')
+    expect(item.attr1).to eq value
+    expect(item.description).to eq value
+    expect(item.sub_items[0].attr1).to eq value
+    expect(item.sub_items[0].name).to eq value
+    expect(item.sub_items[1].attr1).to eq value
+    expect(item.sub_items[1].name).to eq value
+  end
+
+  it 'initial values are correct' do
+    subject.attr1.should == 'initial'
+    item_is_correctly_defined( subject.items[0] )
+    item_is_correctly_defined( subject.items[1] )
+  end
+
+
+  describe ".parse", "specifying an existing object to update" do
+    it 'all fields are correct' do
+      ParseInstanceSpec::Root.parse(parse_instance_updated_xml, :update => subject)
+      expect(subject.attr1).to eq 'updated'
+
+      item_is_correctly_defined( subject.items[0], 'updated' )
+      item_is_correctly_defined( subject.items[1], 'updated' )
+    end
+  end
+
+  describe "#parse" do
+    it "all fields are correct" do
+      subject.parse(parse_instance_updated_xml)
+      expect(subject.attr1).to eq 'updated'
+
+      item_is_correctly_defined( subject.items[0], 'updated' )
+      item_is_correctly_defined( subject.items[1], 'updated' )
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+
+require 'happymapper'
+
+def fixture_file(filename)
+  File.read(File.dirname(__FILE__) + "/fixtures/#{filename}")
+end

data/spec/to_xml_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe "Saving #to_xml" do
+
+  module ToXML
+    class Address
+      include HappyMapper
+
+      tag 'address'
+
+      attribute :location, String, :on_save => :when_saving_location
+
+      element :street, String
+      element :postcode, String
+      element :city, String
+
+      element :housenumber, String
+
+      attribute :modified, Boolean, :read_only => true
+      element :temporary, Boolean, :read_only => true
+      #
+      # 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 }
+
+
+      #
+      # Execute the method with the same name
+
+      #
+      # 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
+      #
+      element :country, 'Country', :tag => 'country'
+
+      attribute :occupied, Boolean
+
+      def initialize(parameters)
+        parameters.each_pair do |property,value|
+          send("#{property}=",value) if respond_to?("#{property}=")
+        end
+        @modified = @temporary = true
+      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
+
+      attribute :code, String, :tag => 'countryCode'
+      has_one :name, String, :tag => 'countryName'
+      has_one :description, 'Description', :tag => 'description'
+
+      #
+      # This inner-class here is to demonstrate saving a text node
+      # and optional attributes
+      #
+      class Description
+        include HappyMapper
+        content :description, String
+        attribute :category, String, :tag => 'category'
+        attribute :rating, String, :tag => 'rating', :state_when_nil => true
+
+        def initialize(desc)
+          @description = desc
+        end
+      end
+
+      def initialize(parameters)
+        parameters.each_pair do |property,value|
+          send("#{property}=",value) if respond_to?("#{property}=")
+        end
+      end
+
+    end
+  end
+
+  let(:subject) do
+    address = ToXML::Address.new 'street' => 'Mockingbird Lane',
+      'location' => 'Home',
+      'housenumber' => '1313',
+      'postcode' => '98103',
+      'city' => 'Seattle',
+      'country' => ToXML::Country.new(:name => 'USA', :code => 'us', :empty_code => nil,
+        :description => ToXML::Country::Description.new("A lovely country") ),
+      'date_created' => '2011-01-01 15:00:00',
+      'occupied' => false
+
+    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("#{property}").text).to eq value
+    end
+  end
+
+  it "saves attributes" do
+    expect(subject.xpath('@location').text).to eq "Home-live"
+  end
+
+  it 'saves attributes that are Boolean and have a value of false' do
+    expect(subject.xpath('@occupied').text).to eq "false"
+  end
+
+  context "when an element has a 'read_only' parameter" do
+    it "does not save elements" do
+      expect(subject.xpath('temporary')).to be_empty
+    end
+  end
+
+  context "when an attribute has a 'read_only' parameter" do
+    it "does not save attributes" do
+      expect(subject.xpath("@modified")).to be_empty
+    end
+  end
+
+  context "when an element has a 'state_when_nil' parameter" do
+    it "saves an empty element" do
+      expect(subject.xpath('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 the function" do
+        expect(subject.xpath("housenumber").text).to eq "[1313]"
+      end
+    end
+
+    context "with a lambda" do
+      it "saves the result of the lambda" do
+        expect(subject.xpath('date_created').text).to eq "15:00:00 01/01/11"
+      end
+    end
+  end
+
+  context "when a has_many has a 'on_save' parameter" do
+    context "with a lambda" do
+      it "saves the results" do
+        dates_updated = subject.xpath('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 attribute has a 'on_save' parameter" do
+    context "with a symbol which represents a function" do
+      it "saves the result" do
+        expect(subject.xpath('@location').text).to eq "Home-live"
+      end
+    end
+  end
+
+  context "when an element type is a HappyMapper subclass" do
+    it "saves attributes" do
+      expect(subject.xpath('country/@countryCode').text).to eq "us"
+    end
+
+    it "saves elements" do
+      expect(subject.xpath('country/countryName').text).to eq "USA"
+    end
+
+    it "saves elements" do
+      expect(subject.xpath('country/description').text).to eq "A lovely country"
+    end
+  end
+end