blockscore-happymapper 0.6.0

data/spec/has_many_empty_array_spec.rb

@@ -0,0 +1,42 @@
+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,87 @@
+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
+
+  attr_reader :catalog_tree
+
+  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,105 @@
+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,58 @@
+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,108 @@
+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,8 @@
+require 'rspec'
+require 'rspec/collection_matchers'
+
+require 'happymapper'
+
+def fixture_file(filename)
+  File.read(File.dirname(__FILE__) + "/fixtures/#{filename}")
+end

data/spec/to_xml_spec.rb

@@ -0,0 +1,197 @@
+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: ->(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