nokogiri-happymapper 0.5.9 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 249c78b638ec21c3296253579fc39a43c8a9ab63
-  data.tar.gz: 65cbf3b6b5bb79dd5daa2946f4af6da9de91e0ff
+  metadata.gz: f94968fd78baee9196d17340ee0fa5731c6f6fd1
+  data.tar.gz: 7ca5b00acc1126a265473d583ee331beb00a50e0
 SHA512:
-  metadata.gz: 19de97b5d193847cbfbec6306fe58d4f4fc99ab90807b301e60f6cbc5263cb9440044b2de8d04076c43f69d40ae93af662f580fd601f3211d122eda3d527142a
-  data.tar.gz: 378289efba3dcfc33709ddd400a71bf7d25f93dc4af568ecaaa2803788890b300490f052613844ca678eba1e822f69feced3dd7dd5ba52510f0f0e75ea1a8fc9
+  metadata.gz: e1d779907f83b14a9b392d4dbcca7515dbda14bc8e9932b48a78cbaf7924df5e65adef12454c294947a7e86167dca1866900133985da9ed6cc14bf57fb392e37
+  data.tar.gz: 5205073663f778a8b699d4d54aa63a1d171f12ee300cbc991bd7e3fb4ee2cc252fc2d4540b270ecadb75e0567bf8abceda913dae822f6c9f103275fe70822785

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.6.0 / Unreleased
+
+* Prevent parsing of empty string for Date, DateTime (wushugene)
+* Rescue nil dates (sarsena)
+* Preserve XML value (benoist)
+* Restore after_parse callback support (codekitchen)
+* Parse specific types before general types (Ivo Wever)
+* Higher priority for namespace on element declarations (Ivo Wever)
+
 ## 0.5.9 / 2014-02-18
 
 * Correctly output boolean element value 'false'  (confusion)
@@ -32,4 +41,4 @@
 ## 0.5.3/ 2012-09-23
 
 * String is the default type for parsed fields. (crv)
-* Update the attributes of an existing HappyMapper instance with new XML (benoist)
+* Update the attributes of an existing HappyMapper instance with new XML (benoist)

data/License

@@ -0,0 +1,20 @@
+Copyright (c) 2008 John Nunemaker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/happymapper.rb

@@ -109,8 +109,8 @@ module HappyMapper
     #
     def element(name, type, options={})
       element = Element.new(name, type, options)
+      attr_accessor element.method_name.intern unless @elements[name]
       @elements[name] = element
-      attr_accessor element.method_name.intern
     end
 
     #
@@ -184,6 +184,22 @@ module HappyMapper
       element name, type, {:single => false}.merge(options)
     end
 
+    #
+    # The list of registered after_parse callbacks.
+    #
+    def after_parse_callbacks
+      @after_parse_callbacks ||= []
+    end
+
+    #
+    # Register a new after_parse callback, given as a block.
+    #
+    # @yield [object] Yields the newly-parsed object to the block after parsing.
+    #     Sub-objects will be already populated.
+    def after_parse(&block)
+      after_parse_callbacks.push(block)
+    end
+
     #
     # Specify a namespace if a node and all its children are all namespaced
     # elements. This is simpler than passing the :namespace option to each
@@ -194,7 +210,7 @@ module HappyMapper
     #
     def namespace(namespace = nil)
       @namespace = namespace if namespace
-      @namespace
+      @namespace if defined? @namespace
     end
 
     #
@@ -249,9 +265,7 @@ module HappyMapper
     #
     # @return [Proc] the proc to pass to Nokogiri to setup parse options. nil if empty.
     #
-    def nokogiri_config_callback
-      @nokogiri_config_callback
-    end
+    attr_reader :nokogiri_config_callback
 
     # Register a config callback according to the block Nokogori expects when calling Nokogiri::XML::Document.parse().
     # See http://nokogiri.org/Nokogiri/XML/Document.html#method-c-parse
@@ -273,7 +287,7 @@ module HappyMapper
     def parse(xml, options = {})
 
       # create a local copy of the objects namespace value for this parse execution
-      namespace = @namespace
+      namespace = (@namespace if defined? @namespace)
 
       # If the XML specified is an Node then we have what we need.
       if xml.is_a?(Nokogiri::XML::Node) && !xml.is_a?(Nokogiri::XML::Document)
@@ -410,7 +424,7 @@ module HappyMapper
             obj.send("#{elem.method_name}=",elem.from_xml_node(n, namespace, namespaces))
           end
 
-          if @content
+          if (defined? @content) && @content
             obj.send("#{@content.method_name}=",@content.from_xml_node(n, namespace, namespaces))
           end
 
@@ -420,7 +434,7 @@ module HappyMapper
 
           if obj.respond_to?('xml_value=')
             n.namespaces.each {|name,path| n[name] = path }
-            obj.xml_value = n.to_xml
+            obj.xml_value = n.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
           end
 
           # If the HappyMapper class has the method #xml_content=,
@@ -429,9 +443,13 @@ module HappyMapper
 
           if obj.respond_to?('xml_content=')
             n = n.children if n.respond_to?(:children)
-            obj.xml_content = n.to_xml
+            obj.xml_content = n.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
           end
 
+          # Call any registered after_parse callbacks for the object's class
+
+          obj.class.after_parse_callbacks.each { |callback| callback.call(obj) }
+
           # collect the object that we have created
 
           obj
@@ -480,10 +498,13 @@ module HappyMapper
   #
   # @param [Nokogiri::XML::Builder] builder an instance of the XML builder which
   #     is being used when called recursively.
-  # @param [String] default_namespace the name of the namespace which is the
-  #     default for the xml being produced; this is specified by the element
-  #     declaration when calling #to_xml recursively.
-  # @param [String] tag_from_parent the xml tag to use on the element when being
+  # @param [String] default_namespace The name of the namespace which is the
+  #     default for the xml being produced; this is the namespace of the
+  #     parent
+  # @param [String] namespace_override The namespace specified with the element
+  #     declaration in the parent. Overrides the namespace declaration in the
+  #     element class itself when calling #to_xml recursively.
+  # @param [String] tag_from_parent The xml tag to use on the element when being
   #     called recursively.  This lets the parent doc define its own structure.
   #     Otherwise the element uses the tag it has defined for itself.  Should only
   #     apply when calling a child HappyMapper element.
@@ -492,7 +513,8 @@ module HappyMapper
   #      HappyMapper object; when called recursively this is going to return
   #      and Nokogiri::XML::Builder object.
   #
-  def to_xml(builder = nil,default_namespace = nil,tag_from_parent = nil)
+  def to_xml(builder = nil, default_namespace = nil, namespace_override = nil,
+             tag_from_parent = nil)
 
     #
     # If to_xml has been called without a passed in builder instance that
@@ -539,7 +561,7 @@ module HappyMapper
         # state that they should be expressed in the output.
         #
         if not value.nil? || attribute.options[:state_when_nil]
-          attribute_namespace = attribute.options[:namespace] || default_namespace
+          attribute_namespace = attribute.options[:namespace]
           [ "#{attribute_namespace ? "#{attribute_namespace}:" : ""}#{attribute.tag}", value ]
         else
           []
@@ -576,39 +598,44 @@ module HappyMapper
       end
 
       #
-      # If the object we are persisting has a namespace declaration we will want
+      # If the object we are serializing has a namespace declaration we will want
       # to use that namespace or we will use the default namespace.
       # When neither are specifed we are simply using whatever is default to the
       # builder
       #
+      namespace_for_parent = namespace_override
       if self.class.respond_to?(:namespace) && self.class.namespace
-        xml.parent.namespace = builder.doc.root.namespace_definitions.find { |x| x.prefix == self.class.namespace }
-      elsif default_namespace
-        xml.parent.namespace = builder.doc.root.namespace_definitions.find { |x| x.prefix == default_namespace }
+        namespace_for_parent ||= self.class.namespace
       end
+      namespace_for_parent ||= default_namespace
+
+      xml.parent.namespace =
+          builder.doc.root.namespace_definitions.find { |x| x.prefix == namespace_for_parent }
 
 
       #
       # When a content has been defined we add the resulting value
       # the output xml
       #
-      if content = self.class.instance_variable_get('@content')
-
-        unless content.options[:read_only]
-          text_accessor = content.tag || content.name
-          value = send(text_accessor)
-
-          if on_save_action = content.options[:on_save]
-            if on_save_action.is_a?(Proc)
-              value = on_save_action.call(value)
-            elsif respond_to?(on_save_action)
-              value = send(on_save_action,value)
+      if self.class.instance_variable_defined?('@content')
+        if content = self.class.instance_variable_get('@content')
+
+          unless content.options[:read_only]
+            text_accessor = content.tag || content.name
+            value = send(text_accessor)
+
+            if on_save_action = content.options[:on_save]
+              if on_save_action.is_a?(Proc)
+                value = on_save_action.call(value)
+              elsif respond_to?(on_save_action)
+                value = send(on_save_action,value)
+              end
             end
+
+            builder.text(value)
           end
 
-          builder.text(value)
         end
-
       end
 
       #
@@ -674,7 +701,9 @@ module HappyMapper
               # process should have their contents retrieved and attached
               # to the builder structure
               #
-              item.to_xml(xml,element.options[:namespace],element.options[:tag] || nil)
+              item.to_xml(xml, self.class.namespace || default_namespace,
+                          element.options[:namespace],
+                          element.options[:tag] || nil)
 
             elsif !item.nil?
 
@@ -733,7 +762,7 @@ module HappyMapper
      Class.new do
        include HappyMapper
        tag name
-       instance_eval &blk
+       instance_eval(&blk)
      end
    end
   end

data/lib/happymapper/anonymous_mapper.rb

@@ -64,8 +64,8 @@ module HappyMapper
         define_attribute_on_class(happymapper_class,attribute)
       end
 
-      element.children.each do |element|
-        define_element_on_class(happymapper_class,element)
+      element.children.each do |child|
+        define_element_on_class(happymapper_class,child)
       end
 
       happymapper_class
@@ -111,4 +111,4 @@ module HappyMapper
 
   end
 
-end
+end

data/lib/happymapper/element.rb

@@ -23,9 +23,9 @@ module HappyMapper
         end
       else
         target_path = options[:xpath] ? options[:xpath] : xpath(namespace)
-        node.xpath(target_path, xpath_options).collect do |result|
-          value = yield(result)
-          handle_attributes_option(result, value, xpath_options)
+        node.xpath(target_path, xpath_options).collect do |item|
+          value = yield(item)
+          handle_attributes_option(item, value, xpath_options)
           value
         end
       end

data/lib/happymapper/supported_types.rb

@@ -109,12 +109,12 @@ module HappyMapper
       Time.parse(value.to_s) rescue Time.at(value.to_i)
     end
 
-    register_type Date do |value|
-      Date.parse(value.to_s)
+    register_type DateTime do |value|
+      DateTime.parse(value.to_s) if value && !value.empty?
     end
 
-    register_type DateTime do |value|
-      DateTime.parse(value.to_s)
+    register_type Date do |value|
+      Date.parse(value.to_s) if value && !value.empty?
     end
 
     register_type Boolean do |value|
@@ -137,4 +137,4 @@ module HappyMapper
 
   end
 
-end
+end

data/lib/happymapper/version.rb

@@ -1,3 +1,3 @@
 module HappyMapper
-  VERSION = "0.5.9"
+  VERSION = "0.6.0"
 end

data/spec/fixtures/unformatted_address.xml

@@ -0,0 +1 @@
+<address><street>Milchstrasse</street><housenumber>23</housenumber></address>

data/spec/happymapper/attribute_spec.rb

@@ -5,7 +5,7 @@ describe HappyMapper::Attribute do
   describe "initialization" do
     it 'accepts :default option' do
       attr = described_class.new(:foo, String, :default => 'foobar')
-      attr.default.should == 'foobar'
+      expect(attr.default).to eq('foobar')
     end
   end
 

data/spec/happymapper/item_spec.rb

@@ -12,61 +12,61 @@ describe HappyMapper::Item do
     end
 
     it "should accept a name" do
-      @item.name.should == 'foo'
+      expect(@item.name).to eq('foo')
     end
 
     it 'should accept a type' do
-      @item.type.should == String
+      expect(@item.type).to eq(String)
     end
 
     it 'should accept :tag as an option' do
-      @item.tag.should == 'foobar'
+      expect(@item.tag).to eq('foobar')
     end
 
     it "should have a method_name" do
-      @item.method_name.should == 'foo'
+      expect(@item.method_name).to eq('foo')
     end
   end
 
   describe "#constant" do
     it "should just use type if constant" do
       item = HappyMapper::Item.new(:foo, String)
-      item.constant.should == String
+      expect(item.constant).to eq(String)
     end
 
     it "should convert string type to constant" do
       item = HappyMapper::Item.new(:foo, 'String')
-      item.constant.should == String
+      expect(item.constant).to eq(String)
     end
 
     it "should convert string with :: to constant" do
       item = HappyMapper::Item.new(:foo, 'Foo::Bar')
-      item.constant.should == Foo::Bar
+      expect(item.constant).to eq(Foo::Bar)
     end
   end
 
   describe "#method_name" do
     it "should convert dashes to underscores" do
       item = HappyMapper::Item.new(:'foo-bar', String, :tag => 'foobar')
-      item.method_name.should == 'foo_bar'
+      expect(item.method_name).to eq('foo_bar')
     end
   end
 
   describe "#xpath" do
     it "should default to tag" do
       item = HappyMapper::Item.new(:foo, String, :tag => 'foobar')
-      item.xpath.should == 'foobar'
+      expect(item.xpath).to eq('foobar')
     end
 
     it "should prepend with .// if options[:deep] true" do
       item = HappyMapper::Item.new(:foo, String, :tag => 'foobar', :deep => true)
-      item.xpath.should == './/foobar'
+      expect(item.xpath).to eq('.//foobar')
     end
 
     it "should prepend namespace if namespace exists" do
       item = HappyMapper::Item.new(:foo, String, :tag => 'foobar')
       item.namespace = 'v2'
-      item.xpath.should == 'v2:foobar'
+      expect(item.xpath).to eq('v2:foobar')
     end
   end
 
@@ -74,42 +74,63 @@ describe HappyMapper::Item do
     it "should work with Strings" do
       item = HappyMapper::Item.new(:foo, String)
       [21, '21'].each do |a|
-        item.typecast(a).should == '21'
+        expect(item.typecast(a)).to eq('21')
       end
     end
 
     it "should work with Integers" do
       item = HappyMapper::Item.new(:foo, Integer)
       [21, 21.0, '21'].each do |a|
-        item.typecast(a).should == 21
+        expect(item.typecast(a)).to eq(21)
       end
     end
 
     it "should work with Floats" do
       item = HappyMapper::Item.new(:foo, Float)
       [21, 21.0, '21'].each do |a|
-        item.typecast(a).should == 21.0
+        expect(item.typecast(a)).to eq(21.0)
       end
     end
 
     it "should work with Times" do
       item = HappyMapper::Item.new(:foo, Time)
-      item.typecast('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
+      expect(item.typecast('2000-01-01 01:01:01.123456')).to eq(Time.local(2000, 1, 1, 1, 1, 1, 123456))
     end
 
     it "should work with Dates" do
       item = HappyMapper::Item.new(:foo, Date)
-      item.typecast('2000-01-01').should == Date.new(2000, 1, 1)
+      expect(item.typecast('2000-01-01')).to eq(Date.new(2000, 1, 1))
+    end
+
+    it "should handle nil Dates" do
+      item = HappyMapper::Item.new(:foo, Date)
+      expect(item.typecast(nil)).to eq(nil)
+    end
+
+    it "should handle empty string Dates" do
+      item = HappyMapper::Item.new(:foo, Date)
+      expect(item.typecast("")).to eq(nil)
     end
 
     it "should work with DateTimes" do
       item = HappyMapper::Item.new(:foo, DateTime)
-      item.typecast('2000-01-01 00:00:00').should == DateTime.new(2000, 1, 1, 0, 0, 0)
+      expect(item.typecast('2000-01-01 00:00:00')).to eq(DateTime.new(2000, 1, 1, 0, 0, 0))
     end
 
+    it "should handle nil DateTimes" do
+      item = HappyMapper::Item.new(:foo, DateTime)
+      expect(item.typecast(nil)).to eq(nil)
+    end
+
+    it "should handle empty string DateTimes" do
+      item = HappyMapper::Item.new(:foo, DateTime)
+      expect(item.typecast("")).to eq(nil)
+    end
+
+
     it "should work with Boolean" do
       item = HappyMapper::Item.new(:foo, HappyMapper::Boolean)
-      item.typecast('false').should == false
+      expect(item.typecast('false')).to eq(false)
     end
   end
 end