nokogiri-happymapper 0.7.0 → 0.8.0

data/lib/happymapper/item.rb

@@ -28,7 +28,7 @@ module HappyMapper
     end
 
     #
-    # @param [XMLNode] node the xml node that is being parsed
+    # @param [Nokogiri::XML::Element] node the xml node that is being parsed
     # @param [String] namespace the name of the namespace
     # @param [Hash] xpath_options additional xpath options
     #

data/lib/happymapper/supported_types.rb

@@ -126,13 +126,8 @@ module HappyMapper
 
     register_type Integer do |value|
       value_to_i = value.to_i
-      if value_to_i == 0 && value != '0'
-        value_to_s = value.to_s
-        begin
-          Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
-        rescue ArgumentError
-          nil
-        end
+      if value_to_i == 0 && !value.to_s.start_with?('0')
+        nil
       else
         value_to_i
       end

data/lib/happymapper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HappyMapper
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/spec/features/after_parse_callbacks_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'after_parse callbacks' do
+  module AfterParseSpec
+    class Address
+      include HappyMapper
+      element :street, String
+    end
+  end
+
+  after do
+    AfterParseSpec::Address.after_parse_callbacks.clear
+  end
+
+  it 'callbacks with the newly created object' do
+    from_cb = nil
+    called = false
+    cb1 = proc { |object| from_cb = object }
+    cb2 = proc { called = true }
+    AfterParseSpec::Address.after_parse(&cb1)
+    AfterParseSpec::Address.after_parse(&cb2)
+
+    object = AfterParseSpec::Address.parse fixture_file('address.xml')
+    expect(from_cb).to eq(object)
+    expect(called).to eq(true)
+  end
+end

data/spec/{attribute_default_value_spec.rb → features/attribute_default_value_spec.rb}

@@ -30,15 +30,15 @@ describe 'Attribute Default Value' do
     end
 
     context 'when a new, non-nil value has been set' do
+      let(:expected_xml) { %(<?xml version="1.0"?>\n<meal type="kosher"/>\n) }
+
       it 'returns the new value' do
         meal = subject.parse('<meal />')
         meal.type = 'vegan'
 
-        expect(meal.type).to_not eq default_meal_type
+        expect(meal.type).not_to eq default_meal_type
       end
 
-      let(:expected_xml) { %(<?xml version="1.0"?>\n<meal type="kosher"/>\n) }
-
       it 'saves the new value to the xml' do
         meal = subject.new
         meal.type = 'kosher'

data/spec/{attributes_spec.rb → features/attributes_spec.rb}

@@ -3,12 +3,6 @@
 require 'spec_helper'
 
 describe 'Attribute Method Conversion' do
-  let(:xml_document) do
-    %(<document>
-        <link data-src='http://cooking.com/roastbeef' type='recipe'>Roast Beef</link>
-      </document>)
-  end
-
   module AttributeMethodConversion
     class Document
       include HappyMapper
@@ -17,6 +11,12 @@ describe 'Attribute Method Conversion' do
     end
   end
 
+  let(:xml_document) do
+    %(<document>
+        <link data-src='http://cooking.com/roastbeef' type='recipe'>Roast Beef</link>
+      </document>)
+  end
+
   let(:document) do
     AttributeMethodConversion::Document.parse(xml_document, single: true)
   end

data/spec/{has_many_empty_array_spec.rb → features/has_many_empty_array_spec.rb}

@@ -38,7 +38,7 @@ describe 'emptyness' do
     expect(navigator.items_with_a_different_name).to be_empty
   end
 
-  it 'returns an empty array' do
+  it 'looks for items based on the element tag, not the element name' do
     expect(navigator.items).to be_empty
   end
 end

data/spec/{ignay_spec.rb → features/ignay_spec.rb}

@@ -39,25 +39,29 @@ class CatalogNode
 end
 
 describe HappyMapper do
-  it 'should not be nil' 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 'should have the attribute code' do
+  it 'has the attribute code' do
     expect(catalog_tree.code).to eq('NLD')
   end
 
-  it 'should have many nodes' do
+  it 'has many nodes' do
     expect(catalog_tree.nodes).not_to be_empty
     expect(catalog_tree.nodes.length).to eq(2)
   end
 
   context 'first node' do
-    it 'should have a name' do
+    let(:first_node) { catalog_tree.nodes.first }
+
+    it 'has a name' do
       expect(first_node.name).to eq('Parent 1')
     end
 
-    it 'should have translations' do
+    it 'has translations' do
       expect(first_node.translations.length).to eq(2)
 
       expect(first_node.translations.first.language).to eq('en-GB')
@@ -65,7 +69,7 @@ describe HappyMapper do
       expect(first_node.translations.last.name).to eq('Parent 1 de')
     end
 
-    it 'should have subnodes' do
+    it 'has subnodes' do
       expect(first_node.nodes).to be_kind_of(Enumerable)
       expect(first_node.nodes).not_to be_empty
       expect(first_node.nodes.length).to eq(1)
@@ -74,18 +78,5 @@ describe HappyMapper do
     it 'first node - first node name' do
       expect(first_node.nodes.first.name).to eq('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 → features/inheritance_spec.rb}

@@ -79,7 +79,7 @@ describe 'Using inheritance to share elements and attributes' do
     end
 
     context 'when parsing xml' do
-      it 'should be possible to deserialize XML into a Child class instance' do
+      it 'is 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'

data/spec/{mixed_namespaces_spec.rb → features/mixed_namespaces_spec.rb}

@@ -3,23 +3,6 @@
 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
@@ -38,6 +21,23 @@ describe 'A document with mixed namespaces' do
     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

data/spec/features/same_tag_different_meaning_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'parsing the same tag differently in different contexts' 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/{to_xml_spec.rb → features/to_xml_spec.rb}

@@ -191,11 +191,11 @@ describe 'Saving #to_xml' do
       expect(subject.xpath('country/@countryCode').text).to eq 'us'
     end
 
-    it 'saves elements' do
+    it 'saves elements with a specified tag' do
       expect(subject.xpath('country/countryName').text).to eq 'USA'
     end
 
-    it 'saves elements' do
+    it 'saves elements with content' do
       expect(subject.xpath('country/description').text).to eq 'A lovely country'
     end
   end

data/spec/{wilcard_tag_name_spec.rb → features/wildcard_tag_name_spec.rb}

@@ -58,12 +58,12 @@ describe 'Wildcard Root 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
+    it 'maps different elements to same class' do
       expect(subject.blargs).not_to be_nil
       expect(subject.jellos).not_to be_nil
     end
 
-    it 'should filter on xpath appropriately' do
+    it 'filters on xpath appropriately' do
       expect(subject.blargs.size).to eq(2)
       expect(subject.jellos.size).to eq(1)
       expect(subject.subjellos.size).to eq(1)
@@ -73,7 +73,7 @@ describe 'Wildcard Root Tag' do
       GenericBase::Base.new(name: name, href: href, other: other)
     end
 
-    it 'should parse correct values onto generic class' do
+    it 'parses 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)
@@ -86,14 +86,14 @@ describe 'Wildcard Root Tag' do
       expect(xml.xpath("#{xpath}/@other").text).to eq other
     end
 
-    it 'should #to_xml using parent element tag name' do
+    it '#to_xmls using parent element tag name' do
       expect(xml.xpath('/root/description').text).to eq('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
+    it "properlies respect child HappyMapper tags if tag isn't provided on the element defintion" do
       expect(xml.xpath('root/subelement').size).to eq(1)
     end
   end

data/spec/{wrap_spec.rb → features/wrap_spec.rb}

@@ -35,15 +35,15 @@ describe 'wrap which allows you to specify a wrapper element' do
         expect(subject.subclass.items.size).to eq(2)
         expect(subject.subclass.items[0]).to eq 'item1'
         expect(subject.subclass.items[1]).to eq 'item2'
-        expect(subject.number).to eq 12345
+        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
+      it 'creates anonymous classes so nil class values do not occur' do
+        expect { subject.description = 'anything' }.not_to raise_error
       end
     end
   end
@@ -54,7 +54,7 @@ describe 'wrap which allows you to specify a wrapper element' do
       root.attr1 = 'somevalue'
       root.name = 'myname'
       root.description = 'some description'
-      root.number = 12345
+      root.number = 12_345
 
       subclass = Wrap::SubClass.new
       subclass.myattr = 'attrvalue'

data/spec/{xpath_spec.rb → features/xpath_spec.rb}

@@ -27,7 +27,7 @@ describe 'Specifying elements and attributes with an xpath' do
     has_one :name, String
   end
 
-  let(:subject) { Item.parse(xml_string, single: true) }
+  let(:parsed_result) { Item.parse(xml_string, single: true) }
 
   let(:xml_string) do
     %(
@@ -50,41 +50,35 @@ describe 'Specifying elements and attributes with an xpath' do
     )
   end
 
-  it 'should have a title' do
-    expect(subject.title).to eq 'Test XML'
+  it 'has a title' do
+    expect(parsed_result.title).to eq 'Test XML'
   end
 
-  it 'should find the link href value' do
-    expect(subject.link).to eq 'link_to_resources'
+  it 'finds the link href value' do
+    expect(parsed_result.link).to eq 'link_to_resources'
   end
 
-  it 'should find the link href value' do
-    expect(subject.different_link).to eq 'different_link'
+  it 'finds the other link href value' do
+    expect(parsed_result.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'
+  it 'finds this subitem based on the xpath' do
+    expect(parsed_result.detail).to eq 'I want to parse this'
   end
 
-  it 'should find the subitems based on the xpath' do
-    expect(subject.more_details_text.size).to eq(2)
-    expect(subject.more_details_text.first).to eq 'more 1'
-    expect(subject.more_details_text.last).to eq 'more 2'
+  it 'finds the subitem texts based on the xpath' do
+    expect(parsed_result.more_details_text).to eq ['more 1', 'more 2']
   end
 
-  it 'should find the subitems based on the xpath' do
-    expect(subject.more_details.size).to eq(2)
-    expect(subject.more_details.first).to eq 'this one'
-    expect(subject.more_details.last).to eq 'another one'
+  it 'finds the subitem attributes based on the xpath' do
+    expect(parsed_result.more_details).to eq ['this one', 'another one']
   end
 
-  it 'should find the subitems based on the xpath' do
-    expect(subject.more_details_alternative.size).to eq(2)
-    expect(subject.more_details_alternative.first).to eq 'this one'
-    expect(subject.more_details_alternative.last).to eq 'another one'
+  it 'finds the subitem attributes based on the xpath with a wildcard' do
+    expect(parsed_result.more_details_alternative).to eq ['this one', 'another one']
   end
 
-  it 'should have a baby name' do
-    expect(subject.baby.name).to eq 'Jumbo'
+  it 'has a baby name' do
+    expect(parsed_result.baby.name).to eq 'Jumbo'
   end
 end

data/spec/happymapper/anonymous_mapper_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe HappyMapper::AnonymousMapper do
+  let(:anonymous_mapper) { described_class.new }
+
+  describe '#parse' do
+    context 'when parsing a single root node' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('address.xml') }
+
+      it 'creates the correct set of child elements on the element class' do
+        elements = parsed_result.class.elements
+        expect(elements.map(&:tag)).to eq %w(street housenumber postcode city country state)
+      end
+
+      it 'parses child elements' do
+        aggregate_failures do
+          expect(parsed_result.street).to eq('Milchstrasse')
+          expect(parsed_result.housenumber).to eq('23')
+          expect(parsed_result.postcode).to eq('26131')
+          expect(parsed_result.city).to eq('Oldenburg')
+        end
+      end
+
+      it 'does not create a content entry when the xml contents no text content' do
+        expect(parsed_result).not_to respond_to :content
+      end
+
+      it 'parses both the attributes and content when present' do
+        aggregate_failures do
+          expect(parsed_result.country.code).to eq('de')
+          expect(parsed_result.country.content).to eq('Germany')
+        end
+      end
+    end
+
+    context 'with element names with special characters' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('ambigous_items.xml') }
+
+      it 'creates accessor methods with similar names' do
+        expect(parsed_result.my_items.item).to be_kind_of Array
+      end
+    end
+
+    context 'with element names with camelCased elements and Capital Letters' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('subclass_namespace.xml') }
+
+      it 'parses camel-cased child elements correctly' do
+        aggregate_failures do
+          expect(parsed_result.photo.publish_options.author).to eq('Stephanie')
+          expect(parsed_result.gallery.photo.title).to eq('photo title')
+        end
+      end
+
+      it 'parses camel-cased child properties correctly' do
+        expect(parsed_result.publish_options.created_day).to eq('2011-01-14')
+      end
+    end
+
+    context 'with repeated elements with camel-cased names' do
+      let(:xml) do
+        <<~XML
+          <foo>
+            <fooBar>
+              <baz>Hello</baz>
+            </fooBar>
+            <fooBar>
+              <baz>Hi</baz>
+            </fooBar>
+          </foo>
+        XML
+      end
+      let(:parsed_result) { anonymous_mapper.parse xml }
+
+      it 'parses the repeated elements correctly' do
+        expect(parsed_result.foo_bar.map(&:baz)).to eq %w(Hello Hi)
+      end
+    end
+
+    context 'with elements with camelCased attribute names' do
+      let(:parsed_result) { anonymous_mapper.parse '<foo barBaz="quuz"/>' }
+
+      it 'parses attributes correctly' do
+        expect(parsed_result.bar_baz).to eq('quuz')
+      end
+    end
+
+    context 'with several elements nested deeply' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('ambigous_items.xml') }
+
+      it 'parses the entire relationship' do
+        expect(parsed_result.my_items.item.first.item.name).to eq('My first internal item')
+      end
+    end
+
+    context 'when parsing an that contains multiple elements with the same tag' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('multiple_primitives.xml') }
+
+      it "parses the elements as it would a 'has_many'" do
+        aggregate_failures do
+          expect(parsed_result.name).to eq('value')
+          expect(parsed_result.image).to eq(%w(image1 image2))
+        end
+      end
+    end
+
+    context 'when parsing xml with multiple namespaces' do
+      let(:parsed_result) { anonymous_mapper.parse fixture_file('subclass_namespace.xml') }
+
+      it 'parses the elements an values correctly' do
+        expect(parsed_result.title).to eq('article title')
+      end
+
+      it 'parses attribute names correctly' do
+        expect(parsed_result.name).to eq 'title'
+      end
+    end
+
+    context 'when parsing an element with a nested value element with a different namespace' do
+      let(:xml) do
+        <<~XML
+          <a:foo xmlns:a="http://foo.org/a" xmlns:b="http://foo.org/b">
+            <b:bar>Hello</b:bar>
+          </a:foo>
+        XML
+      end
+      let(:result) { anonymous_mapper.parse xml }
+
+      it 'parses the value elements correctly' do
+        expect(result.bar).to eq 'Hello'
+      end
+    end
+
+    context 'when parsing xml that uses the same tag for string and other elements' do
+      let(:xml) do
+        <<~XML
+          <foo>
+            <bar>
+              <baz>Hello</baz>
+            </bar>
+            <baz>
+              <qux>Hi</qux>
+            </baz>
+          </foo>
+        XML
+      end
+      let(:result) { anonymous_mapper.parse xml }
+
+      it 'parses both occurences of the tag correctly' do
+        aggregate_failures do
+          expect(result.bar.baz).to eq 'Hello'
+          expect(result.baz.qux).to eq 'Hi'
+        end
+      end
+    end
+  end
+end