atom 0.1 → 0.2

data/lib/atom.rb

@@ -133,6 +133,8 @@ module Atom
 		has_many :category, :name => 'category', :type => Category
 		has_one :content, :type => Content
 		has_one :source, :type => Source
+
+		has_many :extended_elements, :name => :any, :namespace => :any, :type => :raw
 	end
 
 	class Feed 

data/lib/xmlmapping.rb

@@ -26,131 +26,167 @@ require 'rexml/document'
 module XMLMapping
 	def self.included(mod)
 		mod.extend(ClassMethods)
-		mod.instance_variable_set("@attributes", {})
-		mod.instance_variable_set("@elements", {})
-		mod.instance_variable_set("@text_attribute", nil)
+
+		mod.instance_variable_set("@raw_mappings", {})
+		mod.instance_variable_set("@mappings", { :element => {}, :attribute => {}, :text => {}, :namespace => nil})
 	end
 
+
 	def initialize(input)
-		if input.respond_to? :to_str
-			root = REXML::Document.new(input).root
-		elsif input.respond_to?(:node_type) && input.node_type == :document
-			root = input.root
-		elsif input.respond_to?(:node_type) && input.node_type == :element
-			root = input
-		else 
-			raise "Invalid input: #{input}"
-		end
+		root = parse(input)
 
-		namespace = self.class.default_namespace
-		attributes = self.class.attributes
-		elements = self.class.elements
-		text_attribute = self.class.text_attribute
+		mappings = self.class.mappings
+		raw_mappings = self.class.raw_mappings
 
-		if !text_attribute.nil?
-			name = text_attribute[0]
-			options = text_attribute[1]
-			value = root.text
+		# initialize :many attributes
+		raw_mappings.values.select { |mapping| mapping[:cardinality] == :many }.each { |m|
+			instance_variable_set("@#{m[:attribute]}", [])
+		}
 
-			if options.has_key? :transform
-				value = options[:transform].call(value)
-			end
+		root.each_element { |e| 
+			process(e, mappings[:element])
+		}
+
+		root.attributes.each_attribute { |a|
+			process(a, mappings[:attribute])
+		}
 
+		mappings[:text].values.each { |mapping|
+			name = mapping[:attribute]
+			value = extract_value(root, mapping)
 			instance_variable_set("@#{name}", value)
+		}
+
+	end
+
+
+	private
+	def process(e, mappings)
+		mapping = find_mapping(mappings, e.namespace, e.name)
+
+			if !mapping.nil?
+				value = extract_value(e, mapping)
+
+				attribute = mapping[:attribute]
+				previous = instance_variable_get("@#{attribute}")
+				case mapping[:cardinality]
+					when :one 
+						raise "Found more than one #{e.name}" if !previous.nil?
+						instance_variable_set("@#{attribute}", value)
+					when :many 
+						previous << value
+				end		
+			end
+	end
+
+	def find_mapping(mappings, namespace, name)
+		mappings.values_at([namespace, name], [namespace, :any], [:any, :any] ).compact.first
+	end
+
+	def extract_value(node, mapping)
+		if mapping.has_key? :type
+			type = mapping[:type]
+			if type == :raw
+				value = node
+			else
+				value = mapping[:type].new(node)	
+			end
+		elsif node.node_type == :element
+			value = node.texts.map { |t| t.value }.to_s
+		elsif node.node_type == :attribute 
+			value = node.value
 		else
-			# initialize :many attributes
-			elements.select { |k, v|
-				v[:cardinality] == :many
-			}.each { |k, v|
-				instance_variable_set("@#{v[:attribute]}", [])
-			}
-
-			root.each_element { |e| 
-				if e.namespace == namespace && elements.has_key?(e.name.to_sym)
-					options = elements[e.name.to_sym]
-
-					if options.has_key? :type
-							value = options[:type].new(e)	
-					else
-							value = e.text
-					end
-
-					if options.has_key? :transform
-						value = options[:transform].call(value)
-					end
-
-					attribute = options[:attribute]
-
-					existing = instance_variable_get("@#{attribute}")
-					case options[:cardinality]
-						when :one 
-							raise "Found more than one #{e.name}" if !existing.nil?
-							instance_variable_set("@#{attribute}", value)
-						when :many 
-							existing << value
-					end		
-				end
-			}
+			raise "Unexpected node: #{node.inspect}"
 		end
 
-		root.attributes.each_attribute { |a|
-			if a.namespace == namespace && attributes.has_key?(a.name.to_sym)
-				options = attributes[a.name.to_sym]
+		if mapping.has_key? :transform
+			value = mapping[:transform].call(value)
+		end
 
-				value = a.value
-				if options.has_key? :transform
-					value = options[:transform].call(value)
-				end
+		value
+	end
 
-				instance_variable_set("@#{a.name}", value)
-			end
-		}
+	def parse(input)
+		if input.respond_to? :to_str
+			root = REXML::Document.new(input).root
+		elsif input.respond_to?(:node_type) && input.node_type == :document
+			root = input.root
+		elsif input.respond_to?(:node_type) && input.node_type == :element
+			root = input
+		else 
+			raise "Invalid input: #{input}"
+		end
+
+		root
 	end
 
 	module ClassMethods
-		attr :attributes
-		attr :elements
-		attr :text_attribute
-		attr :default_namespace
+		def raw_mappings
+			@raw_mappings || superclass.raw_mappings 
+		end
+
+		def mappings
+			@mappings || superclass.mappings 
+		end
 
 		def namespace(namespace)
-			@default_namespace = namespace
+			initialize_vars
+			@mappings[:namespace] = namespace	
 		end
 
 		def has_one(attribute, options = {})
-			attr attribute
 			options[:cardinality] = :one
-			options[:attribute] = attribute
-			
-			name = attribute
-			if options.has_key? :name
-				name = options[:name].to_sym
-			end
-
-			@elements[name] = options
+			add(attribute, :element, options)
 		end
 
 		def has_many(attribute, options = {})
-			attr attribute
 			options[:cardinality] = :many
-			options[:attribute] = attribute
-
-			name = attribute
-			if options.has_key? :name
-				name = options[:name].to_sym
-			end
-
-			@elements[name] = options
+			add(attribute, :element, options)
 		end
 
 		def has_attribute(attribute, options = {})
-			attr attribute
-			@attributes[attribute] = options
+			add(attribute, :attribute, options)
 		end	
 
 		def text(attribute, options = {})
+			options[:namespace] = :any
+			add(attribute, :text, options)
+		end
+
+		private 
+		def add(attribute, xml_type, mapping)
 			attr attribute
-			@text_attribute = [attribute, options]
+			
+			initialize_vars
+
+			mapping[:namespace] ||= mappings[:namespace]
+			mapping[:cardinality] ||= :one
+			mapping[:name] ||= attribute.to_s
+			mapping[:attribute] = attribute
+
+			qualified_name = [mapping[:namespace], mapping[:name]]
+			mappings = @mappings[xml_type][qualified_name] = mapping
+
+			@raw_mappings[attribute] = mapping
+		end
+
+		def initialize_vars
+			@mappings ||= deep_clone(superclass.mappings)
+			@raw_mappings ||= deep_clone(superclass.raw_mappings)
+		end
+
+		def deep_clone(obj)
+			case obj
+				when Hash	
+					obj.entries.inject({}) { |hash, entry|
+						hash[entry[0]] = deep_clone(entry[1])
+						hash
+					}
+				when Array
+					obj.map { |v| deep_clone[v] }
+				else
+					obj
+			end
 		end
 	end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: atom
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2006-04-06 00:00:00 -07:00
+  version: "0.2"
+date: 2006-04-08 00:00:00 -07:00
 summary: Ruby library for working with the Atom syndication format
 require_paths: 
 - lib