nokogiri-happymapper 0.5.7 → 0.5.8

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OTI1ZDRjNDk4NTE1ZjAxZTA0ZjE0YzhhM2JkYTk3YmZjOWZkYjE3NA==
-  data.tar.gz: !binary |-
-    NjQyMjEyMDBmYTU5NGZmNzM2NGY4NzJkM2Q1ZDA5YmU0NzY5NDU2OA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NjY1MTkxOTI0NjM1NDI2YTdjOGUwNzFhNjkzMWNiMzg5OGQ4ZTcyZGQ3NzZm
-    YmJlNzg0MjNlYjk4MDE5N2E0M2IyNjM5MGE5MmE3M2I3MzE2MTM4MmEwZTNi
-    OTMxMzkxMTViMGI3Mzc5MmY2ZGJjOGY5YTYyNjY1OTk3YTIwZDU=
-  data.tar.gz: !binary |-
-    ZjBmZjEwMzQ4NWRmYWJmYzFiMDRkZDYwYzU5N2VjY2U5ZTEwODU1ZmRiYjVm
-    Njc5OTIyNjA3NmJhMDNmOWNhM2RjOTI5NDZhNmEzODQ5ZDc0MzMxYTM0MWE0
-    MTQzMjYzMDY0Njg4ZGE3NWFjNTU1YmY3NDAwY2ExNDhmMDdhMDc=
+SHA1:
+  metadata.gz: cdf3f127daf46afa0d3d5e20bed4bf5551c29f46
+  data.tar.gz: 391a93426ddbd64054b5e5237796691c02d6ad1b
+SHA512:
+  metadata.gz: 1f0eaadc20671544e2cdb7738cb05359101de87dbeea066492abe2a65aa8016458d15cec88cce6bbba034b167605c5a3e5abd34d7e033df7f0d4101327c736ec
+  data.tar.gz: b690eb50747ebdffb6224e5715124de18c25cba9387c58db51b71d612ac0303be2ed38c4379afd78805a7d5043c9d4c0cf12a60e29edf7b01c66a636ce3d51f0

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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)
+* 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)
+
+## 0.5.7 / 2012-10-29
+
 ## 0.5.6 / 2012-10-29
 
 * Add possibility to give a configuration block to Nokogiri when parsing (DieboldInc).

data/README.md

@@ -11,13 +11,13 @@ This project is a fork of the great work done first by
   * [Nokogiri](http://nokogiri.org/) support
   * Text nodes parsing
   * Raw XML content parsing
-  * [burtlo](http://github.com/burtlo/happymapper)'s `#to_xml` support utilizing the same HappyMapper tags
-  * Fixes for [namespaces when using composition of classes](https://github.com/burtlo/happymapper/commit/fd1e898c70f7289d2d2618d629b56f2f6623785c)
-  * Fixes for instances of XML where a [namespace is defined but no elements with that namespace are found](https://github.com/burtlo/happymapper/commit/9614221a80ff3bda18ff859aa751dff29cf52fd3).
+  * `#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
 
 ## Installation
 
-### [Rubygems](https://rubygems.org/gems/nokogiri-happymapper)
+### [Rubygems](https://rubyygems.org/gems/nokogiri-happymapper)
 
     $ gem install nokogiri-happymapper
 
@@ -68,18 +68,20 @@ It is important to be aware that this no configuration parsing is limited in cap
 
 Happymapper will let you easily model this information as a class:
 
-    require 'happymapper'
-
-    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'
-    end
+```ruby
+require 'happymapper'
+
+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'
+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.
 
@@ -89,16 +91,20 @@ To make a class HappyMapper compatible you simply `include HappyMapper` within t
 
 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:
 
-    element :street, String, :tag => 'street'
-    element :street, String
+```ruby
+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.
 
 Instead of `element` you may also use `has_one`:
 
-    element :street, String, :tag => 'street'
-    element :street, String
-    has_one :street, String
+```ruby
+element :street, String, :tag => 'street'
+element :street, String
+has_one :street, String
+```
 
 These three statements are equivalent to each other.
 
@@ -106,8 +112,10 @@ These three statements are equivalent to each other.
 
 With the mapping of the address XML articulated in our Address class it is time to parse the data:
 
-    address = Address.parse(ADDRESS_XML_DATA, :single => true)
-    puts address.street
+```ruby
+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.
 
@@ -115,8 +123,10 @@ The `parse` method, like `tag` and `element` are all added when you included Hap
 
 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:
 
-    address = Address.parse(ADDRESS_XML_DATA).first
-    address = Address.parse(ADDRESS_XML_DATA, :single => true)
+```ruby
+address = Address.parse(ADDRESS_XML_DATA).first
+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.
 
@@ -135,33 +145,39 @@ What if our address XML was a little different, perhaps we allowed multiple stre
 
 Similar to `element` or `has_one`, the declaration for when you have multiple elements you simply use:
 
-    has_many :streets, String, :tag => 'street'
+```ruby
+has_many :streets, String, :tag => 'street'
+```
 
 Your resulting `streets` method will now return an array.
 
-    address = Address.parse(ADDRESS_XML_DATA, :single => true)
-    puts address.streets.join('\n')
+```ruby
+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.
 
-     require 'happymapper'
+```ruby
+require 'happymapper'
 
-     class Address
-       include HappyMapper
+class Address
+  include HappyMapper
 
-       tag 'address'
+  tag 'address'
 
-       has_many :streets, String
+  has_many :streets, String
 
-       def streets
-         @streets.join('\n')
-       end
+  def streets
+    @streets.join('\n')
+  end
 
-       element :postcode, String, :tag => 'postcode'
-       element :housenumber, String, :tag => 'housenumber'
-       element :city, String, :tag => 'city'
-       element :country, String, :tag => 'country'
-     end
+  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.
 
@@ -179,7 +195,9 @@ 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`
 
-    attribute :location, String, :tag => 'location
+```ruby
+attribute :location, String, :tag => 'location
+```
 
 Again, you can omit the tag if the attribute accessor symbol matches the name of the attribute.
 
@@ -196,22 +214,26 @@ Again, you can omit the tag if the attribute accessor symbol matches the name 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
 
-    class Feed
-      # ....
-      has_many :links, Link, :tag => 'link', :xpath => '.'
-    end
-
-    class Link
-      include HappyMapper
-
-      attribute :rel, String
-      attribute :type, String
-      attribute :href, String
-    end
+```ruby
+class Feed
+  # ....
+  has_many :links, Link, :tag => 'link', :xpath => '.'
+end
+
+class Link
+  include HappyMapper
+
+  attribute :rel, String
+  attribute :type, String
+  attribute :href, String
+end
+```
 
 You can drop the `Link` class and simply replace the `has_many` on `Feed` with
 
-    element :link, String, :single => false, :attributes => { :rel => String, :type => String, :href => String }
+```ruby
+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.
 
@@ -233,14 +255,16 @@ Our address has a country and that country element has a code. Up until this poi
 
 Well if we only going to parse country, on it's own, we would likely create a class mapping for it.
 
-    class Country
-      include HappyMapper
+```ruby
+class Country
+  include HappyMapper
 
-      tag 'country'
+  tag 'country'
 
-      attribute :code, String
-      content :name, String
-    end
+  attribute :code, String
+  content :name, String
+end
+```
 
 We are utilizing an `attribute` declaration and a new declaration called `content`.
 
@@ -248,27 +272,31 @@ We are utilizing an `attribute` declaration and a new declaration called `conten
 
 Awesome, now if we were to redeclare our `Address` class we would use our new `Country` class.
 
-    class Address
-      include HappyMapper
+```ruby
+class Address
+  include HappyMapper
 
-      tag 'address'
+  tag 'address'
 
-      has_many :streets, String, :tag => 'street'
+  has_many :streets, String, :tag => 'street'
 
-      def streets
-        @streets.join('\n')
-      end
+  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'
-    end
+  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.
 
-    address = Address.parse(ADDRESS_XML_DATA, :single => true)
-    puts address.country.code
+```ruby
+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.
 
@@ -294,13 +322,14 @@ Getting to elements deep down within your XML can be a little more work if you d
 
 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.
 
-    class Media
-      include HappyMapper
-
-      has_one :title, String, :xpath => 'gallery/title'
-      has_one :link, String, :xpath => 'gallery/title/@href'
-    end
+```ruby
+class Media
+  include HappyMapper
 
+  has_one :title, String, :xpath => 'gallery/title'
+  has_one :link, String, :xpath => 'gallery/title/@href'
+end
+```
 
 ## Shared Functionality
 
@@ -308,85 +337,90 @@ You may want to map the sub-elements contained buried in the 'gallery' as top le
 
 While mapping XML to objects you may arrive at a point where you have two or more very similar structures.
 
-    class Article
-      include HappyMapper
+```ruby
+class Article
+  include HappyMapper
 
-      has_one :title, String
-      has_one :author, String
-      has_one :published, Time
+  has_one :title, String
+  has_one :author, String
+  has_one :published, Time
 
-      has_one :entry, String
+  has_one :entry, String
 
-    end
+end
 
-    class Gallery
-      include HappyMapper
+class Gallery
+  include HappyMapper
 
-      has_one :title, String
-      has_one :author, String
-      has_one :published, Time
+  has_one :title, String
+  has_one :author, String
+  has_one :published, Time
 
-      has_many :photos, String
+  has_many :photos, String
 
-    end
+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.
 
-    class Content
-      include HappyMapper
+```ruby
+class Content
+  include HappyMapper
 
-      has_one :title, String
-      has_one :author, String
-      has_one :published, Time
-    end
+  has_one :title, String
+  has_one :author, String
+  has_one :published, Time
+end
 
-    class Article < Content
-      include HappyMapper
+class Article < Content
+  include HappyMapper
 
-      has_one :entry, String
-    end
+  has_one :entry, String
+end
 
-    class Gallery < Content
-      include HappyMapper
+class Gallery < Content
+  include HappyMapper
 
-      has_many :photos, String
-    end
+  has_many :photos, String
+end
+```
 
-### Module Mixins Approache
+### Module Mixins Approach
 
 You can also solve the above problem through mixins.
 
-    module Content
-      def self.included(content)
-        content.has_one :title, String
-        content.has_one :author, String
-        content.has_one :published, Time
-      end
-
-      def published_time
-        @published.strftime("%H:%M:%S")
-      end
-    end
-
-    class Article
-      include HappyMapper
-
-      include Content
-      has_one :entry, String
-    end
-
-    class Gallery
-      include HappyMapper
-
-      include Content
-      has_many :photos, String
-    end
-
+```ruby
+module Content
+  def self.included(content)
+    content.has_one :title, String
+    content.has_one :author, String
+    content.has_one :published, Time
+  end
+
+  def published_time
+    @published.strftime("%H:%M:%S")
+  end
+end
+
+class Article
+  include HappyMapper
+
+  include Content
+  has_one :entry, String
+end
+
+class Gallery
+  include HappyMapper
+
+  include Content
+  has_many :photos, String
+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.
 
 
-## Filtering with XPATH
+## 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.
 
@@ -405,25 +439,38 @@ I ran into a case where I wanted to capture all the pictures that were directly
 
 The following `Media` class is where I started:
 
-    require 'happymapper'
+```ruby
+require 'happymapper'
 
-    class Media
-      include HappyMapper
+class Media
+  include HappyMapper
 
-      has_many :galleries, Gallery, :tag => 'gallery'
-      has_many :pictures, Picture, :tag => 'picture'
-    end
+  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.
 
-    pictures = Media.parse(MEDIA_XML,:single => true).pictures
-    pictures.length.should == 1   # => Failed Expectation
+```ruby
+pictures = Media.parse(MEDIA_XML,:single => true).pictures
+pictures.length.should == 1   # => Failed Expectation
+```
+
+The reason that 2 elements are returned and not 1 is because the default
+mappings are assigned XPATH './/' which makes them greedy. Essentially by
+default it will find all elements with the tag 'pictures' at the current
+level of the document and anywhere else within the document.
 
-I was mistaken and that is because, by default the mappings are assigned XPATH './/' which is requiring all the elements no matter where they can be found. To override this you can specify an XPATH value for your defined elements.
+To limit an element from being greedy and only finding elements at the
+level of the current node you can specify an XPATH.
 
-    has_many :pictures, Picture, :tag => 'picture', :xpath => '/media'
+```ruby
+has_many :pictures, Picture, :tag => 'picture', :xpath => '.'
+```
 
-`/media` states that we are only interested in pictures that can be found directly under the media element. So when we parse again we will have only our one element.
+`.` 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
@@ -443,28 +490,32 @@ Perhaps our `address` XML is really swarming with namespaces:
 
 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:
 
-    class Address
-      include HappyMapper
+```ruby
+class Address
+  include HappyMapper
 
-      tag 'address'
-      namespace 'prefix'
-      # ... rest of the code ...
-    end
+  tag 'address'
+  namespace 'prefix'
+  # ... rest of the code ...
+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.
 
-    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'
+```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'
+```
 
 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'`.
 
 Imagine that our `country` actually belonged to a completely different namespace.
 
     <prefix:address location='home' xmlns:prefix="http://www.unicornland.com/prefix"
-    xmlns:prefix="http://www.trollcountry.com/different">
+    xmlns:different="http://www.trollcountry.com/different">
       <prefix:street>Milchstrasse</prefix:street>
       <prefix:street>Another Street</prefix:street>
       <prefix:housenumber>23</prefix:housenumber>
@@ -475,7 +526,9 @@ Imagine that our `country` actually belonged to a completely different namespace
 
 Well we would need to specify that namespace:
 
-    element :country, Country, :tag => 'country', :namespace => 'different'
+```ruby
+element :country, Country, :tag => 'country', :namespace => 'different'
+```
 
 With that we should be able to parse as we once did.
 
@@ -483,9 +536,11 @@ With that we should be able to parse as we once did.
 
 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.
 
-    Address.parse(LARGE_ADDRESS_XML_DATA,:in_groups_of => 5) do |group|
-      puts address.streets
-    end
+```ruby
+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.
 
@@ -498,7 +553,9 @@ Saving a class to XML is as easy as calling `#to_xml`.  The end result will be t
 
 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:
 
-    has_one :published_time, Time, :on_save => lambda {|time| time.strftime("%H:%M:%S") if time }
+```ruby
+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`.
 
@@ -506,7 +563,9 @@ Here we add the options `:on_save` and specify a lambda which will be executed o
 
 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.
 
-    has_one :favorite_color, String, :state_when_nil => true
+```ruby
+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.
 
@@ -515,28 +574,32 @@ The resulting XML will include the 'favorite_color' element even if the favorite
 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`.
 
-    has_one :modified, Boolean, :read_only => true
-    attribute :temporary, Boolean, :read_only => true
+```ruby
+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
 
-While parsing the XML 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.
 
-    class Address
-      include HappyMapper
+```ruby
+class Address
+  include HappyMapper
 
-      register_namespace 'prefix', 'http://www.unicornland.com/prefix'
-      register_namespace 'different', 'http://www.trollcountry.com/different'
+  register_namespace 'prefix', 'http://www.unicornland.com/prefix'
+  register_namespace 'different', 'http://www.trollcountry.com/different'
 
-      tag 'address'
-      namespace 'prefix'
+  tag 'address'
+  namespace 'prefix'
 
-      has_many :street, String
-      element :postcode, String
-      element :housenumber, String
-      element :city, String
-      element :country, Country, :tag => 'country', :namespace => 'different'
+  has_many :street, String
+  element :postcode, String
+  element :housenumber, String
+  element :city, String
+  element :country, Country, :tag => 'country', :namespace => 'different'
 
-    end
+end
+```

data/lib/happymapper.rb

@@ -14,15 +14,17 @@ module HappyMapper
   def self.included(base)
     if !(base.superclass <= HappyMapper)
       base.instance_eval do
-        @attributes = []
-        @elements = []
+        @attributes = {}
+        @elements = {}
         @registered_namespaces = {}
         @wrapper_anonymous_classes = {}
       end
     else
       base.instance_eval do
-        @attributes = superclass.attributes.dup
-        @elements = superclass.elements.dup
+        @attributes =
+            superclass.instance_variable_get(:@attributes).dup
+        @elements =
+            superclass.instance_variable_get(:@elements).dup
         @registered_namespaces =
             superclass.instance_variable_get(:@registered_namespaces).dup
         @wrapper_anonymous_classes =
@@ -52,7 +54,7 @@ module HappyMapper
     #
     def attribute(name, type, options={})
       attribute = Attribute.new(name, type, options)
-      @attributes << attribute
+      @attributes[name] = attribute
       attr_accessor attribute.method_name.intern
     end
 
@@ -63,7 +65,7 @@ module HappyMapper
     #     an empty array is returned when there have been no attributes defined.
     #
     def attributes
-      @attributes
+      @attributes.values
     end
 
     #
@@ -107,7 +109,7 @@ module HappyMapper
     #
     def element(name, type, options={})
       element = Element.new(name, type, options)
-      @elements << element
+      @elements[name] = element
       attr_accessor element.method_name.intern
     end
 
@@ -119,7 +121,7 @@ module HappyMapper
     #     defined.
     #
     def elements
-      @elements
+      @elements.values
     end
 
     #
@@ -338,18 +340,36 @@ module HappyMapper
         nodes = []
 
         # when finding nodes, do it in this order:
-        # 1. specified tag
+        # 1. specified tag if one has been provided
         # 2. name of element
         # 3. tag_name (derived from class name by default)
 
+        # If a tag has been provided we need to search for it.
 
-        [options[:tag], options[:name], tag_name].compact.each do |xpath_ext|
+        if options.key?(:tag)
           begin
-            nodes = node.xpath(xpath + xpath_ext.to_s, namespaces)
+            nodes = node.xpath(xpath + options[:tag].to_s, namespaces)
           rescue
-            break
+            # This exception takes place when the namespace is often not found
+            # and we should continue on with the empty array of nodes.
           end
-          break if nodes && !nodes.empty?
+        else
+
+          # This is the default case when no tag value is provided.
+          # First we use the name of the element `items` in `has_many items`
+          # Second we use the tag name which is the name of the class cleaned up
+
+          [options[:name], tag_name].compact.each do |xpath_ext|
+            begin
+              nodes = node.xpath(xpath + xpath_ext.to_s, namespaces)
+            rescue
+              break
+              # This exception takes place when the namespace is often not found
+              # and we should continue with the empty array of nodes or keep looking
+            end
+            break if nodes && !nodes.empty?
+          end
+
         end
 
         nodes

data/lib/happymapper/element.rb

@@ -35,12 +35,14 @@ module HappyMapper
       if options[:attributes].is_a?(Hash)
         result = result.first unless result.respond_to?(:attribute_nodes)
 
+        return unless result.respond_to?(:attribute_nodes)
+
         result.attribute_nodes.each do |xml_attribute|
           if attribute_options = options[:attributes][xml_attribute.name.to_sym]
             attribute_value = Attribute.new(xml_attribute.name.to_sym, *attribute_options).from_xml_node(result, namespace, xpath_options)
 
             result.instance_eval <<-EOV
-                def value.#{xml_attribute.name}
+                def value.#{xml_attribute.name.gsub(/\-/, '_')}
             #{attribute_value.inspect}
                 end
             EOV

data/lib/happymapper/item.rb

@@ -32,6 +32,8 @@ module HappyMapper
     #
     def from_xml_node(node, namespace, xpath_options)
 
+      namespace = options[:namespace] if options.key?(:namespace)
+
       if suported_type_registered?
         find(node, namespace, xpath_options) { |n| process_node_as_supported_type(n) }
       elsif constant == XmlContent

data/lib/happymapper/version.rb

@@ -1,3 +1,3 @@
 module HappyMapper
-  VERSION = "0.5.7"
+  VERSION = "0.5.8"
 end

data/spec/attributes_spec.rb

@@ -0,0 +1,36 @@
+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
+
+      has_many :link, String, :attributes => { :'data-src' => String, :type => String, :href => String }
+
+    end
+  end
+
+  let(:document) do
+    AttributeMethodConversion::Document.parse(xml_document,single: true)
+  end
+
+  it "link" do
+    expect(document.link).to eq ["Roast Beef"]
+  end
+
+  it "link.data_src" do
+    expect(document.link.first.data_src).to eq "http://cooking.com/roastbeef"
+  end
+
+  it "link.type" do
+    expect(document.link.first.type).to eq "recipe"
+  end
+
+end

data/spec/fixtures/current_weather_missing_elements.xml

@@ -0,0 +1,18 @@
+<aws:weather xmlns:aws="http://www.aws.com/aws">
+  <aws:api version="2.0"/>
+  <aws:WebURL>http://weather.weatherbug.com/IN/Carmel-weather.html?ZCode=Z5546&amp;Units=0&amp;stat=MOCAR</aws:WebURL>
+  <aws:ob>
+    <aws:ob-date>
+      <aws:year number="2008"/>
+      <aws:month number="12" text="December" abbrv="Dec"/>
+      <aws:day number="30" text="Tuesday" abbrv="Tue"/>
+      <aws:hour number="4" hour-24="16"/>
+      <aws:minute number="18"/>
+      <aws:second number="01"/>
+      <aws:am-pm abbrv="PM"/>
+      <aws:time-zone offset="-5" text="Eastern Standard Time" abbrv="EST"/>
+    </aws:ob-date>
+    <aws:feels-like units="&amp;deg;F">51</aws:feels-like>
+    <aws:temp units="&amp;deg;F">51.8</aws:temp>
+  </aws:ob>
+</aws:weather>

data/spec/happymapper_parse_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'spec_helper'
 
 describe HappyMapper do
 
@@ -45,7 +45,7 @@ describe HappyMapper do
 
       subject { described_class.parse fixture_file('subclass_namespace.xml') }
 
-      it "should parse the elements an values correctly" do
+      it "should parse the elements and values correctly" do
         subject.title.should == "article title"
         subject.photo.publish_options.author.should == "Stephanie"
         subject.gallery.photo.title.should == "photo title"
@@ -70,7 +70,7 @@ describe HappyMapper do
         subject.image.should == [ "image1", "image2" ]
 
       end
-      
+
     end
 
     context "xml with multiple namespaces" do

data/spec/happymapper_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'uri'
 
 module Analytics
   class Property
@@ -780,6 +781,10 @@ describe HappyMapper do
     feed.link.last.href.should == 'http://www.example.com/tv_shows.atom'
   end
 
+  it "parses xml with optional elements with embedded attributes" do
+    expect { CurrentWeather.parse(fixture_file('current_weather_missing_elements.xml')) }.to_not raise_error()
+  end
+
   it "returns nil rather than empty array for absent values when :single => true" do
     address = Address.parse('<?xml version="1.0" encoding="UTF-8"?><foo/>', :single => true)
     address.should be_nil
@@ -1099,7 +1104,7 @@ describe HappyMapper do
     end
 
     it 'parses according to @nokogiri_config_callback' do
-      expect { custom.parse(fixture_file('set_config_options.xml')) }.to_not raise_error(Nokogiri::XML::SyntaxError)
+      expect { custom.parse(fixture_file('set_config_options.xml')) }.to_not raise_error
     end
 
     it 'can clear @nokogiri_config_callback' do

data/spec/has_many_empty_array_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module Sheep
+  class Item
+    include HappyMapper
+  end
+
+  class Navigator
+    include HappyMapper
+    tag 'navigator'
+
+    # This is purposefully set to have the name 'items' with the tag 'item'.
+    # The idea is that it should not find the empty items contained within the
+    # xml and return an empty array. This exercises the order of how nodes
+    # are searched for within an XML document.
+    has_many :items, Item, tag: 'item'
+
+    has_many :items_with_a_different_name, Item, tag: 'item'
+
+  end
+end
+
+describe "emptyness" do
+  let(:xml) do
+    <<-EOF
+    <navigator>
+      <items/>
+    </navigator>
+    EOF
+  end
+
+  let(:navigator) do
+    Sheep::Navigator.parse(xml)
+  end
+
+  it "returns an empty array" do
+    navigator.items_with_a_different_name.should be_empty
+  end
+
+  it "returns an empty array" do
+    navigator.items.should be_empty
+  end
+end

data/spec/inheritance_spec.rb

@@ -19,6 +19,52 @@ describe "Using inheritance to share elements and attributes" do
     has_many :immunities, String
   end
 
+  class Overwrite < Parent
+    include HappyMapper
+
+    attribute :love, String
+    element :genetics, Integer
+  end
+
+  describe "Overwrite" do
+    let(:subject) 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
+      expect(Overwrite.attributes.count).to be == Parent.attributes.count
+      expect(Overwrite.elements.count).to be == Parent.elements.count
+    end
+
+    context "when parsing xml" do
+      it 'parses the new overwritten attribut' do
+        expect(subject.love).to be == "love"
+      end
+
+      it 'parses the new overwritten element' do
+        expect(subject.genetics).to be == 1001
+      end
+    end
+
+    context "when saving to xml" do
+      subject 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(subject.xpath('//genetics').count).to be == 1
+      end
+
+      it 'has only 1 love attribute' do
+        expect(subject.xpath('@love').text).to be == "love"
+      end
+    end
+  end
+
   describe "Child", "a subclass of the Parent" do
     let(:subject) do
       xml = '<child love="99" naivety="trusting"><genetics>ABBA</genetics><immunities>Chicken Pox</immunities></child>'
@@ -58,4 +104,4 @@ describe "Using inheritance to share elements and attributes" do
     end
 
   end
-end
+end

data/spec/mixed_namespaces_spec.rb

@@ -0,0 +1,61 @@
+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
+
+      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
+
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nokogiri-happymapper
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - Damien Le Berrigaud
@@ -63,6 +63,7 @@ files:
 - README.md
 - CHANGELOG.md
 - spec/attribute_default_value_spec.rb
+- spec/attributes_spec.rb
 - spec/fixtures/address.xml
 - spec/fixtures/ambigous_items.xml
 - spec/fixtures/analytics.xml
@@ -70,6 +71,7 @@ files:
 - spec/fixtures/atom.xml
 - spec/fixtures/commit.xml
 - spec/fixtures/current_weather.xml
+- spec/fixtures/current_weather_missing_elements.xml
 - spec/fixtures/default_namespace_combi.xml
 - spec/fixtures/dictionary.xml
 - spec/fixtures/family_tree.xml
@@ -95,8 +97,10 @@ files:
 - spec/happymapper/text_node_spec.rb
 - spec/happymapper_parse_spec.rb
 - spec/happymapper_spec.rb
+- spec/has_many_empty_array_spec.rb
 - spec/ignay_spec.rb
 - spec/inheritance_spec.rb
+- spec/mixed_namespaces_spec.rb
 - spec/parse_with_object_to_update_spec.rb
 - spec/spec_helper.rb
 - spec/to_xml_spec.rb
@@ -114,22 +118,23 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 3
 summary: Provides a simple way to map XML to Ruby Objects and back again.
 test_files:
 - spec/attribute_default_value_spec.rb
+- spec/attributes_spec.rb
 - spec/fixtures/address.xml
 - spec/fixtures/ambigous_items.xml
 - spec/fixtures/analytics.xml
@@ -137,6 +142,7 @@ test_files:
 - spec/fixtures/atom.xml
 - spec/fixtures/commit.xml
 - spec/fixtures/current_weather.xml
+- spec/fixtures/current_weather_missing_elements.xml
 - spec/fixtures/default_namespace_combi.xml
 - spec/fixtures/dictionary.xml
 - spec/fixtures/family_tree.xml
@@ -162,8 +168,10 @@ test_files:
 - spec/happymapper/text_node_spec.rb
 - spec/happymapper_parse_spec.rb
 - spec/happymapper_spec.rb
+- spec/has_many_empty_array_spec.rb
 - spec/ignay_spec.rb
 - spec/inheritance_spec.rb
+- spec/mixed_namespaces_spec.rb
 - spec/parse_with_object_to_update_spec.rb
 - spec/spec_helper.rb
 - spec/to_xml_spec.rb
@@ -171,3 +179,4 @@ test_files:
 - spec/wilcard_tag_name_spec.rb
 - spec/wrap_spec.rb
 - spec/xpath_spec.rb
+has_rdoc: