blockscore-happymapper 0.6.0

data/spec/to_xml_with_namespaces_spec.rb

@@ -0,0 +1,223 @@
+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: ->(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,94 @@
+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,80 @@
+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 12_345
+      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 = 12_345
+
+      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,86 @@
+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