nokogiri-happymapper 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f94968fd78baee9196d17340ee0fa5731c6f6fd1
-  data.tar.gz: 7ca5b00acc1126a265473d583ee331beb00a50e0
+SHA256:
+  metadata.gz: 75fd5c49ca6f39f746d0570dcf4b5cbcc53c983aeeb1d5198a4bb8108701fc46
+  data.tar.gz: 5e9106990b90654f2e93977381b3cd4a3901f79cdda533c2f2d6b452e67e95c8
 SHA512:
-  metadata.gz: e1d779907f83b14a9b392d4dbcca7515dbda14bc8e9932b48a78cbaf7924df5e65adef12454c294947a7e86167dca1866900133985da9ed6cc14bf57fb392e37
-  data.tar.gz: 5205073663f778a8b699d4d54aa63a1d171f12ee300cbc991bd7e3fb4ee2cc252fc2d4540b270ecadb75e0567bf8abceda913dae822f6c9f103275fe70822785
+  metadata.gz: 5bceafdb34f883e0980e914ff30bea0774436e9e105c1d89a25128f0e4bb7a1ddb17278bc971ee94578a83a399af4061ddc73813fc0edf46b5d5b35c8e6e48a0
+  data.tar.gz: 956560556fa3dbf7f111f61b4997645cc168f05ac8659c4f68fca2e30db8ab7e2a400ea18c6e13a35aeed81f4626d37e467e8fab116490945dd77269cfc1b4b0

data/CHANGELOG.md

@@ -1,4 +1,29 @@
-## 0.6.0 / Unreleased
+# Changelog
+
+## 0.7.0 / 2018-08-27
+
+### Breaking Changes
+
+* Remove constant HappyMapper::DEFAULT_NS
+* Drop support for Ruby 2.2 and below
+
+### Improvements
+
+* Support Ruby 2.5
+* Always sort namespaces. This adds support for JRuby.
+
+### Bug fixes
+
+* Ensure `#to_xml` generates UTF-8 content
+  ([#88](https://github.com/mvz/happymapper/pull/88))
+* Handle namespaces for nested value elements when parsing anonymously
+  ([#87](https://github.com/mvz/happymapper/pull/87))
+* Handle attributes with a namespace that is different from the element
+  namespace ([#87](https://github.com/mvz/happymapper/pull/87))
+* Ensure camel-cased elements have content in anonymous parse
+  ([#85](https://github.com/mvz/happymapper/pull/85))
+
+## 0.6.0 / 2017-09-17
 
 * Prevent parsing of empty string for Date, DateTime (wushugene)
 * Rescue nil dates (sarsena)

data/README.md

@@ -1,11 +1,17 @@
-HappyMapper
-===========
+# HappyMapper
 
-Happymapper allows you to parse XML data and convert it quickly and easily into ruby data structures.
+Happymapper allows you to parse XML data and convert it quickly and easily into
+ruby data structures.
 
 This project is a fork of the great work done first by
 [jnunemaker](https://github.com/jnunemaker/happymapper).
 
+[![Gem Version](https://badge.fury.io/rb/nokogiri-happymapper.svg)](https://badge.fury.io/rb/nokogiri-happymapper)
+[![Build Status](https://travis-ci.org/mvz/happymapper.svg?branch=master)](https://travis-ci.org/mvz/happymapper)
+[![Coverage Status](https://coveralls.io/repos/github/mvz/happymapper/badge.svg?branch=master)](https://coveralls.io/github/mvz/happymapper?branch=master)
+[![Depfu](https://badges.depfu.com/badges/1707c8c2322e2ed267cf88bd4fb12b66/overview.svg)](https://depfu.com/github/mvz/happymapper)
+[![Maintainability](https://api.codeclimate.com/v1/badges/491015f82bd2a45fd9d3/maintainability)](https://codeclimate.com/github/mvz/happymapper/maintainability)
+
 ## Major Differences
 
   * [Nokogiri](http://nokogiri.org/) support
@@ -13,26 +19,27 @@ This project is a fork of the great work done first by
   * Raw XML content parsing
   * `#to_xml` support utilizing the same HappyMapper tags
   * Numerous fixes for namespaces when using composition of classes
-  * Fixes for instances of XML where a namespace is defined but no elements with that namespace are found
+  * Fixes for instances of XML where a namespace is defined but no elements
+    with that namespace are found
 
 ## Installation
 
-### [Rubygems](https://rubyygems.org/gems/nokogiri-happymapper)
+Install via rubygems:
 
     $ gem install nokogiri-happymapper
 
-### [Bundler](http://gembundler.com/)
-Add the `nokogiri-happymapper` gem to your project's `Gemfile`.
+Or add the `nokogiri-happymapper` gem to your project's `Gemfile`.
 
-    gem 'nokogiri-happymapper', :require => 'happymapper'
+    gem 'nokogiri-happymapper', require: 'happymapper'
 
-Run the bundler command to install the gem:
+Run Bundler to install the gem:
 
     $ bundle install
 
-# Examples
+## Examples
 
-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:
+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>
@@ -42,11 +49,13 @@ Let's start with a simple example to get our feet wet. Here we have a simple exa
       <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.
+Happymapper provides support for simple, zero configuration parsing as well as
+the ability to model the XML content in classes.
 
-## HappyMapper.parse(XML)
+### HappyMapper.parse(XML)
 
-With no classes or configuration you can parse the example XML with little effort:
+With no classes or configuration you can parse the example XML with little
+effort:
 
 ```ruby
 address = HappyMapper.parse(ADDRESS_XML_DATA)
@@ -60,11 +69,14 @@ address.country.content # => Germany
 
 It is important to be aware that this no configuration parsing is limited in capacity:
 
-* All element names are converted to accessor methods with [underscorized](http://rubydoc.info/gems/activesupport/ActiveSupport/Inflector:underscore) names
+* All element names are converted to accessor methods with
+  [underscorized](http://rubydoc.info/gems/activesupport/ActiveSupport/Inflector:underscore)
+  names
 * All value fields are left as String types
-* Determining if there is just one or multiple child elements is hard, so it assumes it is one until it finds another with the same name.
+* Determining if there is just one or multiple child elements is hard, so it
+  assumes it is one until it finds another with the same name.
 
-## Address.parse(XML)
+### Address.parse(XML)
 
 Happymapper will let you easily model this information as a class:
 
@@ -75,64 +87,86 @@ class Address
   include HappyMapper
 
   tag 'address'
-  element :street, String, :tag => 'street'
-  element :postcode, String, :tag => 'postcode'
-  element :housenumber, Integer, :tag => 'housenumber'
-  element :city, String, :tag => 'city'
-  element :country, String, :tag => 'country'
+  element :street, String, tag: 'street'
+  element :postcode, String, tag: 'postcode'
+  element :housenumber, Integer, tag: 'housenumber'
+  element :city, String, tag: 'city'
+  element :country, String, tag: 'country'
 end
 ```
 
-To make a class HappyMapper compatible you simply `include HappyMapper` within the class definition. This takes care of all the work of defining all the speciality methods and magic you need to get running. As you can see we immediately start using these methods.
+To make a class HappyMapper compatible you simply `include HappyMapper` within
+the class definition. This takes care of all the work of defining all the
+speciality methods and magic you need to get running. As you can see we
+immediately start using these methods.
 
 * `tag` matches the name of the XML tag name 'address'.
 
-* `element` defines accessor methods for the specified symbol (e.g. `:street`,`:housenumber`) that will return the class type (e.g. `String`,`Integer`) of the XML tag specified (e.g. `:tag => 'street'`, `:tag => 'housenumber'`).
+* `element` defines accessor methods for the specified symbol
+  (e.g. `:street`,`:housenumber`) that will return the class type
+  (e.g. `String`,`Integer`) of the XML tag specified
+  (e.g. `tag: 'street'`, `tag: 'housenumber'`).
 
-When you define an element with an accessor with the same name as the tag, this is the case for all the examples above, you can omit the `:tag`. These two element declaration are equivalent to each other:
+When you define an element with an accessor with the same name as the tag, this
+is the case for all the examples above, you can omit the `:tag`. These two
+element declaration are equivalent to each other:
 
 ```ruby
-element :street, String, :tag => 'street'
+element :street, String, tag: 'street'
 element :street, String
 ```
 
-Including the additional tag element is not going to hurt anything and in some cases will make it absolutely clear how these elements map to the XML. However, once you know this rule, it is hard not to want to save yourself the keystrokes.
+Including the additional tag element is not going to hurt anything and in some
+cases will make it absolutely clear how these elements map to the XML. However,
+once you know this rule, it is hard not to want to save yourself the
+keystrokes.
 
 Instead of `element` you may also use `has_one`:
 
 ```ruby
-element :street, String, :tag => 'street'
+element :street, String, tag: 'street'
 element :street, String
 has_one :street, String
 ```
 
 These three statements are equivalent to each other.
 
-## Parsing
+### Parsing
 
-With the mapping of the address XML articulated in our Address class it is time to parse the data:
+With the mapping of the address XML articulated in our Address class it is time
+to parse the data:
 
 ```ruby
-address = Address.parse(ADDRESS_XML_DATA, :single => true)
+address = Address.parse(ADDRESS_XML_DATA, single: true)
 puts address.street
 ```
 
-Assuming that the constant `ADDRESS_XML_DATA` contains a string representation of the address XML data this is fairly straight-forward save for the `parse` method.
+Assuming that the constant `ADDRESS_XML_DATA` contains a string representation
+of the address XML data this is fairly straight-forward save for the `parse`
+method.
 
-The `parse` method, like `tag` and `element` are all added when you included HappyMapper in the class. Parse is a wonderful, magical place that converts all these declarations that you have made into the data structure you are about to know and love.
+The `parse` method, like `tag` and `element` are all added when you included
+HappyMapper in the class. Parse is a wonderful, magical place that converts all
+these declarations that you have made into the data structure you are about to
+know and love.
 
-But what about the `:single => true`? Right, that is because by default when your object is all done parsing it will be an array. In this case an array with one element, but an array none the less. So the following are equivalent to each other:
+But what about the `single: true`? Right, that is because by default when
+your object is all done parsing it will be an array. In this case an array with
+one element, but an array none the less. So the following are equivalent to
+each other:
 
 ```ruby
 address = Address.parse(ADDRESS_XML_DATA).first
-address = Address.parse(ADDRESS_XML_DATA, :single => true)
+address = Address.parse(ADDRESS_XML_DATA, single: true)
 ```
 
-The first one returns an array and we return the first instance, the second will do that work for us inside of parse.
+The first one returns an array and we return the first instance, the second
+will do that work for us inside of parse.
 
-## Multiple Elements Mapping
+### Multiple Elements Mapping
 
-What if our address XML was a little different, perhaps we allowed multiple streets:
+What if our address XML was a little different, perhaps we allowed multiple
+streets:
 
     <address>
       <street>Milchstrasse</street>
@@ -143,20 +177,23 @@ What if our address XML was a little different, perhaps we allowed multiple stre
       <country code="de">Germany</country>
     </address>
 
-Similar to `element` or `has_one`, the declaration for when you have multiple elements you simply use:
+Similar to `element` or `has_one`, the declaration for when you have multiple
+elements you simply use:
 
 ```ruby
-has_many :streets, String, :tag => 'street'
+has_many :streets, String, tag: 'street'
 ```
 
 Your resulting `streets` method will now return an array.
 
 ```ruby
-address = Address.parse(ADDRESS_XML_DATA, :single => true)
+address = Address.parse(ADDRESS_XML_DATA, single: true)
 puts address.streets.join('\n')
 ```
 
-Imagine that you have to write `streets.join('\n')` for the rest of eternity throughout your code. It would be a nightmare and one that you could avoid by creating your own convenience method.
+Imagine that you have to write `streets.join('\n')` for the rest of eternity
+throughout your code. It would be a nightmare and one that you could avoid by
+creating your own convenience method.
 
 ```ruby
 require 'happymapper'
@@ -172,17 +209,18 @@ class Address
     @streets.join('\n')
   end
 
-  element :postcode, String, :tag => 'postcode'
-  element :housenumber, String, :tag => 'housenumber'
-  element :city, String, :tag => 'city'
-  element :country, String, :tag => 'country'
+  element :postcode, String, tag: 'postcode'
+  element :housenumber, String, tag: 'housenumber'
+  element :city, String, tag: 'city'
+  element :country, String, tag: 'country'
 end
 ```
 
-Now when we call the method `streets` we get a single value, but we still have the instance variable `@streets` if we ever need to the values as an array.
+Now when we call the method `streets` we get a single value, but we still have
+the instance variable `@streets` if we ever need to the values as an array.
 
 
-## Attribute Mapping
+### Attribute Mapping
 
     <address location='home'>
       <street>Milchstrasse</street>
@@ -196,13 +234,13 @@ Now when we call the method `streets` we get a single value, but we still have t
 Attributes are absolutely the same as `element` or `has_many`
 
 ```ruby
-attribute :location, String, :tag => 'location
+attribute :location, String, tag: 'location
 ```
 
-Again, you can omit the tag if the attribute accessor symbol matches the name of the attribute.
-
+Again, you can omit the tag if the attribute accessor symbol matches the name
+of the attribute.
 
-### Attributes On Empty Child Elements
+#### 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>
@@ -212,12 +250,14 @@ Again, you can omit the tag if the attribute accessor symbol matches the name of
       <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 of
+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
+of
 
 ```ruby
 class Feed
   # ....
-  has_many :links, Link, :tag => 'link', :xpath => '.'
+  has_many :links, Link, tag: 'link', xpath: '.'
 end
 
 class Link
@@ -232,17 +272,25 @@ end
 You can drop the `Link` class and simply replace the `has_many` on `Feed` with
 
 ```ruby
-element :link, String, :single => false, :attributes => { :rel => String, :type => String, :href => String }
+element :link, String, single: false, attributes: { rel: String, type: String, href: String }
 ```
 
-As there is no content, the type given for `:link` (`String` above) is irrelevant, but `nil` won't work and other types may try to perform typecasting and fail. You can omit the :single => false for elements that only occur once within their parent.
+As there is no content, the type given for `:link` (`String` above) is
+irrelevant, but `nil` won't work and other types may try to perform typecasting
+and fail. You can omit the single: false for elements that only occur once
+within their parent.
 
-This syntax is most appropriate for elements that (a) have attributes but no content and (b) only occur at only one level of the heirarchy. If `<feed>` contained another element that also contained a `<link>` (as atom feeds generally do) it would be DRY-er to use the first syntax, i.e. with a separate `Link` class.
+This syntax is most appropriate for elements that (a) have attributes but no
+content and (b) only occur at only one level of the heirarchy. If `<feed>`
+contained another element that also contained a `<link>` (as atom feeds
+generally do) it would be DRY-er to use the first syntax, i.e. with a separate
+`Link` class.
 
 
-## Class composition (and Text Node)
+### Class composition (and Text Node)
 
-Our address has a country and that country element has a code. Up until this point we neglected it as we declared a `country` as being a `String`.
+Our address has a country and that country element has a code. Up until this
+point we neglected it as we declared a `country` as being a `String`.
 
     <address location='home'>
       <street>Milchstrasse</street>
@@ -278,33 +326,40 @@ class Address
 
   tag 'address'
 
-  has_many :streets, String, :tag => 'street'
+  has_many :streets, String, tag: 'street'
 
   def streets
     @streets.join('\n')
   end
 
-  element :postcode, String, :tag => 'postcode'
-  element :housenumber, String, :tag => 'housenumber'
-  element :city, String, :tag => 'city'
-  element :country, Country, :tag => 'country'
+  element :postcode, String, tag: 'postcode'
+  element :housenumber, String, tag: 'housenumber'
+  element :city, String, tag: 'city'
+  element :country, Country, tag: 'country'
 end
 ```
 
-Instead of `String`, `Boolean`, or `Integer` we say that it is a `Country` and HappyMapper takes care of the details of continuing the XML mapping through the country element.
+Instead of `String`, `Boolean`, or `Integer` we say that it is a `Country` and
+HappyMapper takes care of the details of continuing the XML mapping through the
+country element.
 
 ```ruby
-address = Address.parse(ADDRESS_XML_DATA, :single => true)
+address = Address.parse(ADDRESS_XML_DATA, single: true)
 puts address.country.code
 ```
 
-A quick note, in the above example we used the constant `Country`. We could have used `'Country'`. The nice part of using the latter declaration, enclosed in quotes, is that you do not have to define your class before this class. So Country and Address can live in separate files and as long as both constants are available when it comes time to parse you are golden.
+A quick note, in the above example we used the constant `Country`. We could
+have used `'Country'`. The nice part of using the latter declaration, enclosed
+in quotes, is that you do not have to define your class before this class. So
+Country and Address can live in separate files and as long as both constants
+are available when it comes time to parse you are golden.
 
-## Custom XPATH
+### Custom XPATH
 
-### Has One, Has Many
+#### Has One, Has Many
 
-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:
+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>
@@ -320,22 +375,26 @@ Getting to elements deep down within your XML can be a little more work if you d
       </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 accomplish this task, however, using the xpath attribute you have the ability to shortcut some of that work.
+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
+accomplish this task, however, using the xpath attribute you have the ability
+to shortcut some of that work.
 
 ```ruby
 class Media
   include HappyMapper
 
-  has_one :title, String, :xpath => 'gallery/title'
-  has_one :link, String, :xpath => 'gallery/title/@href'
+  has_one :title, String, xpath: 'gallery/title'
+  has_one :link, String, xpath: 'gallery/title/@href'
 end
 ```
 
-## Shared Functionality
+### Shared Functionality
 
-### Inheritance Approach
+#### Inheritance Approach
 
-While mapping XML to objects you may arrive at a point where you have two or more very similar structures.
+While mapping XML to objects you may arrive at a point where you have two or
+more very similar structures.
 
 ```ruby
 class Article
@@ -361,7 +420,9 @@ class Gallery
 end
 ```
 
-In this example there are definitely two similarities between our two pieces of content. So much so that you might be included to create an inheritance structure to save yourself some keystrokes.
+In this example there are definitely two similarities between our two pieces of
+content. So much so that you might be included to create an inheritance
+structure to save yourself some keystrokes.
 
 ```ruby
 class Content
@@ -385,7 +446,7 @@ class Gallery < Content
 end
 ```
 
-### Module Mixins Approach
+#### Module Mixins Approach
 
 You can also solve the above problem through mixins.
 
@@ -417,12 +478,17 @@ class Gallery
 end
 ```
 
-Here, when we include `Content` in both of these classes the module method `#included` is called and our class is given as a parameter. So we take that 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.
+Here, when we include `Content` in both of these classes the module method
+`#included` is called and our class is given as a parameter. So we take that
+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)
+### 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.
+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>
@@ -445,15 +511,15 @@ require 'happymapper'
 class Media
   include HappyMapper
 
-  has_many :galleries, Gallery, :tag => 'gallery'
-  has_many :pictures, Picture, :tag => 'picture'
+  has_many :galleries, Gallery, tag: 'gallery'
+  has_many :pictures, Picture, tag: 'picture'
 end
 ```
 
 However when I parsed the media xml the number of pictures returned to me was 2, not 1.
 
 ```ruby
-pictures = Media.parse(MEDIA_XML,:single => true).pictures
+pictures = Media.parse(MEDIA_XML,single: true).pictures
 pictures.length.should == 1   # => Failed Expectation
 ```
 
@@ -466,16 +532,17 @@ To limit an element from being greedy and only finding elements at the
 level of the current node you can specify an XPATH.
 
 ```ruby
-has_many :pictures, Picture, :tag => 'picture', :xpath => '.'
+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
+### Namespaces
 
-Obviously your XML and these trivial examples are easy to map and parse because they lack the treacherous namespaces that befall most XML files.
+Obviously your XML and these trivial examples are easy to map and parse because
+they lack the treacherous namespaces that befall most XML files.
 
 Perhaps our `address` XML is really swarming with namespaces:
 
@@ -488,7 +555,10 @@ Perhaps our `address` XML is really swarming with namespaces:
       <prefix:country code="de">Germany</prefix:country>
     </prefix:address>
 
-Here again is our address example with a made up namespace called `prefix` that comes direct to use from unicornland, a very magical place indeed. Well we are going to have to do some work on our class definition and that simply adding this one liner to the `Address` class:
+Here again is our address example with a made up namespace called `prefix` that
+comes direct to use from unicornland, a very magical place indeed. Well we are
+going to have to do some work on our class definition and that simply adding
+this one liner to the `Address` class:
 
 ```ruby
 class Address
@@ -500,17 +570,21 @@ class Address
 end
 ```
 
-Of course, if that is too easy for you, you can append a `:namespace => 'prefix` to every one of the elements that you defined.
+Of course, if that is too easy for you, you can append a `namespace: 'prefix`
+to every one of the elements that you defined.
 
 ```ruby
-has_many :street, String, :tag => 'street', :namespace => 'prefix'
-element :postcode, String, :tag => 'postcode', :namespace => 'prefix'
-element :housenumber, String, :tag => 'housenumber', :namespace => 'prefix'
-element :city, String, :tag => 'city', :namespace => 'prefix'
-element :country, Country, :tag => 'country', :namespace => 'prefix'
+has_many :street, String, tag: 'street', namespace: 'prefix'
+element :postcode, String, tag: 'postcode', namespace: 'prefix'
+element :housenumber, String, tag: 'housenumber', namespace: 'prefix'
+element :city, String, tag: 'city', namespace: 'prefix'
+element :country, Country, tag: 'country', namespace: 'prefix'
 ```
 
-I definitely recommend the former, as it saves you a whole hell of lot of typing. However, there are times when appending a namespace to an element declaration is important and that is when it has a different namespace then `namespsace 'prefix'`.
+I definitely recommend the former, as it saves you a whole hell of lot of
+typing. However, there are times when appending a namespace to an element
+declaration is important and that is when it has a different namespace than
+`namespace 'prefix'`.
 
 Imagine that our `country` actually belonged to a completely different namespace.
 
@@ -527,63 +601,76 @@ Imagine that our `country` actually belonged to a completely different namespace
 Well we would need to specify that namespace:
 
 ```ruby
-element :country, Country, :tag => 'country', :namespace => 'different'
+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` parameter.
+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`
+parameter.
 
 ```ruby
-Address.parse(LARGE_ADDRESS_XML_DATA,:in_groups_of => 5) do |group|
+Address.parse(LARGE_ADDRESS_XML_DATA,in_groups_of: 5) do |group|
   puts address.streets
 end
 ```
 
-This trivial block will parse the large set of XML data and in groups of 5 addresses at a time display the streets.
+This trivial block will parse the large set of XML data and in groups of 5
+addresses at a time display the streets.
 
-## Saving to XML
+### Saving to XML
 
-Saving a class to XML is as easy as calling `#to_xml`.  The end result will be the current state of your object represented as xml. Let's cover some details that are sometimes necessary and features present to make your life easier.
+Saving a class to XML is as easy as calling `#to_xml`.  The end result will be
+the current state of your object represented as xml. Let's cover some details
+that are sometimes necessary and features present to make your life easier.
 
 
-### :on_save
+#### :on_save
 
-When you are saving data to xml it is often important to change or manipulate data to a particular format. For example, a time object:
+When you are saving data to xml it is often important to change or manipulate
+data to a particular format. For example, a time object:
 
 ```ruby
-has_one :published_time, Time, :on_save => lambda {|time| time.strftime("%H:%M:%S") if time }
+has_one :published_time, Time, on_save: lambda {|time| time.strftime("%H:%M:%S") if time }
 ```
 
-Here we add the options `:on_save` and specify a lambda which will be executed on the method call to `:published_time`.
+Here we add the options `:on_save` and specify a lambda which will be executed
+on the method call to `:published_time`.
 
-### :state_when_nil
+#### :state_when_nil
 
-When an element contains a nil value, or perhaps the result of the :on_save lambda correctly results in a nil value you will be happy that the element will not appear in the resulting XML. However, there are time when you will want to see that element and that's when `:state_when_nil` is there for you.
+When an element contains a nil value, or perhaps the result of the :on_save
+lambda correctly results in a nil value you will be happy that the element will
+not appear in the resulting XML. However, there are time when you will want to
+see that element and that's when `:state_when_nil` is there for you.
 
 ```ruby
-has_one :favorite_color, String, :state_when_nil => true
+has_one :favorite_color, String, state_when_nil: true
 ```
 
-The resulting XML will include the 'favorite_color' element even if the favorite color has not been specified.
+The resulting XML will include the 'favorite_color' element even if the
+favorite color has not been specified.
 
-### :read_only
+#### :read_only
 
 When an element, attribute, or text node is a value that you have no interest in
 saving to XML, you can ensure that takes place by stating that it is `read only`.
 
 ```ruby
-has_one :modified, Boolean, :read_only => true
-attribute :temporary, Boolean, :read_only => true
+has_one :modified, Boolean, read_only: true
+attribute :temporary, Boolean, read_only: true
 ```
 
 This is useful if perhaps the incoming XML is different than the out-going XML.
 
-### namespaces
+#### namespaces
 
-Parsing the XML to objects only required you to simply specify the prefix of the namespace you wanted to parse, when you persist to xml you will need to define your namespaces so that they are correctly captured.
+Parsing the XML to objects only required you to simply specify the prefix of
+the namespace you wanted to parse, when you persist to xml you will need to
+define your namespaces so that they are correctly captured.
 
 ```ruby
 class Address
@@ -599,7 +686,7 @@ class Address
   element :postcode, String
   element :housenumber, String
   element :city, String
-  element :country, Country, :tag => 'country', :namespace => 'different'
+  element :country, Country, tag: 'country', namespace: 'different'
 
 end
-```
+```