nokogiri-happymapper 0.5.6 → 0.5.7

data/lib/happymapper/item.rb

@@ -2,8 +2,6 @@ module HappyMapper
   class Item
     attr_accessor :name, :type, :tag, :options, :namespace
 
-    Types = [String, Float, Time, Date, DateTime, Integer, Boolean]
-
     # options:
     #   :deep   =>  Boolean False to only parse element's children, True to include
     #               grandchildren and all others down the chain (// in xpath)
@@ -26,56 +24,24 @@ module HappyMapper
     def constant
       @constant ||= constantize(type)
     end
-      
+
     #
     # @param [XMLNode] node the xml node that is being parsed
     # @param [String] namespace the name of the namespace
     # @param [Hash] xpath_options additional xpath options
-    #  
+    #
     def from_xml_node(node, namespace, xpath_options)
-      
-      # If the item is defined as a primitive type then cast the value to that type
-      # else if the type is XMLContent then store the xml value
-      # else the type, specified, needs to handle the parsing.
-      #
-      
-      if primitive?
-        find(node, namespace, xpath_options) do |n|
-          if n.respond_to?(:content)
-            typecast(n.content)
-          else
-            typecast(n)
-          end
-        end
+
+      if suported_type_registered?
+        find(node, namespace, xpath_options) { |n| process_node_as_supported_type(n) }
       elsif constant == XmlContent
-        find(node, namespace, xpath_options) do |n|
-          n = n.children if n.respond_to?(:children)
-          n.respond_to?(:to_xml) ? n.to_xml : n.to_s
-        end
+        find(node, namespace, xpath_options) { |n| process_node_as_xml_content(n) }
+      elsif custom_parser_defined?
+        find(node, namespace, xpath_options) { |n| process_node_with_custom_parser(n) }
       else
-        
-        # When not a primitive type or XMLContent then default to using the
-        # class method #parse of the type class. If the option 'parser' has been 
-        # defined then call that method on the type class instead of #parse
-        
-        if options[:parser]
-          find(node, namespace, xpath_options) do |n|
-            if n.respond_to?(:content) && !options[:raw]
-              value = n.content
-            else
-              value = n.to_s
-            end
-
-            begin
-              constant.send(options[:parser].to_sym, value)
-            rescue
-              nil
-            end
-          end
-        else
-          constant.parse(node, options.merge(:namespaces => xpath_options))
-        end
+        process_node_with_default_parser(node,:namespaces => xpath_options)
       end
+
     end
 
     def xpath(namespace = self.namespace)
@@ -86,166 +52,107 @@ module HappyMapper
       #puts "xpath: #{xpath}"
       xpath
     end
-    
-    # @return [Boolean] true if the type defined for the item is defined in the
-    #     list of primite types {Types}.
-    def primitive?
-      Types.include?(constant)
-    end
-
-    def element?
-      @xml_type == 'element'
-    end
-
-    def attribute?
-      @xml_type == 'attribute'
-    end
-
-    def text_node?
-      @xml_type == 'textnode'
-    end
 
     def method_name
       @method_name ||= name.tr('-', '_')
     end
 
     #
-    # When the type of the item is a primitive type, this will convert value specifed
-    # to the particular primitive type. If it fails during this process it will
-    # return the original String value.
-    # 
+    # Convert the value into the correct type.
+    #
     # @param [String] value the string value parsed from the XML value that will
     #     be converted to the particular primitive type.
-    # 
+    #
     # @return [String,Float,Time,Date,DateTime,Boolean,Integer] the converted value
     #     to the new type.
     #
     def typecast(value)
-      return value if value.kind_of?(constant) || value.nil?
-      begin        
-        if    constant == String    then value.to_s
-        elsif constant == Float     then value.to_f
-        elsif constant == Time      then Time.parse(value.to_s) rescue Time.at(value.to_i)
-        elsif constant == Date      then Date.parse(value.to_s)
-        elsif constant == DateTime  then DateTime.parse(value.to_s)
-        elsif constant == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
-        elsif constant == Integer
-          # ganked from datamapper
-          value_to_i = value.to_i
-          if value_to_i == 0 && value != '0'
-            value_to_s = value.to_s
-            begin
-              Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
-            rescue ArgumentError
-              nil
-            end
-          else
-            value_to_i
-          end
-        else
-          value
-        end
-      rescue
-        value
-      end
+      typecaster(value).apply(value)
     end
 
+
     private
 
-      #
-      # Convert any String defined types into their constant version so that
-      # the method #parse or the custom defined parser method would be used.
-      # 
-      # @param [String,Constant] type is the name of the class or the constant
-      #     for the class.
-      # @return [Constant] the constant of the type
-      #
-      def constantize(type)
-        if type.is_a?(String)
-          names = type.split('::')
-          constant = Object
-          names.each do |name|
-            constant =
-              if constant.const_defined?(name)
-                constant.const_get(name)
-              else
-                constant.const_missing(name)
-              end
-          end
-          constant
-        else
-          type
-        end
+    # @return [Boolean] true if the type defined for the item is defined in the
+    #     list of support types.
+    def suported_type_registered?
+      SupportedTypes.types.map {|caster| caster.type }.include?(constant)
+    end
+
+    # @return [#apply] the typecaster object that will be able to convert
+    #   the value into a value with the correct type.
+    def typecaster(value)
+      SupportedTypes.types.find { |caster| caster.apply?(value,constant) }
+    end
+
+    #
+    # Processes a Nokogiri::XML::Node as a supported type
+    #
+    def process_node_as_supported_type(node)
+      content = node.respond_to?(:content) ? node.content : node
+      typecast(content)
+    end
+
+    #
+    # Process a Nokogiri::XML::Node as XML Content
+    #
+    def process_node_as_xml_content(node)
+      node = node.children if node.respond_to?(:children)
+      node.respond_to?(:to_xml) ? node.to_xml : node.to_s
+    end
+
+    #
+    # A custom parser is a custom parse method on the class. When the parser
+    # option has been set this value is the name of the method which will be
+    # used to parse the node content.
+    #
+    def custom_parser_defined?
+      options[:parser]
+    end
+
+    def process_node_with_custom_parser(node)
+      if node.respond_to?(:content) && !options[:raw]
+        value = node.content
+      else
+        value = node.to_s
       end
 
+      begin
+        constant.send(options[:parser].to_sym, value)
+      rescue
+        nil
+      end
+    end
 
-      def find(node, namespace, xpath_options, &block)
-        if self.namespace && xpath_options["xmlns:#{self.namespace}"]
-          # from the class definition
-          namespace = self.namespace
-        elsif options[:namespace] && xpath_options["xmlns:#{options[:namespace]}"]
-          namespace = options[:namespace]
-        end
-        
-        if element?
-          if options[:single]
-            
-            result = nil
-            
-            if options[:xpath]
-              result = node.xpath(options[:xpath], xpath_options)
-            else
-              result = node.xpath(xpath(namespace), xpath_options)
-            end
-
-            if result
-              value = options[:single] ? yield(result.first) : result.map {|r| yield r }
-              handle_attributes_option(result, value, xpath_options)
-
-              value
-            end
-          else
-            
-            target_path = options[:xpath] ? options[:xpath] : xpath(namespace)
-            
-            results = node.xpath(target_path, xpath_options).collect do |result|
-              value = yield(result)
-              handle_attributes_option(result, value, xpath_options)
-              value
-            end
-            results
-          end
-        elsif attribute?
-          
-          if options[:xpath]
-            yield(node.xpath(options[:xpath],xpath_options))
+    def process_node_with_default_parser(node,parse_options)
+      constant.parse(node,options.merge(parse_options))
+    end
+
+    #
+    # Convert any String defined types into their constant version so that
+    # the method #parse or the custom defined parser method would be used.
+    #
+    # @param [String,Constant] type is the name of the class or the constant
+    #     for the class.
+    # @return [Constant] the constant of the type
+    #
+    def constantize(type)
+      type.is_a?(String) ? convert_string_to_constant(type) : type
+    end
+
+    def convert_string_to_constant(type)
+      names = type.split('::')
+      constant = Object
+      names.each do |name|
+        constant =
+          if constant.const_defined?(name)
+            constant.const_get(name)
           else
-            yield(node[tag])
+            constant.const_missing(name)
           end
-          
-        else # text node
-          yield(node.children.detect{|c| c.text?})
-        end
       end
+      constant
+    end
 
-      def handle_attributes_option(result, value, xpath_options)
-        if options[:attributes].is_a?(Hash)
-          result = result.first 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}
-                  #{attribute_value.inspect}
-                end
-              EOV
-            end # if attributes_options
-          end # attribute_nodes.each
-        end # if options[:attributes]
-      end # def handle...
-
-    # end private methods
   end
 end

data/lib/happymapper/supported_types.rb

@@ -0,0 +1,140 @@
+module HappyMapper
+  module SupportedTypes
+    extend self
+
+    #
+    # All of the registerd supported types that can be parsed.
+    #
+    # All types defined here are set through #register.
+    #
+    def types
+      @types ||= []
+    end
+
+    #
+    # Add a new converter to the list of supported types. A converter
+    # is an object that adheres to the protocol which is defined with two
+    # methods #apply?(value,convert_to_type) and #apply(value).
+    #
+    # @example Defining a class that would process `nil` or values that have
+    #   already been converted.
+    #
+    #     class NilOrAlreadyConverted
+    #       def apply?(value,convert_to_type)
+    #         value.kind_of?(convert_to_type) || value.nil?
+    #       end
+    #
+    #       def apply(value)
+    #         value
+    #       end
+    #     end
+    #
+    #
+    def register(type_converter)
+      types.push type_converter
+    end
+
+    #
+    # An additional shortcut registration method that assumes that you want
+    # to perform a conversion on a specific type. A block is provided which
+    # is the operation to perform when #apply(value) has been called.
+    #
+    # @example Registering a DateTime parser
+    #
+    #     HappyMapper::SupportedTypes.register_type DateTime do |value|
+    #       DateTime.parse(value,to_s)
+    #     end
+    #
+    def register_type(type,&block)
+      register CastWhenType.new(type,&block)
+    end
+
+    #
+    # Many of the conversions are based on type. When the type specified
+    # matches then perform the action specified in the specified block.
+    # If no block is provided the value is simply returned.
+    #
+    class CastWhenType
+      attr_reader :type
+
+      def initialize(type,&block)
+        @type = type
+        @apply_block = block || no_operation
+      end
+
+      def no_operation
+        lambda {|value| value }
+      end
+
+      def apply?(value,convert_to_type)
+        convert_to_type == type
+      end
+
+      def apply(value)
+        @apply_block.call(value)
+      end
+    end
+
+    #
+    # For the cases when the value is nil or is already the
+    # intended type then no work needs to be done and the
+    # value simply can be returned.
+    #
+    class NilOrAlreadyConverted
+
+      def type
+        NilClass
+      end
+
+      def apply?(value,convert_to_type)
+        value.kind_of?(convert_to_type) || value.nil?
+      end
+
+      def apply(value)
+        value
+      end
+    end
+
+    register NilOrAlreadyConverted.new
+
+    register_type String do |value|
+      value.to_s
+    end
+
+    register_type Float do |value|
+      value.to_f
+    end
+
+    register_type Time do |value|
+      Time.parse(value.to_s) rescue Time.at(value.to_i)
+    end
+
+    register_type Date do |value|
+      Date.parse(value.to_s)
+    end
+
+    register_type DateTime do |value|
+      DateTime.parse(value.to_s)
+    end
+
+    register_type Boolean do |value|
+      ['true', 't', '1'].include?(value.to_s.downcase)
+    end
+
+    register_type Integer do |value|
+      value_to_i = value.to_i
+      if value_to_i == 0 && value != '0'
+        value_to_s = value.to_s
+        begin
+          Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+        rescue ArgumentError
+          nil
+        end
+      else
+        value_to_i
+      end
+    end
+
+  end
+
+end

data/lib/happymapper/text_node.rb

@@ -1,3 +1,8 @@
 module HappyMapper
-  class TextNode < Item; end
+  class TextNode < Item
+
+    def find(node, namespace, xpath_options)
+      yield(node.children.detect{|c| c.text?})
+    end
+  end
 end

data/lib/happymapper/version.rb

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

data/lib/happymapper.rb

@@ -1,21 +1,34 @@
 require 'nokogiri'
 require 'date'
 require 'time'
-
-class Boolean; end
-class XmlContent; end
+require 'happymapper/anonymous_mapper'
 
 module HappyMapper
+  class Boolean; end
+  class XmlContent; end
 
-  VERSION = "0.5.6"
+  extend AnonymousMapper
 
   DEFAULT_NS = "happymapper"
 
   def self.included(base)
-    base.instance_variable_set("@attributes", {})
-    base.instance_variable_set("@elements", {})
-    base.instance_variable_set("@registered_namespaces", {})
-    base.instance_variable_set("@wrapper_anonymous_classes", {})
+    if !(base.superclass <= HappyMapper)
+      base.instance_eval do
+        @attributes = []
+        @elements = []
+        @registered_namespaces = {}
+        @wrapper_anonymous_classes = {}
+      end
+    else
+      base.instance_eval do
+        @attributes = superclass.attributes.dup
+        @elements = superclass.elements.dup
+        @registered_namespaces =
+            superclass.instance_variable_get(:@registered_namespaces).dup
+        @wrapper_anonymous_classes =
+            superclass.instance_variable_get(:@wrapper_anonymous_classes).dup
+      end
+    end
 
     base.extend ClassMethods
   end
@@ -39,8 +52,7 @@ module HappyMapper
     #
     def attribute(name, type, options={})
       attribute = Attribute.new(name, type, options)
-      @attributes[to_s] ||= []
-      @attributes[to_s] << attribute
+      @attributes << attribute
       attr_accessor attribute.method_name.intern
     end
 
@@ -51,7 +63,7 @@ module HappyMapper
     #     an empty array is returned when there have been no attributes defined.
     #
     def attributes
-      @attributes[to_s] || []
+      @attributes
     end
 
     #
@@ -95,8 +107,7 @@ module HappyMapper
     #
     def element(name, type, options={})
       element = Element.new(name, type, options)
-      @elements[to_s] ||= []
-      @elements[to_s] << element
+      @elements << element
       attr_accessor element.method_name.intern
     end
 
@@ -108,7 +119,7 @@ module HappyMapper
     #     defined.
     #
     def elements
-      @elements[to_s] || []
+      @elements
     end
 
     #
@@ -305,9 +316,7 @@ module HappyMapper
         namespace = options[:namespace]
       elsif namespaces.has_key?("xmlns")
         namespace ||= DEFAULT_NS
-        default_namespace = namespaces.delete("xmlns")
-        namespaces[namespace] ||= default_namespace
-        namespaces["xmlns:#{namespaces.key(default_namespace)}"] = default_namespace
+        namespaces[DEFAULT_NS] = namespaces.delete("xmlns")
       elsif namespaces.has_key?(DEFAULT_NS)
         namespace ||= DEFAULT_NS
       end
@@ -372,7 +381,9 @@ module HappyMapper
           obj = options[:update] ? options[:update] : new
 
           attributes.each do |attr|
-            obj.send("#{attr.method_name}=",attr.from_xml_node(n, namespace, namespaces))
+            value = attr.from_xml_node(n, namespace, namespaces)
+            value = attr.default if value.nil?
+            obj.send("#{attr.method_name}=", value)
           end
 
           elements.each do |elem|
@@ -431,7 +442,14 @@ module HappyMapper
         collection
       end
     end
+  end
 
+  # Set all attributes with a default to their default values
+  def initialize
+    super
+    self.class.attributes.reject {|attr| attr.default.nil?}.each do |attr|
+      send("#{attr.method_name}=", attr.default)
+    end
   end
 
   #
@@ -481,6 +499,7 @@ module HappyMapper
       unless attribute.options[:read_only]
 
         value = send(attribute.method_name)
+        value = nil if value == attribute.default
 
         #
         # If the attribute defines an on_save lambda/proc or value that maps to
@@ -701,7 +720,8 @@ module HappyMapper
 
 end
 
-require File.dirname(__FILE__) + '/happymapper/item'
-require File.dirname(__FILE__) + '/happymapper/attribute'
-require File.dirname(__FILE__) + '/happymapper/element'
-require File.dirname(__FILE__) + '/happymapper/text_node'
+require 'happymapper/supported_types'
+require 'happymapper/item'
+require 'happymapper/attribute'
+require 'happymapper/element'
+require 'happymapper/text_node'

data/spec/attribute_default_value_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "Attribute Default Value" do
+
+  context "when given a default value" do
+
+    class Meal
+      include HappyMapper
+      tag 'meal'
+      attribute :type, String, :default => 'omnivore'
+    end
+
+    let(:subject) { Meal }
+    let(:default_meal_type) { 'omnivore' }
+
+    context "when no value has been specified" do
+      it "returns the default value" do
+        meal = subject.parse('<meal />')
+        expect(meal.type).to eq default_meal_type
+      end
+    end
+
+    context "when saving to xml" do
+
+      let(:expected_xml) { %{<?xml version="1.0"?>\n<meal/>\n} }
+
+      it "the default value is not included" do
+        meal = subject.new
+        expect(meal.to_xml).to eq expected_xml
+      end
+    end
+
+    context "when a new, non-nil value has been set" do
+      it "returns the new value" do
+        meal = subject.parse('<meal />')
+        meal.type = 'vegan'
+
+        expect(meal.type).to_not eq default_meal_type
+      end
+
+      let(:expected_xml) { %{<?xml version="1.0"?>\n<meal type="kosher"/>\n} }
+
+      it "saves the new value to the xml" do
+        meal = subject.new
+        meal.type = 'kosher'
+        expect(meal.to_xml).to eq expected_xml
+      end
+    end
+  end
+end

data/spec/fixtures/default_namespace_combi.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0"?>
-<bk:book xmlns="urn:ISBN:0-395-36341-6" xmlns:bk="urn:loc.gov:books">
+<bk:book xmlns:bk="urn:loc.gov:books" xmlns:p="urn:loc.gov:people" xmlns="urn:ISBN:0-395-36341-6">
+    <p:author>Frank Gilbreth</p:author>
     <bk:title>Cheaper by the Dozen</bk:title>
     <number>1568491379</number>
 </bk:book>

data/spec/happymapper/attribute_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe HappyMapper::Attribute do
+
+  describe "initialization" do
+    it 'accepts :default option' do
+      attr = described_class.new(:foo, String, :default => 'foobar')
+      attr.default.should == 'foobar'
+    end
+  end
+
+end

data/spec/happymapper/element_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe HappyMapper::Element do
+  describe "initialization" do
+    before do
+      @attr = HappyMapper::Element.new(:foo, String)
+    end
+  end
+end