om 1.8.1 → 1.9.0.pre1

data/lib/om/xml/term_value_operators.rb

@@ -3,12 +3,12 @@ require "logger"
 
 class OM::XML::ParentNodeNotFoundError < RuntimeError; end
 module OM::XML::TermValueOperators
-
+  
   # Retrieves all of the nodes from the current document that match +term_pointer+ and returns an array of their values
   def term_values(*term_pointer)
     result = []
     xpath = self.class.terminology.xpath_with_indexes(*term_pointer)
-    # if value is on line by itself sometimes does not trim leading and trailing whitespace for a text node so will detect and fix it
+    #if value is on line by itself sometimes does not trim leading and trailing whitespace for a text node so will detect and fix it
     trim_text = !xpath.nil? && !xpath.index("text()").nil?
     find_by_terms(*term_pointer).each {|node| result << (trim_text ? node.text.strip : node.text) }
 
@@ -20,59 +20,61 @@ module OM::XML::TermValueOperators
       term.deserialize(result)
     end
   end
-
+  
   # alias for term_values
   def property_values(*lookup_args)
     term_values(*lookup_args)
   end
-
-  #
+  
+  # 
   # example term values hash: {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] }
   def update_values(params={})
-    # remove any terms from params that this datastream doesn't recognize
-
-    params.delete_if do |term_pointer,new_values|
+    # remove any terms from params that this datastream doesn't recognize    
+    
+    params.delete_if do |term_pointer,new_values| 
       if term_pointer.kind_of?(String)
         true
       else
         !self.class.terminology.has_term?(*OM.destringify(term_pointer))
       end
     end
-
+    
     result = params.dup
-
+    
     params.each_pair do |term_pointer,new_values|
       pointer = OM.destringify(term_pointer)
       template_pointer = OM.pointers_to_flat_array(pointer,false)
       hn = OM::XML::Terminology.term_hierarchical_name(*pointer)
-
+      
       term = self.class.terminology.retrieve_term( *OM.pointers_to_flat_array(pointer,false) )
 
       # Sanitize new_values to always be a hash with indexes
       new_values = term.sanitize_new_values(new_values)
-
+      
       # Populate the response hash appropriately, using hierarchical names for terms as keys rather than the given pointers.
       result.delete(term_pointer)
       result[hn] = new_values.dup
-
+      
       # Skip any submitted values if the new value matches the current values
       current_values = term_values(*pointer)
       new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y|
         z = new_values[y]
-        new_values.delete(y) if current_values[y.to_i]==z && y.to_i > -1
-      end
-
+        if current_values[y.to_i]==z and y.to_i > -1
+          new_values.delete(y)
+        end
+      end 
+      
       # Fill out the pointer completely if the final term is a NamedTermProxy
       if term.kind_of? OM::XML::NamedTermProxy
         pointer.pop
         pointer = pointer.concat(term.proxy_pointer)
       end
-
+      
       xpath = self.class.terminology.xpath_with_indexes(*pointer)
       parent_pointer = pointer.dup
       parent_pointer.pop
       parent_xpath = self.class.terminology.xpath_with_indexes(*parent_pointer)
-
+      
       # If the value doesn't exist yet, append it.  Otherwise, update the existing value.
       new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y|
         z = new_values[y]
@@ -87,18 +89,18 @@ module OM::XML::TermValueOperators
         end
       end
     end
-    result
+    return result
   end
-
+  
   def term_values_append(opts={})
     parent_select = Array( opts[:parent_select] )
     parent_index = opts[:parent_index]
     template = opts[:template]
-    new_values = Array( opts[:values] )
-
+    new_values = Array( opts[:values] )  
+    
     parent_nodeset = find_by_terms(*parent_select)
     parent_node = node_from_set(parent_nodeset, parent_index)
-
+    
     if parent_node.nil?
       if parent_select.empty?
         parent_node = ng_xml.root
@@ -108,12 +110,12 @@ module OM::XML::TermValueOperators
     end
 
     insert_from_template(parent_node, new_values, template)
-
-    parent_node
-
+    
+    return parent_node
+    
   end
 
-  # Insert xml containing +new_values+ into +parent_node+.  Generate the xml based on +template+
+  # Insert xml containing +new_values+ into +parent_node+.  Generate the xml based on +template+ 
   # @param [Nokogiri::XML::Node] parent_node to insert new xml into
   # @param [Array] new_values to build the xml around
   # @param [Array -- (OM term pointer array) OR String -- (like what you would pass into Nokogiri::XML::Builder.new)] template for building the new xml.  Use the syntax that Nokogiri::XML::Builder uses.
@@ -131,23 +133,23 @@ module OM::XML::TermValueOperators
       template = self.class.terminology.xml_builder_template( *template_args )
     end
 
-    # if there is an xpath element pointing to text() need to change to just 'text' so it references the text method for the parent node
+    #if there is an xpath element pointing to text() need to change to just 'text' so it references the text method for the parent node
     template.gsub!(/text\(\)/, 'text')
-
+    
     builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
       new_values.each do |builder_new_value|
         builder_new_value = builder_new_value.gsub(/'/, "\\\\'") # escape any apostrophes in the new value
         if matchdata = /xml\.@(\w+)/.match(template)
           parent_node.set_attribute(matchdata[1], builder_new_value)
-        else
+        else 
           builder_arg = eval('"'+ template + '"') # this inserts builder_new_value into the builder template
           eval(builder_arg)
         end
       end
     end
-    parent_node
+    return parent_node
   end
-
+  
   # Creates necesary ancestor nodes to support inserting a new term value where the ancestor node(s) don't exist yet.
   # Corrects node indexes in the pointer array to correspond to the ancestors that it creates.
   # Returns a two-value array with the 'parent' node and a corrected pointer array
@@ -157,18 +159,20 @@ module OM::XML::TermValueOperators
     parent_select = Array(parent_select)
     parent_nodeset = find_by_terms(*parent_select)
     starting_point = node_from_set(parent_nodeset, parent_index)
-    starting_point = [] if starting_point.nil?
+    if starting_point.nil? 
+      starting_point = [] 
+    end
     to_build = []
-    while starting_point.empty?
+    until !starting_point.empty?
       to_build = [parent_select.pop] + to_build
       starting_point = find_by_terms(*parent_select)
-      if starting_point.empty? && parent_select.empty?
+      if starting_point.empty? && parent_select.empty? 
         raise OM::XML::TemplateMissingException, "Cannot insert nodes into the document because it is empty.  Try defining self.xml_template on the #{self.class} class."
       end
     end
-    to_build.each do |term_pointer|
+    to_build.each do |term_pointer|      
       parent_select << term_pointer
-
+      
       # If pointers in parent_select don't match with the indexes of built ancestors, correct the hash
       if find_by_terms(*parent_select+[{}]).length == 0
         if parent_select.last.kind_of?(Hash)
@@ -194,13 +198,13 @@ module OM::XML::TermValueOperators
     if parent_index > starting_point.length
       parent_index = starting_point.length - 1
     end
-    node_from_set(starting_point, parent_index)
+    return node_from_set(starting_point, parent_index)
   end
-
+  
   def term_value_update(node_select,node_index,new_value,opts={})
     ng_xml_will_change!
     # template = opts.fetch(:template,nil)
-
+    
     node = find_by_terms_and_value(*node_select)[node_index]
     if delete_on_update?(node, new_value)
       node.remove
@@ -212,23 +216,23 @@ module OM::XML::TermValueOperators
   def delete_on_update?(node, new_value)
     new_value == "" || new_value == :delete
   end
-
+  
   # def term_value_set(term_ref, query_opts, node_index, new_value)
   # end
-
+  
   def term_value_delete(opts={})
     ng_xml_will_change!
     parent_select = Array( opts[:parent_select] )
     parent_index = opts[:parent_index]
     child_index = opts[:child_index]
     xpath_select = opts[:select]
-
+    
     if !xpath_select.nil?
       node = find_by_terms_and_value(xpath_select).first
     else
       # parent_nodeset = find_by_terms_and_value(parent_select, parent_select)
       parent_nodeset = find_by_terms_and_value(*parent_select)
-
+      
       if parent_index.nil?
         node = node_from_set(parent_nodeset, child_index)
       else
@@ -237,24 +241,24 @@ module OM::XML::TermValueOperators
         node = node_from_set(parent.xpath("*"), child_index)
       end
     end
-
+    
     node.remove
   end
-
-
+   
+  
   # Allows you to provide an array index _or_ a symbol representing the function to call on the nodeset in order to retrieve the node.
   def node_from_set(nodeset, index)
     if index.kind_of?(Integer)
       node = nodeset[index]
-    elsif index.kind_of?(Symbol) && nodeset.respond_to?(index)
+    elsif index.kind_of?(Symbol) && nodeset.respond_to?(index) 
       node = nodeset.send(index)
     else
       raise "Could not retrieve node using index #{index}."
     end
-
-    node
+    
+    return node
   end
-
+  
   private :node_from_set
-
+  
 end

data/lib/om/xml/term_xpath_generator.rb

@@ -1,27 +1,27 @@
 require 'loggable'
 module OM::XML::TermXpathGenerator
   include Loggable
-
+  
   # Generate relative xpath for a term
   # @param [OM::XML::Term] term that you want to generate relative xpath for
   #
   # In most cases, the resulting xpath will be the Term's path with the appropriate namespace appended to it.
-  # If the Term specifies any attributes,
+  # If the Term specifies any attributes, 
   # Special Case: attribute Terms
-  # If the Term's path is set to {:attribute=>attr_name}, the resulting xpath will points to a node attribute named attr_name
+  # If the Term's path is set to {:attribute=>attr_name}, the resulting xpath will points to a node attribute named attr_name 
   # ie. a path fo {:attribute=>"lang"} will result in a relative xpath of "@lang"
   # Special Case: xpath functions
   # If the Term's path variable is text(), it will be treated as an xpath function (no namespace) and turned into "text()[normalize-space(.)]"
   def self.generate_relative_xpath(term)
     template = ""
     predicates = []
-
+    
     if term.namespace_prefix.nil?
       complete_prefix = ""
     else
       complete_prefix = term.namespace_prefix + ":"
     end
-
+    
     if term.path.kind_of?(Hash)
       if term.path.has_key?(:attribute)
         base_path = "@"+term.path[:attribute]
@@ -32,12 +32,14 @@ module OM::XML::TermXpathGenerator
       if term.path == "text()"
         base_path = "#{term.path}[normalize-space(.)]"
       else
-        template << complete_prefix unless term.namespace_prefix.nil?
+        unless term.namespace_prefix.nil?
+          template << complete_prefix
+        end
         base_path = term.path
       end
     end
     template << base_path
-
+    
     unless term.attributes.nil?
       term.attributes.each_pair do |attr_name, attr_value|
         if attr_value == :none
@@ -47,14 +49,14 @@ module OM::XML::TermXpathGenerator
         end
       end
     end
-
-    unless predicates.empty?
+    
+    unless predicates.empty? 
       template << "["+ delimited_list(predicates, " and ")+"]"
     end
-
-    template
+    
+    return template
   end
-
+  
   # Generate absolute xpath for a Term
   # @param [OM::XML::Term] term that you want to generate absolute xpath for
   #
@@ -67,36 +69,36 @@ module OM::XML::TermXpathGenerator
       return term.parent.xpath_absolute + "/" + relative
     end
   end
-
+  
   def self.generate_constrained_xpath(term)
     if term.namespace_prefix.nil?
       complete_prefix = ""
     else
       complete_prefix = term.namespace_prefix + ":"
     end
-
+    
     absolute = generate_absolute_xpath(term)
     constraint_predicates = []
-
+    
     arguments_for_contains_function = []
 
-    unless term.default_content_path.nil?
+    if !term.default_content_path.nil?
       arguments_for_contains_function << "#{complete_prefix}#{term.default_content_path}"
     end
-
+      
     # If no subelements have been specified to search within, set contains function to search within the current node
     if arguments_for_contains_function.empty?
       arguments_for_contains_function << "."
     end
-
+    
     arguments_for_contains_function << "\":::constraint_value:::\""
-
+  
     contains_function = "contains(#{delimited_list(arguments_for_contains_function)})"
 
     template = add_predicate(absolute, contains_function)
-    template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }.gsub('"', '\"')
+    return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }.gsub('"', '\"')
   end
-
+  
   # Generate an xpath of the chosen +type+ for the given Term.
   # @param [OM::XML::Term] term that you want to generate relative xpath for
   # @param [Symbol] the type of xpath to generate, :relative, :abolute, or :constrained
@@ -110,9 +112,9 @@ module OM::XML::TermXpathGenerator
       self.generate_constrained_xpath(term)
     end
   end
-
+  
   # Use the given +terminology+ to generate an xpath with (optional) node indexes for each of the term pointers.
-  # Ex.  OM::XML::TermXpathGenerator.xpath_with_indexes(my_terminology, {:conference=>0}, {:role=>1}, :text )
+  # Ex.  OM::XML::TermXpathGenerator.xpath_with_indexes(my_terminology, {:conference=>0}, {:role=>1}, :text ) 
   #      will yield an xpath similar to this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
   # @param [OM::XML::Terminology] terminology to generate xpath based on
   # @param [String -- OM term pointer] pointers identifying the node to generate xpath for
@@ -125,28 +127,30 @@ module OM::XML::TermXpathGenerator
         return root_term.xpath
       end
     end
-
+    
     query_constraints = nil
-
+    
     if pointers.length > 1 && pointers.last.kind_of?(Hash)
       constraints = pointers.pop
-      query_constraints = constraints unless constraints.empty?
+      unless constraints.empty?
+        query_constraints = constraints
+      end 
     end
 
     if pointers.length == 1 && pointers.first.instance_of?(String)
       return xpath_query = pointers.first
     end
-
+      
     # if pointers.first.kind_of?(String)
     #   return pointers.first
     # end
-
+    
     keys = []
     xpath = "//"
 
     pointers = OM.destringify(pointers)
     pointers.each_with_index do |pointer, pointer_index|
-
+      
       if pointer.kind_of?(Hash)
         k = pointer.keys.first
         index = pointer[k]
@@ -154,13 +158,13 @@ module OM::XML::TermXpathGenerator
         k = pointer
         index = nil
       end
-
+      
       keys << k
-
-      term = terminology.retrieve_term(*keys)
+      
+      term = terminology.retrieve_term(*keys)  
       # Return nil if there is no term to work with
       return if term.nil?
-
+      
       # If we've encountered a NamedTermProxy, insert path sections corresponding to each entry in its proxy_pointer (rather than just the final term that it points to).
       # TODO Looks like this only works if the last key is a NamedTermProxy, what if we cross proxies on the way there?
       if term.kind_of? OM::XML::NamedTermProxy
@@ -183,20 +187,22 @@ module OM::XML::TermXpathGenerator
             raise "There's a problem with the #{term.name} OM::XML::NamedTermProxy, whose proxy pointer is #{term.proxy_pointer}.  The #{proxy_pointer} pointer is returning #{proxy_term.inspect}"
           end
         end
-      else
+      else  
         relative_path = term.xpath_relative
-
+      
         unless index.nil?
           relative_path = add_node_index_predicate(relative_path, index)
         end
       end
-
-      relative_path = "/"+relative_path if pointer_index > 0
-      xpath << relative_path
+      
+      if pointer_index > 0
+        relative_path = "/"+relative_path
+      end
+      xpath << relative_path 
     end
-
-    final_term = terminology.retrieve_term(*keys)
-
+      
+    final_term = terminology.retrieve_term(*keys) 
+    
     if query_constraints.kind_of?(Hash)
       contains_functions = []
       query_constraints.each_pair do |k,v|
@@ -207,20 +213,20 @@ module OM::XML::TermXpathGenerator
         end
         contains_functions << "contains(#{constraint_path}, \"#{v}\")"
       end
-
+      
       xpath = add_predicate(xpath, delimited_list(contains_functions, " and ") )
     end
-
-    xpath
+    
+    return xpath
   end
-
+  
   # @see OM::XML.delimited_list
   def self.delimited_list(*args)
     OM::XML.delimited_list(*args)
   end
-
+  
   # Adds xpath xpath node index predicate to the end of your xpath query
-  # Example:
+  # Example: 
   # add_node_index_predicate("//oxns:titleInfo",0)
   #   => "//oxns:titleInfo[1]"
   #
@@ -230,9 +236,9 @@ module OM::XML::TermXpathGenerator
     modified_query = xpath_query.dup
     modified_query << "[#{array_index_value + 1}]"
   end
-
+  
   # Adds xpath:position() method call to the end of your xpath query
-  # Examples:
+  # Examples: 
   #
   # add_position_predicate("//oxns:titleInfo",0)
   # => "//oxns:titleInfo[position()=1]"
@@ -243,7 +249,7 @@ module OM::XML::TermXpathGenerator
     position_function = "position()=#{array_index_value + 1}"
     self.add_predicate(xpath_query, position_function)
   end
-
+  
   def self.add_predicate(xpath_query, predicate)
     modified_query = xpath_query.dup
     # if xpath_query.include?("]")
@@ -252,7 +258,7 @@ module OM::XML::TermXpathGenerator
     else
       modified_query << "[#{predicate}]"
     end
-    modified_query
+    return modified_query
   end
 
 end