nokogiri-happymapper 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75fd5c49ca6f39f746d0570dcf4b5cbcc53c983aeeb1d5198a4bb8108701fc46
-  data.tar.gz: 5e9106990b90654f2e93977381b3cd4a3901f79cdda533c2f2d6b452e67e95c8
+  metadata.gz: 20c74c3600aeae595d9851fdc864364df4af72d3b5ea1257cb7323a5f4032439
+  data.tar.gz: b1fe72afe90bebc42fe52130fe1d4fb6681815f9c9e79a9f8dccabf93f5e9003
 SHA512:
-  metadata.gz: 5bceafdb34f883e0980e914ff30bea0774436e9e105c1d89a25128f0e4bb7a1ddb17278bc971ee94578a83a399af4061ddc73813fc0edf46b5d5b35c8e6e48a0
-  data.tar.gz: 956560556fa3dbf7f111f61b4997645cc168f05ac8659c4f68fca2e30db8ab7e2a400ea18c6e13a35aeed81f4626d37e467e8fab116490945dd77269cfc1b4b0
+  metadata.gz: ab001b07e41193a760a37d87600f2020310aa4f753b1bdcca2fad7251a5ac50346267c61cce18a5d5fc20f3ec683a3f8b67a305de2183a5fb8b3187731f8eab8
+  data.tar.gz: db0cb626e8d21eaf4b388bdb414165dbcb6b63ab3d6c6c3f61077255983fa3ec833e10e223ad429a9162d669d0ede349010c9b8c123ad231e34b4949ee2c4288

data/CHANGELOG.md

@@ -1,16 +1,38 @@
 # Changelog
 
+## 0.8.0 / 2018-08-28
+
+### Breaking Changes
+
+* Ensure child elements only parse direct child nodes when parsing anonymously
+  ([#100](https://github.com/mvz/happymapper/pull/100))
+
+### Improvements
+
+* Improve documentation
+  ([#99](https://github.com/mvz/happymapper/pull/99))
+
+### Bug fixes
+
+* Handle repeated camel-cased elements as `has_many` when parsing anonymously
+  ([#101](https://github.com/mvz/happymapper/pull/101))
+* Avoid creating extra elements named `text` when parsing anonymously
+  ([#98](https://github.com/mvz/happymapper/pull/98))
+
 ## 0.7.0 / 2018-08-27
 
 ### Breaking Changes
 
-* Remove constant HappyMapper::DEFAULT_NS
+* Remove constant `HappyMapper::DEFAULT_NS`
+  ([#78](https://github.com/mvz/happymapper/pull/78))
 * Drop support for Ruby 2.2 and below
+  ([#80](https://github.com/mvz/happymapper/pull/80))
 
 ### Improvements
 
 * Support Ruby 2.5
 * Always sort namespaces. This adds support for JRuby.
+  ([#84](https://github.com/mvz/happymapper/pull/84))
 
 ### Bug fixes
 
@@ -28,7 +50,7 @@
 * Prevent parsing of empty string for Date, DateTime (wushugene)
 * Rescue nil dates (sarsena)
 * Preserve XML value (benoist)
-* Restore after_parse callback support (codekitchen)
+* Restore `after_parse` callback support (codekitchen)
 * Parse specific types before general types (Ivo Wever)
 * Higher priority for namespace on element declarations (Ivo Wever)
 
@@ -39,7 +61,7 @@
 ## 0.5.8 / 2013-10-12
 
 * Allow child elements to remove their parent's namespacing (dcarneiro)
-* has_many elements were returning nil because the tag name was being ignored (haarts)
+* `has_many` elements were returning nil because the tag name was being ignored (haarts)
 * Subclassed happymapper classes are allowed to override elements (benoist)
 * Attributes on elements with dashes will properly created methods (alex-klepa)
 * 'Embedded' attributes break parsing when parent element is not present (geoffwa)
@@ -56,8 +78,8 @@
 
 ## 0.5.4/ 2012-09-25
 
-* the #wrap method allows you to better model xml content that is buried deep
-  within the xml. This implementation addresses issues with calling #to_xml
+* the `#wrap` method allows you to better model xml content that is buried deep
+  within the xml. This implementation addresses issues with calling `#to_xml`
   with content that was parsed from an xpath. (zrob)
 
 * Parent HappyMapper classes may dictate the name of the tag for the child

data/README.md

@@ -41,13 +41,15 @@ Run Bundler to install the gem:
 Let's start with a simple example to get our feet wet. Here we have a simple
 example of XML that defines some address information:
 
-    <address>
-      <street>Milchstrasse</street>
-      <housenumber>23</housenumber>
-      <postcode>26131</postcode>
-      <city>Oldenburg</city>
-      <country code="de">Germany</country>
-    </address>
+```xml
+<address>
+  <street>Milchstrasse</street>
+  <housenumber>23</housenumber>
+  <postcode>26131</postcode>
+  <city>Oldenburg</city>
+  <country code="de">Germany</country>
+</address>
+```
 
 Happymapper provides support for simple, zero configuration parsing as well as
 the ability to model the XML content in classes.
@@ -168,14 +170,16 @@ will do that work for us inside of parse.
 What if our address XML was a little different, perhaps we allowed multiple
 streets:
 
-    <address>
-      <street>Milchstrasse</street>
-      <street>Another Street</street>
-      <housenumber>23</housenumber>
-      <postcode>26131</postcode>
-      <city>Oldenburg</city>
-      <country code="de">Germany</country>
-    </address>
+```xml
+<address>
+  <street>Milchstrasse</street>
+  <street>Another Street</street>
+  <housenumber>23</housenumber>
+  <postcode>26131</postcode>
+  <city>Oldenburg</city>
+  <country code="de">Germany</country>
+</address>
+```
 
 Similar to `element` or `has_one`, the declaration for when you have multiple
 elements you simply use:
@@ -222,14 +226,16 @@ the instance variable `@streets` if we ever need to the values as an array.
 
 ### Attribute Mapping
 
-    <address location='home'>
-      <street>Milchstrasse</street>
-      <street>Another Street</street>
-      <housenumber>23</housenumber>
-      <postcode>26131</postcode>
-      <city>Oldenburg</city>
-      <country code="de">Germany</country>
-    </address>
+```xml
+<address location='home'>
+  <street>Milchstrasse</street>
+  <street>Another Street</street>
+  <housenumber>23</housenumber>
+  <postcode>26131</postcode>
+  <city>Oldenburg</city>
+  <country code="de">Germany</country>
+</address>
+```
 
 Attributes are absolutely the same as `element` or `has_many`
 
@@ -242,13 +248,16 @@ of the attribute.
 
 #### Attributes On Empty Child Elements
 
-    <feed xml:lang="en-US" xmlns="http://www.w3.org/2005/Atom">
-      <id>tag:all-the-episodes.heroku.com,2005:/tv_shows</id>
-      <link rel="alternate" type="text/html" href="http://all-the-episodes.heroku.com"/>
-      <link rel="self" type="application/atom+xml" href="http://all-the-episodes.heroku.com/tv_shows.atom"/>
-      <title>TV Shows</title>
-      <updated>2011-07-10T06:52:27Z</updated>
-    </feed>
+```xml
+<feed xml:lang="en-US" xmlns="http://www.w3.org/2005/Atom">
+  <id>tag:all-the-episodes.heroku.com,2005:/tv_shows</id>
+  <link rel="alternate" type="text/html" href="http://all-the-episodes.heroku.com"/>
+  <link rel="self" type="application/atom+xml"
+        href="http://all-the-episodes.heroku.com/tv_shows.atom"/>
+  <title>TV Shows</title>
+  <updated>2011-07-10T06:52:27Z</updated>
+</feed>
+```
 
 In this case you would need to map an element to a new `Link` class just to
 access `<link>`s attributes, except that there is an alternate syntax. Instead
@@ -301,7 +310,8 @@ point we neglected it as we declared a `country` as being a `String`.
       <country code="de">Germany</country>
     </address>
 
-Well if we only going to parse country, on it's own, we would likely create a class mapping for it.
+Well if we only going to parse country, on it's own, we would likely create a
+class mapping for it.
 
 ```ruby
 class Country
@@ -318,7 +328,8 @@ We are utilizing an `attribute` declaration and a new declaration called `conten
 
 * `content` is used when you want the text contained within the element
 
-Awesome, now if we were to redeclare our `Address` class we would use our new `Country` class.
+Awesome, now if we were to redeclare our `Address` class we would use our new
+`Country` class.
 
 ```ruby
 class Address
@@ -361,19 +372,21 @@ are available when it comes time to parse you are golden.
 Getting to elements deep down within your XML can be a little more work if you
 did not have xpath support. Consider the following example:
 
-    <media>
-      <gallery>
-        <title href="htttp://fishlovers.org/friends">Friends Who Like Fish</title>
-        <picture>
-          <name>Burtie Sanchez</name>
-          <img>burtie01.png</img>
-        </picture>
-      </gallery>
-      <picture>
-        <name>Unsorted Photo</name>
-        <img>bestfriends.png</img>
-      </picture>
-    </media>
+```xml
+<media>
+  <gallery>
+    <title href="htttp://fishlovers.org/friends">Friends Who Like Fish</title>
+    <picture>
+      <name>Burtie Sanchez</name>
+      <img>burtie01.png</img>
+    </picture>
+  </gallery>
+  <picture>
+    <name>Unsorted Photo</name>
+    <img>bestfriends.png</img>
+  </picture>
+</media>
+```
 
 You may want to map the sub-elements contained buried in the 'gallery' as top
 level items in the media. Traditionally you could use class composition to
@@ -484,24 +497,25 @@ opportunity to do some surgery and define our happymapper elements as well as
 any other methods that may rely on those instance variables that come along in
 the package.
 
-
 ### Filtering with XPATH (non-greedy)
 
 I ran into a case where I wanted to capture all the pictures that were directly
 under media, but not the ones contained within a gallery.
 
-    <media>
-      <gallery>
-        <picture>
-          <name>Burtie Sanchez</name>
-          <img>burtie01.png</img>
-        </picture>
-      </gallery>
-      <picture>
-        <name>Unsorted Photo</name>
-        <img>bestfriends.png</img>
-      </picture>
-    </media>
+```xml
+<media>
+  <gallery>
+    <picture>
+      <name>Burtie Sanchez</name>
+      <img>burtie01.png</img>
+    </picture>
+  </gallery>
+  <picture>
+    <name>Unsorted Photo</name>
+    <img>bestfriends.png</img>
+  </picture>
+</media>
+```
 
 The following `Media` class is where I started:
 
@@ -538,7 +552,6 @@ has_many :pictures, Picture, tag: 'picture', xpath: '.'
 `.` states that we are only interested in pictures that can be found directly
 under the current node. So when we parse again we will have only our one element.
 
-
 ### Namespaces
 
 Obviously your XML and these trivial examples are easy to map and parse because
@@ -588,15 +601,18 @@ declaration is important and that is when it has a different namespace than
 
 Imagine that our `country` actually belonged to a completely different namespace.
 
-    <prefix:address location='home' xmlns:prefix="http://www.unicornland.com/prefix"
-    xmlns:different="http://www.trollcountry.com/different">
-      <prefix:street>Milchstrasse</prefix:street>
-      <prefix:street>Another Street</prefix:street>
-      <prefix:housenumber>23</prefix:housenumber>
-      <prefix:postcode>26131</prefix:postcode>
-      <prefix:city>Oldenburg</prefix:city>
-      <different:country code="de">Germany</different:country>
-    </prefix:address>
+```xml
+<prefix:address location='home'
+                xmlns:prefix="http://www.unicornland.com/prefix"
+                xmlns:different="http://www.trollcountry.com/different">
+  <prefix:street>Milchstrasse</prefix:street>
+  <prefix:street>Another Street</prefix:street>
+  <prefix:housenumber>23</prefix:housenumber>
+  <prefix:postcode>26131</prefix:postcode>
+  <prefix:city>Oldenburg</prefix:city>
+  <different:country code="de">Germany</different:country>
+</prefix:address>
+```
 
 Well we would need to specify that namespace:
 
@@ -606,7 +622,7 @@ element :country, Country, tag: 'country', namespace: 'different'
 
 With that we should be able to parse as we once did.
 
-### Large Datasets (in_groups_of)
+### Large Datasets (`:in_groups_of`)
 
 When dealing with large sets of XML that simply cannot or should not be placed
 into memory the objects can be handled in groups through the `:in_groups_of`

data/lib/happymapper.rb

@@ -10,7 +10,9 @@ module HappyMapper
   class Boolean; end
   class XmlContent; end
 
-  extend AnonymousMapper
+  def self.parse(xml_content)
+    AnonymousMapper.new.parse(xml_content)
+  end
 
   def self.included(base)
     if base.superclass <= HappyMapper
@@ -282,15 +284,13 @@ module HappyMapper
     #
     # @param [Nokogiri::XML::Node,Nokogiri:XML::Document,String] xml the XML
     #     contents to convert into Object.
-    # @param [Hash] options additional information for parsing. :single => true
-    #     if requesting a single object, otherwise it defaults to retuning an
-    #     array of multiple items. :xpath information where to start the parsing
+    # @param [Hash] options additional information for parsing.
+    #     :single => true if requesting a single object, otherwise it defaults
+    #     to retuning an array of multiple items.
+    #     :xpath information where to start the parsing
     #     :namespace is the namespace to use for additional information.
     #
     def parse(xml, options = {})
-      # create a local copy of the objects namespace value for this parse execution
-      namespace = (@namespace if defined? @namespace)
-
       # Capture any provided namespaces and merge in any namespaces that have
       # been registered on the object.
       namespaces = options[:namespaces] || {}
@@ -323,15 +323,15 @@ module HappyMapper
         root = node.name == tag_name
       end
 
+      # If the :single option has been specified or we are at the root element
+      # then we are going to return a single element or nil if no nodes are found
+      single = root || options[:single]
+
       # if a namespace has been provided then set the current namespace to it
-      # or set the default namespace to the one defined under 'xmlns'
-      # or set the default namespace to the namespace that matches 'happymapper's
+      # or use the namespace provided by the class
+      # or use the 'xmlns' namespace if defined
 
-      if options[:namespace]
-        namespace = options[:namespace]
-      elsif namespaces.has_key?('xmlns')
-        namespace ||= 'xmlns'
-      end
+      namespace = options[:namespace] || self.namespace || namespaces.key?('xmlns') && 'xmlns'
 
       # from the options grab any nodes present and if none are present then
       # perform the following to find the nodes for the given class
@@ -341,7 +341,7 @@ module HappyMapper
       end
 
       # Nothing matching found, we can go ahead and return
-      return (options[:single] || root ? nil : []) if nodes.size == 0
+      return (single ? nil : []) if nodes.empty?
 
       # If the :limit option has been specified then we are going to slice
       # our node results by that amount to allow us the ability to deal with
@@ -372,11 +372,11 @@ module HappyMapper
         end
       end
 
-      # If the :single option has been specified or we are at the root element
-      # then we are going to return the first item in the collection. Otherwise
-      # the return response is going to be an entire array of items.
+      # If we're parsing a single element then we are going to return the first
+      # item in the collection. Otherwise the return response is going to be an
+      # entire array of items.
 
-      if options[:single] || root
+      if single
         collection.first
       else
         collection
@@ -396,8 +396,13 @@ module HappyMapper
       # and finally attach the current namespace if one has been defined
       #
 
-      xpath  = (root ? '/' : './/')
-      xpath  = options[:xpath].to_s.sub(/([^\/])$/, '\1/') if options[:xpath]
+      xpath = if options[:xpath]
+                options[:xpath].to_s.sub(%r{([^/])$}, '\1/')
+              elsif root
+                '/'
+              else
+                './/'
+              end
       if namespace
         return [] unless namespaces.find { |name, _url| ["xmlns:#{namespace}", namespace].include? name }
         xpath += "#{namespace}:"
@@ -646,7 +651,7 @@ module HappyMapper
         # Attributes that have a nil value should be ignored unless they explicitly
         # state that they should be expressed in the output.
         #
-        if not value.nil? || attribute.options[:state_when_nil]
+        if !(value.nil? || attribute.options[:state_when_nil])
           attribute_namespace = attribute.options[:namespace]
           ["#{attribute_namespace ? "#{attribute_namespace}:" : ''}#{attribute.tag}", value]
         else

data/lib/happymapper/anonymous_mapper.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 module HappyMapper
-  module AnonymousMapper
+  class AnonymousMapper
     def parse(xml_content)
       # TODO: this should be able to handle all the types of functionality that parse is able
       #   to handle which includes the text, xml document, node, fragment, etc.
       xml = Nokogiri::XML(xml_content)
 
-      happymapper_class = create_happymapper_class_with_element(xml.root)
+      klass = create_happymapper_class_from_node(xml.root)
 
       # With all the elements and attributes defined on the class it is time
       # for the class to actually use the normal HappyMapper powers to parse
       # the content. At this point this code is utilizing all of the existing
       # code implemented for parsing.
-      happymapper_class.parse(xml_content, single: true)
+      klass.parse(xml_content, single: true)
     end
 
     private
@@ -38,75 +38,80 @@ module HappyMapper
     # value is set to the one provided.
     #
     def create_happymapper_class_with_tag(tag_name)
-      happymapper_class = Class.new
-      happymapper_class.class_eval do
+      klass = Class.new
+      klass.class_eval do
         include HappyMapper
         tag tag_name
       end
-      happymapper_class
+      klass
     end
 
     #
     # Used internally to create and define the necessary happymapper
     # elements.
     #
-    def create_happymapper_class_with_element(element)
-      happymapper_class = create_happymapper_class_with_tag(element.name)
+    def create_happymapper_class_from_node(node)
+      klass = create_happymapper_class_with_tag(node.name)
 
-      happymapper_class.namespace element.namespace.prefix if element.namespace
+      klass.namespace node.namespace.prefix if node.namespace
 
-      element.namespaces.each do |prefix, namespace|
-        happymapper_class.register_namespace prefix, namespace
+      node.namespaces.each do |prefix, namespace|
+        klass.register_namespace prefix, namespace
       end
 
-      element.attributes.each_value do |attribute|
-        define_attribute_on_class(happymapper_class, attribute)
+      node.attributes.each_value do |attribute|
+        define_attribute_on_class(klass, attribute)
       end
 
-      element.children.each do |child|
-        define_element_on_class(happymapper_class, child)
+      node.children.each do |child|
+        define_element_on_class(klass, child)
       end
 
-      happymapper_class
+      klass
     end
 
     #
     # Define a HappyMapper element on the provided class based on
-    # the element provided.
+    # the node provided.
     #
-    def define_element_on_class(class_instance, element)
-      # When a text element has been provided create the necessary
+    def define_element_on_class(klass, node)
+      # When a text node has been provided create the necessary
       # HappyMapper content attribute if the text happens to contain
       # some content.
 
-      class_instance.content :content, String if element.text? && (element.content.strip != '')
+      if node.text?
+        klass.content :content, String if node.content.strip != ''
+        return
+      end
 
-      # When the element has children elements, that are not text
-      # elements, then we want to recursively define a new HappyMapper
+      # When the node has child elements, that are not text
+      # nodes, then we want to recursively define a new HappyMapper
       # class that will have elements and attributes.
 
-      element_type = if !element.elements.reject(&:text?).empty? || !element.attributes.empty?
-                       create_happymapper_class_with_element(element)
+      element_type = if node.elements.any? || node.attributes.any?
+                       create_happymapper_class_from_node(node)
                      else
                        String
                      end
 
-      method = class_instance.elements.find { |e| e.name == element.name } ? :has_many : :has_one
+      element_name = underscore(node.name)
+      method = klass.elements.find { |e| e.name == element_name } ? :has_many : :has_one
 
       options = {}
-      options[:tag] = element.name
-      namespace = element.namespace
+      options[:tag] = node.name
+      namespace = node.namespace
       options[:namespace] = namespace.prefix if namespace
+      options[:xpath] = './' unless element_type == String
 
-      class_instance.send(method, underscore(element.name), element_type, options)
+      klass.send(method, element_name, element_type, options)
     end
 
     #
     # Define a HappyMapper attribute on the provided class based on
     # the attribute provided.
     #
-    def define_attribute_on_class(class_instance, attribute)
-      class_instance.attribute underscore(attribute.name), String, tag: attribute.name
+    def define_attribute_on_class(klass, attribute)
+      klass.attribute underscore(attribute.name), String, tag: attribute.name
     end
   end
 end