nokogiri-happymapper 0.8.1 → 0.10.0

data/spec/features/mixed_namespaces_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'A document with mixed namespaces', type: :feature do
-  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
-
-  #
-  # 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
-
-  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/features/parse_with_object_to_update_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Updating existing objects with .parse and #parse', type: :feature do
-  let(:root) { 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
-    aggregate_failures do
-      expect(root.attr1).to eq('initial')
-      item_is_correctly_defined(root.items[0])
-      item_is_correctly_defined(root.items[1])
-    end
-  end
-
-  describe '.parse', 'specifying an existing object to update' do
-    it 'all fields are correct' do
-      ParseInstanceSpec::Root.parse(parse_instance_updated_xml, update: root)
-
-      aggregate_failures do
-        expect(root.attr1).to eq 'updated'
-        item_is_correctly_defined(root.items[0], 'updated')
-        item_is_correctly_defined(root.items[1], 'updated')
-      end
-    end
-  end
-
-  describe '#parse' do
-    it 'all fields are correct' do
-      root.parse(parse_instance_updated_xml)
-
-      aggregate_failures do
-        expect(root.attr1).to eq 'updated'
-        item_is_correctly_defined(root.items[0], 'updated')
-        item_is_correctly_defined(root.items[1], 'updated')
-      end
-    end
-  end
-end

data/spec/features/same_tag_different_meaning_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'parsing the same tag differently in different contexts', type: :feature do
-  module SameTagSpec
-    class Bar
-      include HappyMapper
-      has_one :baz, String
-    end
-
-    class Baz
-      include HappyMapper
-      has_one :qux, String
-    end
-
-    class Foo
-      include HappyMapper
-      has_one :bar, Bar
-      has_one :baz, Baz, xpath: '.'
-    end
-  end
-
-  let(:xml) do
-    <<~XML
-      <foo>
-        <bar>
-          <baz>Hello</baz>
-        </bar>
-        <baz>
-          <qux>Hi</qux>
-        </baz>
-      </foo>
-    XML
-  end
-
-  it 'parses both uses correctly if xpath limits recursion' do
-    result = SameTagSpec::Foo.parse xml
-    aggregate_failures do
-      expect(result.bar.baz).to eq 'Hello'
-      expect(result.baz.qux).to eq 'Hi'
-    end
-  end
-end

data/spec/features/to_xml_spec.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Saving #to_xml', type: :feature 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
-      #
-      undef :housenumber
-      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) { Time.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| Time.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(:xml) do
-    country = ToXML::Country.new(name: 'USA', code: 'us', empty_code: nil,
-                                 description: ToXML::Country::Description.new('A lovely country'))
-
-    address = ToXML::Address.new 'street' => 'Mockingbird Lane',
-                                 'location' => 'Home',
-                                 'housenumber' => '1313',
-                                 'postcode' => '98103',
-                                 'city' => 'Seattle',
-                                 'country' => 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(xml.xpath(property.to_s).text).to eq value
-    end
-  end
-
-  it 'saves attributes' do
-    expect(xml.xpath('@location').text).to eq 'Home-live'
-  end
-
-  it 'saves attributes that are Boolean and have a value of false' do
-    expect(xml.xpath('@occupied').text).to eq 'false'
-  end
-
-  context "when an element has a 'read_only' parameter" do
-    it 'does not save elements' do
-      expect(xml.xpath('temporary')).to be_empty
-    end
-  end
-
-  context "when an attribute has a 'read_only' parameter" do
-    it 'does not save attributes' do
-      expect(xml.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(xml.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(xml.xpath('housenumber').text).to eq '[1313]'
-      end
-    end
-
-    context 'with a lambda' do
-      it 'saves the result of the lambda' do
-        expect(xml.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 = xml.xpath('dates_updated')
-
-        aggregate_failures do
-          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
-  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(xml.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(xml.xpath('country/@countryCode').text).to eq 'us'
-    end
-
-    it 'saves elements with a specified tag' do
-      expect(xml.xpath('country/countryName').text).to eq 'USA'
-    end
-
-    it 'saves elements with content' do
-      expect(xml.xpath('country/description').text).to eq 'A lovely country'
-    end
-  end
-end

data/spec/features/to_xml_with_namespaces_spec.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-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
-    #
-    undef :housenumber
-    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) { Time.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| Time.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
-
-RSpec.describe 'Saving #to_xml with xml namespaces', type: :feature do
-  context 'with namespaces' do
-    let(:xml) do
-      country = ToXMLWithNamespaces::Country.new(name: 'USA', code: 'us')
-      address = ToXMLWithNamespaces::Address.new('street' => 'Mockingbird Lane',
-                                                 'location' => 'Home',
-                                                 'housenumber' => '1313',
-                                                 'postcode' => '98103',
-                                                 'city' => 'Seattle',
-                                                 'country' => country,
-                                                 '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 'sets the namespace specified in the class' do
-      expect(xml.xpath('/').children.first.namespace.prefix).to eq 'address'
-    end
-
-    it 'saves elements' do
-      elements = { 'street' => 'Mockingbird Lane', 'postcode' => '98103', 'city' => 'Seattle' }
-
-      elements.each_pair do |property, value|
-        expect(xml.xpath("address:#{property}").text).to eq value
-      end
-    end
-
-    it 'saves attributes' do
-      expect(xml.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(xml.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 ivar' do
-          expect(xml.xpath('address:housenumber').text).to eq '[1313]'
-        end
-      end
-
-      context 'with a lambda' do
-        it 'saves the results' do
-          expect(xml.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(xml.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 = xml.xpath('address:dates_updated')
-
-          aggregate_failures do
-            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
-    end
-
-    context 'when an element type is a HappyMapper subclass' do
-      it 'saves attributes' do
-        expect(xml.xpath('country:country/@countryCode').text).to eq 'us'
-      end
-
-      it 'saves elements' do
-        expect(xml.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:beverage="http://beverages.org/Beverage/0.1" xmlns:coffee="http://coffee.org/Coffee/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' }
-      expect(machine.to_xml).to eq(expected_xml)
-    end
-  end
-end