nokogiri-happymapper 0.8.1 → 0.9.0

data/spec/features/ignay_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-RSpec.describe 'parsing a VOD catalog', type: :feature do
-  let(:catalog_tree) { CatalogTree.parse(fixture_file('inagy.xml'), single: true) }
-
-  it 'is not nil' do
-    expect(catalog_tree).not_to be_nil
-  end
-
-  it 'has the attribute code' do
-    expect(catalog_tree.code).to eq('NLD')
-  end
-
-  it 'has many nodes' do
-    nodes = catalog_tree.nodes
-
-    aggregate_failures do
-      expect(nodes).not_to be_empty
-      expect(nodes.length).to eq(2)
-    end
-  end
-
-  describe 'first node' do
-    let(:first_node) { catalog_tree.nodes.first }
-
-    it 'has a name' do
-      expect(first_node.name).to eq('Parent 1')
-    end
-
-    it 'has translations' do
-      translations = first_node.translations
-
-      aggregate_failures do
-        expect(translations.length).to eq(2)
-        expect(translations.first.language).to eq('en-GB')
-        expect(translations.last.name).to eq('Parent 1 de')
-      end
-    end
-
-    it 'has subnodes' do
-      nodes = first_node.nodes
-
-      aggregate_failures do
-        expect(nodes).to be_kind_of(Enumerable)
-        expect(nodes).not_to be_empty
-        expect(nodes.length).to eq(1)
-      end
-    end
-
-    it 'first node - first node name' do
-      expect(first_node.nodes.first.name).to eq('First')
-    end
-  end
-end

data/spec/features/inheritance_spec.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Using inheritance to share elements and attributes', type: :feature 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(:overwrite) 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
-      aggregate_failures do
-        expect(Overwrite.attributes.count).to eq Parent.attributes.count
-        expect(Overwrite.elements.count).to eq Parent.elements.count
-      end
-    end
-
-    context 'when parsing xml' do
-      it 'parses the new overwritten attribut' do
-        expect(overwrite.love).to be == 'love'
-      end
-
-      it 'parses the new overwritten element' do
-        expect(overwrite.genetics).to be == 1001
-      end
-    end
-
-    context 'when saving to xml' do
-      let(:xml) 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(xml.xpath('//genetics').count).to be == 1
-      end
-
-      it 'has only 1 love attribute' do
-        expect(xml.xpath('@love').text).to be == 'love'
-      end
-    end
-  end
-
-  describe 'Child', 'a subclass of the Parent' do
-    let(:child) 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 'is possible to deserialize XML into a Child class instance' do
-        aggregate_failures do
-          expect(child.love).to eq 99
-          expect(child.genetics.dna).to eq 'ABBA'
-          expect(child.naivety).to eq 'trusting'
-          expect(child.immunities.size).to eq(1)
-        end
-      end
-    end
-
-    context 'when saving to xml' do
-      let(:xml) 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
-        aggregate_failures do
-          expect(xml.xpath('@naivety').text).to eq 'Bright Eyed'
-          expect(xml.xpath('@love').text).to eq '100'
-        end
-      end
-
-      it 'saves both the Child and Parent elements' do
-        aggregate_failures do
-          expect(xml.xpath('genetics').text).to eq 'GATTACA'
-          expect(xml.xpath('immunities').size).to eq(3)
-        end
-      end
-    end
-  end
-end

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