unhappymapper 0.4.0

data/lib/happymapper/item.rb

@@ -0,0 +1,250 @@
+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)
+    #   :namespace => String Element's namespace if it's not the global or inherited
+    #                  default
+    #   :parser =>  Symbol Class method to use for type coercion.
+    #   :raw    =>  Boolean Use raw node value (inc. tags) when parsing.
+    #   :single =>  Boolean False if object should be collection, True for single object
+    #   :tag    =>  String Element name if it doesn't match the specified name.
+    def initialize(name, type, o={})
+      self.name = name.to_s
+      self.type = type
+      #self.tag = o.delete(:tag) || name.to_s
+      self.tag = o[:tag] || name.to_s
+      self.options = { :single => true }.merge(o.merge(:name => self.name))
+
+      @xml_type = self.class.to_s.split('::').last.downcase
+    end
+
+    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.to_s)
+          end
+        end
+      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
+      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
+      end
+    end
+
+    def xpath(namespace = self.namespace)
+      xpath  = ''
+      xpath += './/' if options[:deep]
+      xpath += "#{namespace}:" if namespace
+      xpath += tag
+      #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.
+    # 
+    # @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
+    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
+      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))
+          else
+            yield(node[tag])
+          end
+          
+        else # text node
+          yield(node.children.detect{|c| c.text?})
+        end
+      end
+
+      def handle_attributes_option(result, value, xpath_options)
+        if options[:attributes].is_a?(Hash)
+          result = result.first if result.respond_to?(:first)
+
+          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/text_node.rb

@@ -0,0 +1,3 @@
+module HappyMapper
+  class TextNode < Item; end
+end