ginjo-rfm 3.0.4 → 3.0.5

data/lib/rfm/utilities/sax/fmpxml_minimal.yml

@@ -39,4 +39,9 @@ elements:
   attach: hash
   attach_attributes: hash
   delimiter: text
+# Experimental, but needs to be done.
+# - name: errorcode
+#   as_name: error
+#   attach: private
+#   compact: true
 

data/lib/rfm/utilities/sax/fmpxmllayout.yml

@@ -14,7 +14,7 @@ elements:
   attach: none
 - name: errorcode
   attach: none
-  before_close: 'check_for_errors'
+  before_close: :check_for_errors
   attributes:
   - name: text
     as_name: error
@@ -28,26 +28,42 @@ elements:
   - name: NAME
     as_name: name
 - name: field
-  # Used to be 'object.meta', but that required sloppy 'loaded' indicator handling (or infinite loop),
-  # so now just referring to raw inst var @meta, instead of method .meta.
-  handler: [object.instance_variable_get('@meta'), handle_new_field_control, _attributes]
+  attach:
+  - cursor
+  - Rfm::Metadata::FieldControl
+  - :new
+  - ivg(:meta)
+  # Must use before_close handler to attach, since field_mapping must be applied to value-list key name.
+  before_close: [object, ':element_close_handler']
+  # # Used to be 'object.meta', but that required sloppy 'loaded' indicator handling (or infinite loop),
+  # # so now just referring to raw inst var @meta, instead of method .meta.
+  # # Need to assume attributes may or may not be included in start_element call.
+  # handler: [object.instance_variable_get('@meta'), handle_new_field_control, _attributes]
+  # # attach_attributes isn't doing anything when used with new-element-handler.
   attach_attributes: private
+  delimiter: name
   elements:
+  # This config doesn't use the creation handler, so it should work with ox.
   - name: style
-    handler: [object, handle_style_element, _attributes]
-    # attach: none
-    # attributes:
-    # - name: valuelist
-    #   as_name: value_list_name
+    #element_handler: [object, handle_style_element, _attributes]
+    attach: none
+    #attach: [cursor, object, handle_style_element, _attributes]
+    #attach_attributes: none
+    attributes:
+    - name: valuelist
+      as_name: value_list_name
+      #translate: translate_style_value
 - name: valuelists
   attach: none
 - name: valuelist
-  class: Array
+  #class: Array
+  attach: [_meta, Array, ':new']
   as_name: value_lists
   delimiter: name
   elements:
   - name: value
-    class: Rfm::Metadata::ValueListItem
+    #class: Rfm::Metadata::ValueListItem
+    attach: [array, 'Rfm::Metadata::ValueListItem', ':allocate']
     before_close: replace(@value.to_s)
     attach_attributes: private
     attributes:

data/lib/rfm/utilities/sax/fmresultset.yml

@@ -16,33 +16,38 @@ elements:
 - name: product
 - name: error
   attach: none
-  before_close: 'check_for_errors'
+  before_close: :check_for_errors
   attributes:
   - name: code
     as_name: error
 - name: datasource
   attach: none
+  before_close: [object, end_datasource_element_callback, self]
   attributes:
   - name: total_count
     accessor: none
-  before_close: :end_datasource_element_callback
 - name:  metadata
   attach: none
 - name: field_definition
-  handler: [object.meta, handle_new_field, _attributes]
-  before_close: :main_callback
+  # These two steps can be used to create the attachment to resultset-meta automatically,
+  # but the field-mapping translation won't happen.
+  # attach: [_meta, 'Rfm::Metadata::Field', allocate]
+  # as_name: field_meta
+  attach: [cursor, 'Rfm::Metadata::Field', ':allocate']
+  delimiter: name
+  attach_attributes: private
+  before_close: [object, field_definition_element_close_callback, self]
 - name: relatedset_definition
   delimiter: table
   as_name: portal_meta
   attach_attributes: private
   elements:
   - name: field_definition
-    class: Rfm::Metadata::Field
-    attach: cursor
+    attach: [cursor, 'Rfm::Metadata::Field', ':allocate']
     delimiter: name
     as_name: field_meta
     attach_attributes: private
-    before_close: :portal_callback
+    before_close:  [object, relatedset_field_definition_element_close_callback, self]
 - name: resultset
   attach: none
   attributes:
@@ -51,32 +56,33 @@ elements:
   - name: fetch_size
     accessor: none
 - name: record
-  handler: [object, handle_new_record, _attributes]
+  #attach: [cursor, object, handle_new_record, _attributes]
+  #attach_attributes: none
+  attach: [array, 'Rfm::Record', new, object]
+  attach_attributes: private
   before_close: '@loaded=true'
   elements:
   - name: field
-    class: Rfm::Metadata::Datum
-    compact: true
-    attach: cursor
-    before_close: :handler_callback
+    attach: [cursor, 'Rfm::Metadata::Datum', ':allocate']
+    compact: false
+    before_close: [object, field_element_close_callback, self]
   - name: relatedset
-    class: Array
+    attach: [private, Array, ':allocate']
     as_name: portals
-    attach: private
     attach_attributes: private
     create_accessors: all
     delimiter: table
     elements:
     - name: record
-      class: Rfm::Record
+      #class: Rfm::Record
+      attach: [default, 'Rfm::Record', ':allocate']
       attach_attributes: private
       before_close: '@loaded=true'
       elements:
       - name: field
         compact: true
-        class: Rfm::Metadata::Datum
-        attach: cursor
-        before_close: :portal_callback
+        attach: [cursor, 'Rfm::Metadata::Datum', ':allocate']
+        before_close: [object, portal_field_element_close_callback, self]
 
 
 

data/lib/rfm/utilities/sax_parser.rb

@@ -1,3 +1,7 @@
+# encoding: UTF-8
+# Encoding is necessary for Ox, which appears to ignore character encoding.
+# See: http://stackoverflow.com/questions/11331060/international-chars-using-rspec-with-ruby-on-rails
+#
 # ####  A declarative SAX parser, written by William Richardson  #####
 #
 # This XML parser builds a result object from callbacks sent by any ruby sax/stream parsing
@@ -31,6 +35,13 @@
 # Note: 'attach: cursor' puts the object in the cursor & stack but does not attach it to the parent.
 #       'attach: none' prevents the object from entering the cursor or stack.
 #				Both of these will still allow processing of attributes and subelements.
+#
+# Note: Attribute attachment is controlled first by the attributes' model's :attributes hash (controls individual attrs),
+#       and second by the base model's main hash. Any model's main hash :attach_attributes only controls
+#       attributes that will be attached to that model's object. So if a model's object is not attached to anything
+#       (:attach=>'none'), then the higher base-model's :attach_attributes will control the lower model's attribute attachment.
+#       Put another way: If a model is :attach=>'none', then its :attach_attributes won't be counted.
+#
 #   
 # Examples:
 #   Rfm::SaxParser.parse('some/file.xml')  # => defaults to best xml backend with no parsing configuration.
@@ -43,20 +54,23 @@
 #
 # YAML structure defining a SAX xml parsing template.
 # Options:
-#   initialize:									array: initialize new objects with this code [:method, params] instead of defaulting to 'allocate'
+#   initialize_with:						string, symbol, or array (object, method, params...). Should return new object. See Rfm::SaxParser::Cursor#get_callback.
 #   elements:										array of element hashes [{'name'=>'element-tag'},...]
 #   attributes:									array of attribute hashes {'name'=>'attribute-name'} UC
-#   class: NOT USED							string-or-class: class name for new element
-#   depth:											integer: depth-of-default-class UC
-#		attach:											string: shared, _shared_name, private, hash, array, cursor, none - attach this element or attribute to parent. 
-#		attach_elements:						string: same as 'attach' - for all subelements, unless they have their own 'attach' specification
-#		attach_attributes:					string: same as 'attach' - for all attributes, unless they have their own 'attach' specification
-#   before_close:								symbol (method) or string (code): run a model method before closing tag, passing in #cursor. String is eval'd in context of object.
+#   class:                      string-or-class: class name for new element
+#		attach:											string: shared, _shared_var_name, private, hash, array, cursor, none - how to attach this element or attribute to #object. 
+#		attach_elements:						string: same as 'attach' - how to attach ANY subelements to this model's object, unless they have their own 'attach' specification.
+#		attach_attributes:					string: same as 'attach' - how to attach ANY attributes to this model's object, unless they have their own 'attach' specification.
+#   before_close:								string, symbol, or array (object, method, params...). See Rfm::SaxParser::Cursor#get_callback.
 #   as_name:										string: store element or attribute keyed as specified
 #   delimiter:									string: attribute/hash key to delineate objects with identical tags
-#		create_accessors: UC				string or array: all, private, shared, hash, none
-#		accessor:	UC								string: all, private, shared, hash, none
-#		handler:										array: call an object with any params [obj, method, params]. Default attach prefs are 'cursor'.
+#		create_accessors:   				string or array: all, private, shared, hash, none
+#		accessor:   								string: all, private, shared, hash, none
+#		element_handler:						string, symbol, or array (object, method, params...). Should return new object. See Rfm::SaxParser::Cursor#get_callback.
+# 															Default attach prefs are 'cursor'.
+#																Use this when all new-element operations should be offloaded to custom class or module.
+#																Should return an instance of new object.
+#   translate: UC               Consider adding a 'translate' option to point to a method on the current model's object to use to translate values for attributes.
 #
 #
 # ####  See below for notes & todos  ####
@@ -68,50 +82,58 @@ require 'stringio'
 
 module Rfm
 	module SaxParser
-		extend Forwardable
+	
+		RUBY_VERSION_NUM = RUBY_VERSION[0,3].to_f
 
 		PARSERS = {}
-		# OPTIONS constant not yet used.
-		# 	OPTIONS = [:name, :elements, :attributes, :attach, :attach_elements, :attach_attributes, :compact,
-		# 						:depth, :before_close, :each_before_close, :delimiter, :as_name, :initialize, :handler
-		# 						]
-		DEFAULTS = [:default_class, :backend, :text_label, :tag_translation, :shared_instance_var, :templates, :template_prefix]
 		
-
-		class << self
-			attr_accessor *DEFAULTS
-		end
-	
-		### Default class MUST be a descendant of Hash or respond to hash methods !!!
-		(@default_class = Hash) unless defined? @default_class
-		
-		# Use :libxml, :nokogiri, :ox, :rexml, or anything else, if you want it to always default
+		# These defaults can be set here or in any ancestor/enclosing module or class,
+		# as long as the defaults or their constants can be seen from this POV.
+		#
+		#	Default class MUST be a descendant of Hash or respond to hash methods !!!
+		# 	
+		# For backend, use :libxml, :nokogiri, :ox, :rexml, or anything else, if you want it to always default
 		# to something other than the fastest backend found.
-		# Nil will let the SaxParser decide.
-		(@backend = nil) unless defined? @backend
-		
-		(@text_label = 'text') unless defined? @text_label
-		
-		(@tag_translation = lambda {|txt| txt.gsub(/\-/, '_').downcase}) unless defined? @tag_translation
-		
-		(@shared_instance_var = 'attributes') unless defined? @shared_instance_var		
-			
-		(@templates = {}) unless defined? @templates
+		# Using nil will let the SaxParser decide.
+		@parser_defaults = {
+			:default_class => Hash,
+			:backend => nil,
+			:text_label => 'text',
+			:tag_translation => lambda {|txt| txt.gsub(/\-/, '_').downcase},
+			:shared_variable_name => 'attributes',
+			:templates => {},
+			:template_prefix => nil
+		}
 		
-		def self.parse(*args)
-			Handler.build(*args)
+		# Merge any upper-level default definitions
+		if defined? PARSER_DEFAULTS
+			tmp_defaults = PARSER_DEFAULTS.dup
+			PARSER_DEFAULTS.replace(@parser_defaults).merge!(tmp_defaults)
+		else
+			PARSER_DEFAULTS = @parser_defaults
 		end
 
-		# Installs attribute accessors for defaults
-		def self.install_defaults(klass)
-			klass.extend Forwardable		    
-	    klass.def_delegators SaxParser, *DEFAULTS
-			class << klass
-				extend Forwardable
-				def_delegators SaxParser, *DEFAULTS
-			end		
+		# Convert defaults to constants, available to all sub classes/modules/instances.
+		PARSER_DEFAULTS.each do |k, v|
+			k = k.to_s.upcase
+			#(const_set k, v) unless eval("defined? #{k}")   #(const_defined?(k) or defined?(k))
+			if eval("defined? #{k}")
+				(const_set k, eval(k))
+			else
+				(const_set k, v)
+			end
 		end
+		
+		::Object::ATTACH_OBJECT_DEFAULT_OPTIONS = {
+			:shared_variable_name => SHARED_VARIABLE_NAME,
+			:default_class => DEFAULT_CLASS,
+			:text_label => TEXT_LABEL,
+			:create_accessors => [] #:all, :private, :shared, :hash
+		}		
 
+		def self.parse(*args)
+			Handler.build(*args)
+		end
 
 		# A Cursor instance is created for each element encountered in the parsing run
 		# and is where the parsing result is constructed from the custom parsing template.
@@ -125,11 +147,17 @@ module Rfm
 		# you will always get the last object added to the stack. Think of a cursor as
 		# a framework of tools that accompany each element's build process.
 		class Cursor
-		
-		    #attr_accessor :model, :object, :tag, :parent, :top, :stack, :newtag, :callbacks
-		    attr_accessor :model, :object, :tag, :newtag, :callbacks, :handler, :parent  #, :top, :stack,
+				extend Forwardable
+
+				# model - currently active model (rename to current_model)
+				# local_model - model of this cursor's tag (rename to local_model)
+				# newtag - incoming tag of yet-to-be-created cursor. Get rid of this if you can.
+				# element_attachment_prefs - local object's attachment prefs based on local_model and current_model.
+				# level - cursor depth
+		    attr_accessor :model, :local_model, :object, :tag, :handler, :parent, :level, :element_attachment_prefs, :new_element_callback, :initial_attributes  #, :newtag
 		    
-				SaxParser.install_defaults(self)
+		    
+				#SaxParser.install_defaults(self)
 				
 				def_delegators :handler, :top, :stack
 		    
@@ -139,157 +167,234 @@ module Rfm
 			  	
 			  	case
 			  	when klass.is_a?(Class); klass
-			  	when (klass=klass.to_s) == ''; default_class
+			  	#when (klass=klass.to_s) == ''; DEFAULT_CLASS
+  		  	when klass.nil?; DEFAULT_CLASS
+			  	when klass == ''; DEFAULT_CLASS
 			  	when klass[/::/]; eval(klass)
 			  	when defined?(klass); const_get(klass)  ## == 'constant'; const_get(klass)
-			  	#when defined?(klass); eval(klass) # This was for 'handler' pattern.
+			  	#when defined?(klass); eval(klass) # This was for 'element_handler' pattern.
 			  	else
 			  		Rfm.log.warn "Could not find constant '#{klass}'"
-			  		default_class
+			  		DEFAULT_CLASS
 			  	end
 
 			  end
 		    
-		    def initialize(_model, _obj, _tag, _handler)
-		    	@tag     = _tag
-		    	@model   = _model
-		    	@object  = _obj       #_obj.is_a?(String) ? get_constant(_obj).new : _obj
-		    	@callbacks = {}
+		    def initialize(_tag, _handler, _parent=nil, _initial_attributes=nil) #, caller_binding=nil)
+		    #def initialize(_model, _obj, _tag, _handler)
+		    	@tag     =  _tag
 		    	@handler = _handler
+		    	@parent = _parent || self
+		    	@initial_attributes = _initial_attributes
+		    	@level = @parent.level.to_i + 1
+		    	@local_model = (model_elements?(@tag, @parent.model) || DEFAULT_CLASS.new)
+		    	@element_attachment_prefs = attachment_prefs(@parent.model, @local_model, 'element')
+		    	#@attribute_attachment_prefs = attachment_prefs(@parent.model, @local_model, 'attribute')
+		    	
+		    	if @element_attachment_prefs.is_a? Array
+			    	@new_element_callback = @element_attachment_prefs[1..-1]
+			    	@element_attachment_prefs = @element_attachment_prefs[0]
+			    	if @element_attachment_prefs.to_s == 'default'; @element_attachment_prefs = nil; end
+			    end
+			    
+			   	#puts ["\nINITIALIZE_CURSOR tag: #{@tag}", "parent.object: #{@parent.object.class}", "local_model: #{@local_model.class}", "el_prefs: #{@element_attachment_prefs}",  "new_el_callback: #{@new_element_callback}", "attributes: #{@initial_attributes}"]
+
 		    	self
 		    end
 		    
-		    def handler
-		    	@handler
-		    end
-		    
-		    
 		    
 		    #####  SAX METHODS  #####
 		    
-		    # Not sure if this is still used.
+		    # Receive a single attribute (any named attribute or text)
 			  def receive_attribute(name, value)
-			  	#puts "\nRECEIVE_ATTR '#{name}' value '#{value}' object '#{object.class}' model '#{model.keys}' subm '#{submodel.keys}' tag '#{tag}' newtag '#{newtag}'"
-			  	new_att = default_class.new.tap{|att| att[name]=value}
-			  	assign_attributes(new_att, object, model, model)
+			  	#puts ["\nRECEIVE_ATTR '#{name}'", "value: #{value}", "tag: #{@tag}", "object: #{object.class}", "model: #{model['name']}"]
+			  	new_att = {name=>value}    #.new.tap{|att| att[name]=value}
+
+			  	assign_attributes(new_att) #, @object, @model, @local_model)
 			  rescue
 			  	Rfm.log.warn "Error: could not assign attribute '#{name.to_s}' to element '#{self.tag.to_s}': #{$!}"
 			  end
-		        
+			  
 		    def receive_start_element(_tag, _attributes)
-		    # TODO: Use a case statement to separate the various tasks possible in this method
+			    #puts ["\nRECEIVE_START '#{_tag}'", "current_object: #{@object.class}", "current_model: #{@model}"]
+					new_cursor = Cursor.new(_tag, @handler, self, _attributes) #, binding)
+					new_cursor.process_new_element(binding)
+
+		      new_cursor
+		    end # receive_start_element
+		    
+		    # Decides how to attach element & attributes associated with this cursor.
+		    def process_new_element(caller_binding=binding)
+		    
+		    	#puts ["\nPROCESS_NEW_ELEMENT tag: #{@tag}", "@element_attachment_prefs: #{@element_attachment_prefs}", "@local_model: #{local_model}"]
+		    
+		    	new_element = @new_element_callback ? get_callback(@new_element_callback, caller_binding) : nil
 		    	
+		    	case
 		    	
-		    	#puts ['START', _tag, object.class, model]
-		    	# Set newtag for other methods to use during the start_el run.
-					@newtag = _tag
-					
-		    	# Acquire submodel definition.
-		      subm = model_elements?(@newtag) || default_class.new
-		      
-		      # Get attachment_prefs
-		      prefs = attachment_prefs(model, subm, 'element')
-		      
-		      #puts "RECEIVE_START_ELEMENT: _tag '#{_tag}'\ncurrent object '#{object.class}'\ncursor_model '#{model}'\ncursor_submodel '#{subm.to_yaml}', attributes '#{_attributes.to_a}'"
-		      
-		      # Clean-up and return if new element is not to be attached.
-		    	if prefs == 'none'
-		    		# Set callbacks, since object & model of new element won't be stored.
-		    		callbacks[_tag] = lambda {run_callback(_tag, self, subm)}
-		    		#puts "Assigning attributes for attach:none on #{newtag}"
-		    		# This passes current model, since that is the model that will be accepting thiese attributes, if any.
-		    		assign_attributes(_attributes, object, model, subm)
-		    		return
-		    	end		      
-		      
-		      if handler?(subm)
-		      	code = handler?(subm)
-		      	obj = eval(code[0].to_s)
-		      	mthd = code[1].to_s
-		      	prms = eval(code[2].to_s)
-		      	new_element = obj.send(mthd, prms)
-		      	#puts ["\nIF_HANDLER", code, new_element.class, new_element]
-		      else
-			      # Create new element.
-			      const = get_constant(subm['class'])
-			      # Needs to be duped !!!
-			      init = initialize?(subm) ? initialize?(subm).dup : []
-			      #puts init.to_yaml
-			      init[0] ||= :allocate
-			      init[1] = eval(init[1].to_s)
-			      #puts "Current object: #{eval('object').class}"
-			      #puts "Creating new element '#{const}' with '#{init[0]}' and '#{init[1].class}'"
-			      new_element = const.send(*init.compact)
-			      #puts "Created new element of class '#{new_element.class}' for _tag '#{tag}'."
+		    	# when inital cursor, just set model & object.
+		    	when @tag == '__TOP__';
+						#puts "__TOP__"
+		    	  @model = @handler.template
+		    	  @object = @handler.initial_object
+		    	
+		    	when @element_attachment_prefs == 'none';
+		    		#puts "__NONE__"
+		    	  @model = @parent.model #nil
+		    	  @object = @parent.object #nil
+		    	  
+		    	  if @initial_attributes && @initial_attributes.any? #&& @attribute_attachment_prefs != 'none'
+			    	  assign_attributes(@initial_attributes) #, @object, @model, @local_model) 
+			    	end
+		    	
+	    		when @element_attachment_prefs == 'cursor';
+	    			#puts "__CURSOR__"
+	    		  @model = @local_model
+            @object = new_element || DEFAULT_CLASS.allocate
+
+						if @initial_attributes && @initial_attributes.any? #&& @attribute_attachment_prefs != 'none'
+			    	  assign_attributes(@initial_attributes) #, @object, @model, @local_model) 
+			    	end
+		      	
+	    		else
+	    			#puts "__OTHER__"
+	    		  @model = @local_model
+						@object = new_element || DEFAULT_CLASS.allocate
 			      
-			      # Assign attributes to new element.
-			      assign_attributes(_attributes, new_element, subm, subm) #unless attach_attributes?(subm) == 'none'
-	
-						# Attach new element to cursor object
-						attach_new_object(object, new_element, newtag, model, subm, 'element') #unless prefs == 'cursor'
-		  		end
-		  		
-		  		returntag = newtag
-		  		self.newtag = nil
-		      Cursor.new(subm, new_element, returntag, handler)
-		    end # start_el
-		
+						if @initial_attributes && @initial_attributes.any? #&& @attribute_attachment_prefs != 'none'
+			    	  assign_attributes(@initial_attributes) #, @object, @model, @local_model) 
+			    	end
+			      
+						if !delimiter?(@local_model) 
+  						#attach_new_object(@parent.object, @object, @tag, @parent.model, @local_model, 'element')
+  						attach_new_element(@tag, @object)
+  					end  		
+		    	end
+
+          self
+		  	end
+
+		    		
 		    def receive_end_element(_tag)
-		    	#puts ["\nEND_ELEMENT #{_tag}", "CurrentObject: #{object.class}", "CurrentTag: #{self.tag}", "CurrentModel: #{model}", "BeforeClose: #{before_close?}", "Compact: #{compact?}"]
+		    	#puts ["\nRECEIVE_END_ELEMENT '#{_tag}'", "tag: #{@tag}", "object: #{@object.class}", "model: #{@model['name']}", "local_model: #{@local_model['name']}"]
+		    	#puts ["\nEND_ELEMENT_OBJECT", object.to_yaml]
 	      	begin
-						if _tag == self.tag
+	      		      	
+						if _tag == @tag && (@model == @local_model)
 		      		# Data cleaup
-							compactor_settings = compact?
-							(compactor_settings = compact?(top.model)) unless compactor_settings # prefer local settings, or use top settings.
+							compactor_settings = compact? || compact?(top.model)
+							#(compactor_settings = compact?(top.model)) unless compactor_settings # prefer local settings, or use top settings.
 							(clean_members {|v| clean_members(v){|v| clean_members(v)}}) if compactor_settings
 						end
-	      	
-						# 	# EXPERIMENTAL: sending modle PLUS submodel prefs to _create_accessors
-						# 	# Acquire submodel definition for create accessors (EXPERIMENTAL)
-						#   subm = model_elements?(_tag) || default_class.new
-						# 	accessor_options = (create_accessors? | create_accessors?(subm))
-						# 	if accessor_options.any?
-						# 		#puts ["CREATING_ACCESSORS #{accessor_options}"]
-						#   	object._create_accessors(accessor_options)
-						#   end	      		
-	      		
-						# 		# Create accessors is specified.
-						# 		# TODO: This creates redundant calls when elements close with the same model as current. But how to get the correct model when elements close that are attach:none  ???
-						# 		if create_accessors?.any?
-						# 			#puts ['CREATING_ACCESSORS', create_accessors?]
-						#     	object._create_accessors(create_accessors?)
-						#     end
-	      	
-	      		# Run callback of non-stored element.
-	      		callbacks[_tag].call if callbacks[_tag]
-		      	if _tag == self.tag
+						
+	      		if (delimiter = delimiter?(@local_model); delimiter && !['none','cursor'].include?(@element_attachment_prefs.to_s))
+  						#attach_new_object(@parent.object, @object, @tag, @parent.model, @local_model, 'element')
+  						attach_new_element(@tag, @object)
+  					end  		
+
+		      	if _tag == @tag #&& (@model == @local_model)
 							# End-element callbacks.
-							run_callback(_tag, self)
-							# 	if before_close?.is_a? Symbol
-							# 		object.send before_close?, self
-							# 	elsif before_close?.is_a?(String)
-							# 		object.send :eval, before_close?
-							# 	end
+							#run_callback(_tag, self)
+							callback = before_close?(@local_model)
+							get_callback(callback, binding) if callback
 						end
 						
-						# return true only if matching tags
-						if _tag == self.tag
+						if _tag == @tag
+							# return true only if matching tags
 							return true
 						end
-# 		      rescue
-# 		      	Rfm.log.warn "Error: end_element tag '#{_tag}' failed: #{$!}"
+						
+            # # return true only if matching tags
+            # if _tag == @tag
+            #   return true
+            # end
+						
+						return
+# 					rescue
+# 					 Rfm.log.debug "Error: end_element tag '#{_tag}' failed: #{$!}"
 		      end
 		    end
-
-				def run_callback(_tag, _cursor=self, _model=_cursor.model, _object=_cursor.object )
-	    		callback = before_close?(_model)
-	    		#puts ["\nRUN_CALLBACK", _tag, _cursor.tag, _object.class, callback]
-	      	if callback.is_a? Symbol
-	      		_object.send callback, _cursor
-	      	elsif callback.is_a?(String)
-	      		_object.send :eval, callback
-	      	end
-	      end
+		    
+		    ###  Parse callback instructions, compile & send callback method  ###
+		    # This method will send a method to an object, with parameters, and return a new object.
+		    # Input: string, symbol, or array of strings
+		    # Returns: object
+		    # Default options:
+		    #   :object=>object
+		    #   :method=>'a method name string or symbol'
+		    #   :params=>"params string to be eval'd in context of cursor"
+		    # Usage:
+		    #   callback: send a method (or eval string) to an object with parameters.
+		    #   string: a string to be eval'd in context of current object.
+		    #   symbol: method to be called on current object.
+		    #   array: object, method, params.
+		    #     object: <object or string>
+		    #     method: <string or symbol>
+		    #     params: <string>
+		    #
+		    # TODO-MAYBE: Change param order to (method, object, params),
+		    #             might help confusion with param complexities.
+		    #
+		    def get_callback(callback, caller_binding=binding, defaults={})
+		      input = callback.is_a?(Array) ? callback.dup : callback
+		      #puts "\nGET_CALLBACK tag: #{tag}, callback: #{callback}"
+		      params = case
+	        when input.is_a?(String) || input.is_a?(Symbol)
+	          [nil, input]
+          # when input.is_a?(Symbol)
+          #   [nil, input]
+          when input.is_a?(Array)
+          	#puts ["\nCURSOR#get_callback is an array", input]
+            case
+            when input[0].is_a?(Symbol)
+              [nil, input].flatten(1)
+            when input[1].is_a?(String) && ( input.size > 2 || (remove_colon=(input[1][0,1]==":"); remove_colon) )
+              code_or_method = input[1].dup
+            	code_or_method[0]='' if remove_colon
+              code_or_method = code_or_method.to_sym
+              output = [input[0], code_or_method, input[2..-1]].flatten(1)
+              #puts ["\nCURSOR#get_callback converted input[1] to symbol", output]
+              output
+            else # when input is ['object', 'sym-or-str', 'param1',' param2', ...]
+              input
+            end
+          else
+            []
+          end
+          
+          obj_raw = params.shift
+          #puts ["\nOBJECT_RAW:","class: #{obj_raw.class}", "object: #{obj_raw}"]
+          obj = if obj_raw.is_a?(String); eval(obj_raw.to_s, caller_binding); else obj_raw; end
+          if obj.nil? || obj == ''; obj = defaults[:object] || @object; end
+          #puts ["\nOBJECT:","class: #{obj.class}", "object: #{obj}"]
+            
+          code = params.shift || defaults[:method]
+          params.each_with_index{|str,i| if str.is_a?(String); params[i] = eval(str, caller_binding); end }
+          params = defaults[:params] if params.size == 0
+         	#puts ["\nGET_CALLBACK tag: #{@tag}" ,"callback: #{callback}", "obj.class: #{obj.class}", "code: #{code}", "params-class #{params.class}"]
+          case
+          when (code.nil? || code=='')
+          	obj
+          when (code.is_a?(Symbol) || params)
+	          #puts ["\nGET_CALLBACK sending symbol", obj.class, code] 
+            obj.send *[code, params].flatten(1).compact
+          when code.is_a?(String)
+          	#puts ["\nGET_CALLBACK evaling string", obj.class, code]
+            obj.send :eval, code
+            #eval(code, caller_binding)
+          end		      
+        end
+        
+        # # Run before-close callback.
+        # def run_callback(_tag, _cursor=self, _model=_cursor.local_model, _object=_cursor.object )
+        #   callback = before_close?(_model)
+        #   #puts ["\nRUN_CALLBACK", _tag, _cursor.tag, _object.class, callback, callback.class]
+        #   if callback.is_a? Symbol
+        #     _object.send callback, _cursor
+        #   elsif callback.is_a?(String)
+        #     _object.send :eval, callback
+        #   end
+        # end
 
 
 
@@ -297,52 +402,91 @@ module Rfm
 				#####  MERGE METHODS  #####
 				
 		  	# Assign attributes to element.
-				def assign_attributes(_attributes, base_object, base_model, new_model)
+				def assign_attributes(_attributes)
 		      if _attributes && !_attributes.empty?
 
-		      	#puts ["\nASSIGN_ATTRIBUTES", base_object.class, base_model, new_model].join(' **** ')
-
-						# 	# This is trying to merge element set as a whole, if possible.
-						# 	# Experimental #
-						# 	#
-						# 	# OLD: prefs_exist = model_attributes?(nil, new_model) || attach_attributes?(base_model) || delimiter?(base_model)
-						# 	attribute_prefs =  attach_attributes?(base_model)
-						# 	case
-						# 	when !model_attributes?(nil, base_model) && attribute_prefs.to_s[/shared|_/]
-						# 		shared_var_name = shared_variable_name(attribute_prefs) || 'attributes'
-						# 		#puts ["MASS", attribute_prefs, shared_var_name, _attributes.keys].join(', ')
-						# 		#attach_new_object(base_object, _attributes, shared_var_name, base_model, new_model, 'attribute')
-						# 		#base_object._attach_object!(_attributes, shared_var_name, nil, 'private', 'attribute', :default_class=>default_class, :create_accessors=>create_accessors?(base_model))
-						# 		(var = ivg(shared_var_name, base_object)) ? var.merge!(_attributes) : ivs(shared_var_name, _attributes, base_object)
-						# 	else
-						# 		#puts "Loading attributes individually."
-						# 		#puts ["INDIVIDUAL", attribute_prefs, _attributes.keys].join(', ')
-						_attributes.each{|k,v| attach_new_object(base_object, v, k, base_model, model_attributes?(k, new_model), 'attribute')}
-	 					#		end
+						_attributes.each do |k,v|
+							#attach_new_object(base_object, v, k, base_model, model_attributes?(k, new_model), 'attribute')}
+							attr_model = model_attributes?(k, @local_model)
+							
+							label = label_or_tag(k, attr_model)
+							
+							prefs = [attachment_prefs(@model, attr_model, 'attribute')].flatten(1)[0]
+							
+							shared_var_name = shared_variable_name(prefs)
+							(prefs = "shared") if shared_var_name
+							
+							# Use local create_accessors prefs first, then more general ones.
+							create_accessors = accessor?(attr_model) || create_accessors?(@model)
+							#(create_accessors = create_accessors?(@model)) unless create_accessors && create_accessors.any?
+							
+							#puts ["\nATTACH_NEW_OBJECT 1", "type: #{type}", "label: #{label}", "base_object: #{base_object.class}", "new_object: #{new_object.class}", "delimiter: #{delimiter?(new_model)}", "prefs: #{prefs}", "shared_var_name: #{shared_var_name}", "create_accessors: #{create_accessors}"]
+							@object._attach_object!(v, label, delimiter?(attr_model), prefs, 'attribute', :default_class=>DEFAULT_CLASS, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors)
+	 					end
+	 					
 		      end
 				end
 								
-				def attach_new_object(base_object, new_object, name, base_model, new_model, type)
-					label = label_or_tag(name, new_model)
+				# 	def attach_new_object(base_object, new_object, name, base_model, new_model, type)
+				# 		label = label_or_tag(name, new_model)
+				# 		
+				# 		# Was this, which works fine, but not as efficient:
+				# 		# prefs = [attachment_prefs(base_model, new_model, type)].flatten(1)[0]
+				# 		prefs = if type=='attribute'
+				# 			[attachment_prefs(base_model, new_model, type)].flatten(1)[0]
+				# 		else
+				# 			@element_attachment_prefs
+				# 		end
+				# 		
+				# 		shared_var_name = shared_variable_name(prefs)
+				# 		(prefs = "shared") if shared_var_name
+				# 		
+				# 		# Use local create_accessors prefs first, then more general ones.
+				# 		create_accessors = accessor?(new_model)
+				# 		(create_accessors = create_accessors?(base_model)) unless create_accessors && create_accessors.any?
+				# 		
+				#     # # This is NEW!
+				#     # translator = new_model['translator']
+				#     # if translator
+				#     #   new_object = base_object.send translator, name, new_object
+				#     # end
+				# 		
+				# 		
+				# 		#puts ["\nATTACH_NEW_OBJECT 1", "type: #{type}", "label: #{label}", "base_object: #{base_object.class}", "new_object: #{new_object.class}", "delimiter: #{delimiter?(new_model)}", "prefs: #{prefs}", "shared_var_name: #{shared_var_name}", "create_accessors: #{create_accessors}"]
+				# 		base_object._attach_object!(new_object, label, delimiter?(new_model), prefs, type, :default_class=>DEFAULT_CLASS, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors)
+				# 		#puts ["\nATTACH_NEW_OBJECT 2: #{base_object.class} with ", label, delimiter?(new_model), prefs, type, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors]
+				#     # if type == 'attribute'
+				#     #   puts ["\nATTACH_ATTR", "name: #{name}", "label: #{label}", "new_object: #{new_object.class rescue ''}", "base_object: #{base_object.class rescue ''}", "base_model: #{base_model['name'] rescue ''}", "new_model: #{new_model['name'] rescue ''}", "prefs: #{prefs}"]
+				#     # end
+				# 	end
+				
+				def attach_new_element(name, new_object)   #(base_object, new_object, name, base_model, new_model, type)
+					label = label_or_tag(name, @local_model)
 					
-					prefs = attachment_prefs(base_model, new_model, type)
+					# Was this, which works fine, but not as efficient:
+					# prefs = [attachment_prefs(base_model, new_model, type)].flatten(1)[0]
+					prefs = @element_attachment_prefs
 					
-					# 	shared_var_name = nil
-					# 	if prefs.to_s[0,1] == "_"
-					# 		shared_var_name = prefs.to_s[1,16]
-					# 		prefs = "shared"
-					# 	end
-					shared_var_name = shared_variable_name prefs
+					shared_var_name = shared_variable_name(prefs)
 					(prefs = "shared") if shared_var_name
 					
 					# Use local create_accessors prefs first, then more general ones.
-					create_accessors = accessor?(new_model)
-					(create_accessors = create_accessors?(base_model)) unless create_accessors && create_accessors.any?
+					create_accessors = accessor?(@local_model) || create_accessors?(@parent.model)
+					#(create_accessors = create_accessors?(@parent.model)) unless create_accessors && create_accessors.any?
+					
+          # # This is NEW!
+          # translator = new_model['translator']
+          # if translator
+          #   new_object = base_object.send translator, name, new_object
+          # end
 					
 					
-					#puts ["\nCURSOR.attach_new_object 1", type, label, base_object.class, new_object.class, delimiter?(new_model), prefs, shared_var_name, create_accessors].join(', ')
-					base_object._attach_object!(new_object, label, delimiter?(new_model), prefs, type, :default_class=>default_class, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors)
-					#puts ["\nCURSOR.attach_new_object 2: #{base_object.class} with ", label, delimiter?(new_model), prefs, type, :default_class=>default_class, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors]
+					#puts ["\nATTACH_NEW_ELEMENT 1", "type: #{type}", "label: #{label}", "base_object: #{base_object.class}", "new_object: #{new_object.class}", "delimiter: #{delimiter?(new_model)}", "prefs: #{prefs}", "shared_var_name: #{shared_var_name}", "create_accessors: #{create_accessors}"]
+					@parent.object._attach_object!(new_object, label, delimiter?(@local_model), prefs, 'element', :default_class=>DEFAULT_CLASS, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors)
+					#puts ["\nATTACH_NEW_ELEMENT 2: #{base_object.class} with ", label, delimiter?(new_model), prefs, type, :shared_variable_name=>shared_var_name, :create_accessors=>create_accessors]
+          # if type == 'attribute'
+          #   puts ["\nATTACH_ATTR", "name: #{name}", "label: #{label}", "new_object: #{new_object.class rescue ''}", "base_object: #{base_object.class rescue ''}", "base_model: #{base_model['name'] rescue ''}", "new_model: #{new_model['name'] rescue ''}", "prefs: #{prefs}"]
+          # end
 				end
 				
 				def attachment_prefs(base_model, new_model, type)
@@ -355,7 +499,7 @@ module Rfm
 				def shared_variable_name(prefs)
 					rslt = nil
 					if prefs.to_s[0,1] == "_"
-						rslt = prefs.to_s[1,16] #prefs.gsub(/^_/, '')
+						rslt = prefs.to_s[1..-1] #prefs.gsub(/^_/, '')
 					end
 				end
 
@@ -367,30 +511,32 @@ module Rfm
 			  end
 			  
 			  # Methods for current _model
-			  def ivg(name, _object=object); _object.instance_variable_get "@#{name}"; end
-			  def ivs(name, value, _object=object); _object.instance_variable_set "@#{name}", value; end
-			  def model_elements?(which=nil, _model=model); _model && _model.has_key?('elements') && ((_model['elements'] && which) ? _model['elements'].find{|e| e['name']==which} : _model['elements']) ; end
-			  def model_attributes?(which=nil, _model=model); _model && _model.has_key?('attributes') && ((_model['attributes'] && which) ? _model['attributes'].find{|a| a['name']==which} : _model['attributes']) ; end
-			  def depth?(_model=model); _model && _model['depth']; end
-			  def before_close?(_model=model); _model && _model['before_close']; end
-			  def each_before_close?(_model=model); _model && _model['each_before_close']; end
-			  def compact?(_model=model); _model && _model['compact']; end
-			  def attach?(_model=model); _model && _model['attach']; end
-			  def attach_elements?(_model=model); _model && _model['attach_elements']; end
-			  def attach_attributes?(_model=model); _model && _model['attach_attributes']; end
-			  def delimiter?(_model=model); _model && _model['delimiter']; end
-			  def as_name?(_model=model); _model && _model['as_name']; end
-			  def initialize?(_model=model); _model && _model['initialize']; end
-			  def create_accessors?(_model=model); _model && [_model['create_accessors']].flatten.compact; end
-			  def accessor?(_model=model); _model && [_model['accessor']].flatten.compact; end
-			  def handler?(_model=model); _model && _model['handler']; end
+			  def ivg(name, _object=@object); _object.instance_variable_get "@#{name}"; end
+			  def ivs(name, value, _object=@object); _object.instance_variable_set "@#{name}", value; end
+			  def model_elements?(which=nil, _model=@model); _model && _model.has_key?('elements') && ((_model['elements'] && which) ? _model['elements'].find{|e| e['name']==which} : _model['elements']) ; end
+			  def model_attributes?(which=nil, _model=@model); _model && _model.has_key?('attributes') && ((_model['attributes'] && which) ? _model['attributes'].find{|a| a['name']==which} : _model['attributes']) ; end
+			  def depth?(_model=@model); _model && _model['depth']; end
+			  def before_close?(_model=@model); _model && _model['before_close']; end
+			  def each_before_close?(_model=@model); _model && _model['each_before_close']; end
+			  def compact?(_model=@model); _model && _model['compact']; end
+			  def attach?(_model=@model); _model && _model['attach']; end
+			  def attach_elements?(_model=@model); _model && _model['attach_elements']; end
+			  def attach_attributes?(_model=@model); _model && _model['attach_attributes']; end
+			  def delimiter?(_model=@model); _model && _model['delimiter']; end
+			  def as_name?(_model=@model); _model && _model['as_name']; end
+			  def initialize_with?(_model=@model); _model && _model['initialize_with']; end
+			  def create_accessors?(_model=@model); _model && _model['create_accessors'] && [_model['create_accessors']].flatten.compact; end
+			  def accessor?(_model=@model); _model && _model['accessor'] && [_model['accessor']].flatten.compact; end
+			  def element_handler?(_model=@model); _model && _model['element_handler']; end
 			  
 
 			  # Methods for submodel
-				def label_or_tag(_tag=newtag, new_model=submodel); as_name?(new_model) || _tag; end
+			  
+			  # This might be broken.
+				def label_or_tag(_tag=@tag, new_model=@local_model); as_name?(new_model) || _tag; end
 
 				
-		    def clean_members(obj=object)
+		    def clean_members(obj=@object)
 		    	#puts ["CURSOR.clean_members: #{object.class}", "tag: #{tag}", "model-name: #{model[:name]}"]
 					# 	cursor.object = clean_member(cursor.object)
 					# 	clean_members(ivg(shared_attribute_var, obj))
@@ -460,23 +606,23 @@ module Rfm
 		# is returned to the object that originally called for the parsing run (your script/app/whatever).
 		module Handler
 		
-			attr_accessor :stack, :template
+			attr_accessor :stack, :template, :initial_object, :stack_debug
 			
-			SaxParser.install_defaults(self)
+			#SaxParser.install_defaults(self)
 
 
 			###  Class Methods  ###
 
 			# Main parsing interface (also aliased at SaxParser.parse)
 			def self.build(io, template=nil, initial_object=nil, parser=nil, options={})
-				parser = parser || options[:parser] || backend
+				parser = parser || options[:parser] || BACKEND
 				parser = get_backend(parser)
 				(Rfm.log.info "Using backend parser: #{parser}, with template: #{template}") if options[:log_parser]
 			  parser.build(io, template, initial_object)
 		  end
 		  
 		  def self.included(base)
-		  	# Add a .build method to the custom handler class, when the generic Handler module is included.
+		  	# Add a .build method to the custom handler instance, when the generic Handler module is included.
 		    def base.build(io, template=nil, initial_object=nil)
 		  		handler = new(template, initial_object)
 		  		handler.run_parser(io)
@@ -485,7 +631,7 @@ module Rfm
 		  end # self.included
 		  
 		  # Takes backend symbol and returns custom Handler class for specified backend.
-		  def self.get_backend(parser=backend)
+		  def self.get_backend(parser=BACKEND)
 				(parser = decide_backend) unless parser
 				if parser.is_a?(String) || parser.is_a?(Symbol)
 					parser_proc = PARSERS[parser.to_sym][:proc]
@@ -508,21 +654,17 @@ module Rfm
 		  
 		  ###  Instance Methods  ###
 		  
-		  def initialize(_template=nil, initial_object=nil)
-		  	initial_object = case
-		  		when initial_object.nil?; default_class.new
-		  		when initial_object.is_a?(Class); initial_object.new
-		  		when initial_object.is_a?(String) || initial_object.is_a?(Symbol); SaxParser.get_constant(initial_object).new
-		  		else initial_object
+		  def initialize(_template=nil, _initial_object=nil)
+		  	@initial_object = case
+		  		when _initial_object.nil?; DEFAULT_CLASS.new
+		  		when _initial_object.is_a?(Class); _initial_object.new
+		  		when _initial_object.is_a?(String) || _initial_object.is_a?(Symbol); SaxParser.get_constant(_initial_object).new
+		  		else _initial_object
 		  	end
-		  	#initial_object = initial_object || default_class.new || {}
 		  	@stack = []
+		  	@stack_debug=[]
 		  	@template = get_template(_template)
-		  	@tag_translation = tag_translation
-		  	#(@template = @template.values[0]) if @template.size == 1
-		  	#y @template
-		  	init_element_buffer
-		    set_cursor Cursor.new(@template, initial_object, 'top', self)
+		    set_cursor Cursor.new('__TOP__', self).process_new_element
 		  end
 		  
 		  # Takes string, symbol, hash, and returns a (possibly cached) parsing template.
@@ -538,12 +680,13 @@ module Rfm
 				# 	end
 				# 	(templates[name] = rslt) #unless dat == rslt
 				# The above works, but this is cleaner.
-				templates[name] = templates[name] && load_template(templates[name]) || load_template(name)
+				TEMPLATES[name] = TEMPLATES[name] && load_template(TEMPLATES[name]) || load_template(name)
 			end
 			
 			# Does the heavy-lifting of template retrieval.
 			def load_template(dat)
-				prefix = defined?(template_prefix) ? template_prefix : ''
+				prefix = defined?(TEMPLATE_PREFIX) ? TEMPLATE_PREFIX : ''
+				#puts "SaxParser::Handler#load_template... 'prefix' is #{prefix}"
 		  	rslt = case
 		  		when dat.is_a?(Hash); dat
 		  		when dat.to_s[/\.y.?ml$/i]; (YAML.load_file(File.join(*[prefix, dat].compact)))
@@ -551,7 +694,7 @@ module Rfm
 		  		when dat.to_s[/\.xml$/i]; self.class.build(File.join(*[prefix, dat].compact), nil, {'compact'=>true})
 		  		when dat.to_s[/^<.*>/i]; "Convert from xml to Hash - under construction"
 		  		when dat.is_a?(String); YAML.load dat
-		  		else default_class.new
+		  		else DEFAULT_CLASS.new
 		  	end
 			end
 		  
@@ -566,10 +709,7 @@ module Rfm
 			def set_cursor(args) # cursor_object
 				if args.is_a? Cursor
 					stack.push(args)
-					cursor.parent = stack[-2] || stack[0] #_stack[0] so methods called on parent won't bomb.
-					# Cursor is no longer storing top or stack, it is delegating those mehthods to main handler.
-					#cursor.top = stack[0]
-					#cursor.stack = stack
+					#@stack_debug.push(args.dup.tap(){|c| c.handler = c.handler.object_id; c.parent = c.parent.tag})
 				end
 				cursor
 			end
@@ -583,64 +723,49 @@ module Rfm
 			end
 			
 			def transform(name)
-				return name unless @tag_translation.is_a?(Proc)
-				#name.to_s.gsub(*@tag_translation)
-				@tag_translation.call(name.to_s)
-			end
-			
-			def init_element_buffer
-		    @element_buffer = {:tag=>nil, :attributes=>default_class.new, :text=>''}
+				return name unless TAG_TRANSLATION.is_a?(Proc)
+				TAG_TRANSLATION.call(name.to_s)
 			end
-			
-			def send_element_buffer
-		    if element_buffer?
-		    	(@element_buffer[:attributes][text_label] = @element_buffer[:text]) if @element_buffer[:text].to_s[/[^\s]/]
-          set_cursor cursor.receive_start_element(@element_buffer[:tag], @element_buffer[:attributes])
-          init_element_buffer
-	      end
-	    end
-	    
-	    def element_buffer?
-	      @element_buffer[:tag] && !@element_buffer[:tag].empty?
-	    end
-
 
 		  # Add a node to an existing element.
 			def _start_element(tag, attributes=nil, *args)
 				#puts ["_START_ELEMENT", tag, attributes, args].to_yaml # if tag.to_s.downcase=='fmrestulset'
 				tag = transform tag
-				send_element_buffer if element_buffer?
 				if attributes
 					# This crazy thing transforms attribute keys to underscore (or whatever).
 					#attributes = default_class[*attributes.collect{|k,v| [transform(k),v] }.flatten]
 					# This works but downcases all attribute names - not good.
-					attributes = default_class.new.tap {|hash| attributes.each {|k, v| hash[transform(k)] = v}}
+					attributes = DEFAULT_CLASS.new.tap {|hash| attributes.each {|k, v| hash[transform(k)] = v}}
 					# This doesn't work yet, but at least it wont downcase hash keys.
 					#attributes = Hash.new.tap {|hash| attributes.each {|k, v| hash[transform(k)] = v}}
 				end
-				@element_buffer.merge!({:tag=>tag, :attributes => attributes || default_class.new})
+				set_cursor cursor.receive_start_element(tag, attributes)
 			end
 			
 			# Add attribute to existing element.
 			def _attribute(name, value, *args)
 				#puts "Receiving attribute '#{name}' with value '#{value}'"
 				name = transform name
-				new_att = default_class.new.tap{|att| att[name]=value}
-				@element_buffer[:attributes].merge!(new_att)
+				cursor.receive_attribute(name, value)
 			end
 			
 			# Add 'content' attribute to existing element.
 			def _text(value, *args)
 				#puts "Receiving text '#{value}'"
-				return unless value.to_s[/[^\s]/]
-			  @element_buffer[:text] << value
+				#puts RUBY_VERSION_NUM
+				if RUBY_VERSION_NUM > 1.8 && value.is_a?(String)
+					#puts "Forcing utf-8"
+					value.force_encoding('UTF-8')
+				end
+				# I think the reason this was here is no longer relevant, so I'm disabeling.
+				return unless value[/[^\s]/]
+			  cursor.receive_attribute(TEXT_LABEL, value)
 			end
 			
 			# Close out an existing element.
 			def _end_element(tag, *args)
 				tag = transform tag
 				#puts "Receiving end_element '#{tag}'"
-	      send_element_buffer
 	      cursor.receive_end_element(tag) and dump_cursor
 			end
 			
@@ -767,30 +892,34 @@ class Object
 
 	# Master method to attach any object to this object.
 	def _attach_object!(obj, *args) # name/label, collision-delimiter, attachment-prefs, type, *options: <options>
-		#puts ["OBJECT._attach_object", self.class, obj.class, obj.to_s, args].to_yaml
-		default_options = {
-			:shared_variable_name => 'attributes',
-			:default_class => Hash,
-			:create_accessors => [] #:all, :private, :shared, :hash
-		}
-		options = default_options.merge(args.last.is_a?(Hash) ? args.pop : {}){|key, old, new| new || old}
-		name = (args[0] || options[:name])
-		delimiter = (args[1] || options[:delimiter])
+		#puts ["\nATTACH_OBJECT._attach_object", self.class, obj.class, obj.to_s, args].to_yaml
+		options = ATTACH_OBJECT_DEFAULT_OPTIONS.merge(args.last.is_a?(Hash) ? args.pop : {}){|key, old, new| new || old}
+		# 	name = (args[0] || options[:name])
+		# 	delimiter = (args[1] || options[:delimiter])
 		prefs = (args[2] || options[:prefs])
-		type = (args[3] || options[:type])
-		#puts ['OBJECT.attach_object', type, name, self.class, obj.class, delimiter, prefs, options[:shared_variable_name], options[:default_class], options[:create_accessors]].join(', ')
-		case
-		when prefs=='none' || prefs=='cursor'; nil
-		when name
-			self._merge_object!(obj, name, delimiter, prefs, type, options)
-		else
-			self._merge_object!(obj, 'unknown_name', delimiter, prefs, type, options)
-		end
+		# 	type = (args[3] || options[:type])
+		return if (prefs=='none' || prefs=='cursor')   #['none', 'cursor'].include? prefs ... not sure which is faster.
+		self._merge_object!(
+			obj,
+			args[0] || options[:name] || 'unknown_name',
+			args[1] || options[:delimiter],
+			prefs,
+			args[3] || options[:type],
+			options
+		)
+		
+	# 		case
+	# 		when prefs=='none' || prefs=='cursor'; nil
+	# 		when name
+	# 			self._merge_object!(obj, name, delimiter, prefs, type, options)
+	# 		else
+	# 			self._merge_object!(obj, 'unknown_name', delimiter, prefs, type, options)
+	# 		end
 	end
 	
 	# Master method to merge any object with this object
 	def _merge_object!(obj, name, delimiter, prefs, type, options={})
-		#puts ["-----OBJECT._merge_object", self.class, (obj.to_s rescue obj.class), name, delimiter, prefs, type.capitalize, options].join(', ')
+		#puts ["\n-----OBJECT._merge_object", self.class, (obj.to_s rescue obj.class), name, delimiter, prefs, type.capitalize, options].join(', ')
 		if prefs=='private'
 			_merge_instance!(obj, name, delimiter, prefs, type, options)
 		else
@@ -805,16 +934,16 @@ class Object
 		# TODO: Figure this part out:
 		# The resetting of shared_variable_name to 'attributes' was to fix Asset.field_controls (it was not able to find the valuelive name).
 		# I think there might be a level of heirarchy that is without a proper cursor model, when using shared variables & object delimiters.
-		shared_var._merge_object!(obj, name, delimiter, nil, type, options.merge(:shared_variable_name=>'attributes'))
+		shared_var._merge_object!(obj, name, delimiter, nil, type, options.merge(:shared_variable_name=>ATTACH_OBJECT_DEFAULT_OPTIONS[:shared_variable_name]))
 	end
 	
 	# Merge a named object with the specified instance variable of self.
 	def _merge_instance!(obj, name, delimiter, prefs, type, options={})
-		#puts ['_merge_instance!', self.class, obj.class, name, delimiter, prefs, type, options.keys, '_end_merge_instance!'].join(', ')
-		if instance_variable_get("@#{name}") || delimiter
+		#puts ["\n_merge_instance!", self.class, obj.class, name, delimiter, prefs, type, options.keys, '_end_merge_instance!'].join(', ')
+		rslt = if instance_variable_get("@#{name}") || delimiter
 			if delimiter
 				delimit_name = obj._get_attribute(delimiter, options[:shared_variable_name]).to_s.downcase
-				#puts ['_setting_with_delimiter', delimit_name]
+				#puts ["\n_setting_with_delimiter", delimit_name]
 				#instance_variable_set("@#{name}", instance_variable_get("@#{name}") || options[:default_class].new)[delimit_name]=obj
 				# This line is more efficient than the above line.
 				instance_variable_set("@#{name}", options[:default_class].new) unless instance_variable_get("@#{name}")
@@ -823,28 +952,34 @@ class Object
 				# In parsing terms, this is trying to handle multiple elements who's delimiter field contains the SAME delimiter data.
 				#instance_variable_get("@#{name}")._merge_object!(obj, delimit_name, nil, nil, nil)
 			else
-				#puts ['_setting_existing_instance_var', name]
-				instance_variable_set("@#{name}", [instance_variable_get("@#{name}")].flatten << obj)
+				#puts ["\_setting_existing_instance_var", name]
+				if name == options[:text_label]
+					instance_variable_get("@#{name}") << obj.to_s
+				else
+					instance_variable_set("@#{name}", [instance_variable_get("@#{name}")].flatten << obj)
+				end
 			end
 		else
-			#puts ['_setting_new_instance_var', name]
+			#puts ["\n_setting_new_instance_var", name]
 			instance_variable_set("@#{name}", obj)
 		end
 		
 		# NEW
 		_create_accessor(name) if (options[:create_accessors] & ['all','private']).any?
 		
+		rslt
 	end
 	
 	# Get an instance variable, a member of a shared instance variable, or a hash value of self.
   def _get_attribute(name, shared_var_name=nil, options={})
   	return unless name
-  	#puts ["\nOBJECT_get_attribute", self.instance_variables, name, shared_var_name, options].join(', ')
+  	#puts ["\n\n", self.to_yaml]
+  	#puts ["OBJECT_get_attribute", self.class, self.instance_variables, name, shared_var_name, options].join(', ')
   	(shared_var_name = options[:shared_variable_name]) unless shared_var_name
 		
 		rslt = case
 		when self.is_a?(Hash) && self[name]; self[name]
-		when (var= instance_variable_get("@#{shared_var_name}")) && var[name]; var[name]
+		when ((var= instance_variable_get("@#{shared_var_name}")) && var[name]); var[name]
 		else instance_variable_get("@#{name}")
 		end
 		
@@ -853,6 +988,7 @@ class Object
   end
   
 	#   # We don't know which attributes are shared, so this isn't really accurate per the options.
+	#   # But this could be useful for mass-attachment of a set of attributes (to increase performance in some situations).
 	#   def _create_accessors options=[]
 	#   	options=[options].flatten.compact
 	#   	#puts ['CREATE_ACCESSORS', self.class, options, ""]
@@ -874,7 +1010,7 @@ class Object
 		meta.send(:attr_reader, name.to_sym)
 	end
   
-	# Attach hash as individual instance variables.
+	# Attach hash as individual instance variables to self.
 	# This is for manually attaching a hash of attributes to the current object.
 	# Pass in translation procs to alter the keys or values.
 	def _attach_as_instance_variables(hash, options={})
@@ -885,7 +1021,7 @@ class Object
 		if hash.is_a? Hash
 			hash.each do |k,v|
 				(k = key_translator.call(k)) if key_translator
-				(v = value_translator.call(v)) if value_translator
+				(v = value_translator.call(k, v)) if value_translator
 				instance_variable_set("@#{k}", v)
 			end
 		end
@@ -895,7 +1031,7 @@ end # Object
 
 class Array
 	def _merge_object!(obj, name, delimiter, prefs, type, options={})
-		#puts ["\n+++++ARRAY._merge_object", self.class, (obj.to_s rescue obj.class), name, delimiter, prefs, type.titleize, options].join(', ')
+		#puts ["\n+++++ARRAY._merge_object", self.class, (obj.to_s rescue obj.class), name, delimiter, prefs, type, options].join(', ')
 		case
 		when prefs=='shared' || type == 'attribute' && prefs.to_s != 'private' ; _merge_shared!(obj, name, delimiter, prefs, type, options)
 		when prefs=='private'; _merge_instance!(obj, name, delimiter, prefs, type, options)
@@ -906,14 +1042,14 @@ end # Array
 
 class Hash
 	def _merge_object!(obj, name, delimiter, prefs, type, options={})
-		#puts ["\n*****HASH._merge_object", type, name, self.class, (obj.to_s rescue obj.class), delimiter, prefs, options].join(', ')
+		#puts ["\n*****HASH._merge_object", "type: #{type}", "name: #{name}", "self.class: #{self.class}", "new_obj: #{(obj.to_s rescue obj.class)}", "delimiter: #{delimiter}", "prefs: #{prefs}", "options: #{options}"]
 		case
 		when prefs=='shared'
 			_merge_shared!(obj, name, delimiter, prefs, type, options)
 		when prefs=='private'
 			_merge_instance!(obj, name, delimiter, prefs, type, options)
 		when (self[name] || delimiter)
-			if delimiter
+			rslt = if delimiter
 				delimit_name =  obj._get_attribute(delimiter, options[:shared_variable_name]).to_s.downcase
 				#puts "MERGING delimited object with hash: self '#{self.class}' obj '#{obj.class}' name '#{name}' delim '#{delimiter}' delim_name '#{delimit_name}' options '#{options}'"
 				self[name] ||= options[:default_class].new
@@ -922,14 +1058,21 @@ class Hash
 				#obj.instance_variable_set(:@_index_, 0)
 				#self[name]._merge_object!(obj, delimit_name, nil, nil, nil)
 			else
-				self[name] = [self[name]].flatten
-				#obj.instance_variable_set(:@_index_, self[name].last.instance_variable_get(:@_index_).to_i + 1)
-				self[name] << obj
+				if name == options[:text_label]
+					self[name] << obj.to_s
+				else
+					self[name] = [self[name]].flatten
+					self[name] << obj
+				end
 			end
 			_create_accessor(name) if (options[:create_accessors] & ['all','shared','hash']).any?
+			
+			rslt
 		else
-			self[name] = obj
+			rslt = self[name] = obj
 			_create_accessor(name) if (options[:create_accessors] & ['all','shared','hash']).any?
+			#puts ["\nRESULT", self.to_yaml]
+			rslt
 		end
 	end