om 1.0.1 → 1.0.2

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/om/xml/term.rb

@@ -1,7 +1,10 @@
 class OM::XML::Term
   
   # Term::Builder Class Definition
-  
+  #
+  # When coding against Builders, remember that they rely on MethodMissing, 
+  # so any time you call a method on the Builder that it doesn't explicitly recognize, 
+  # the Builder will add your method & arguments to the it's settings and return itself.
   class Builder
     attr_accessor :name, :settings, :children, :terminology_builder
     

data/lib/om/xml/term_value_operators.rb

@@ -34,7 +34,7 @@ module OM::XML::TermValueOperators
     
     params.each_pair do |term_pointer,new_values|
       pointer = OM.destringify(term_pointer)
-      template = OM.pointers_to_flat_array(pointer,false)
+      template_pointer = OM.pointers_to_flat_array(pointer,false)
       hn = OM::XML::Terminology.term_hierarchical_name(*pointer)
       
       # Sanitize new_values to always be a hash with indexes
@@ -78,7 +78,8 @@ module OM::XML::TermValueOperators
       new_values.each do |y,z|   
         if find_by_terms(*pointer)[y.to_i].nil? || y.to_i == -1
           result[hn].delete(y)
-          term_values_append(:parent_select=>parent_xpath,:child_index=>0,:template=>template,:values=>z)
+          term_values_append(:parent_select=>parent_pointer,:parent_index=>0,:template=>template_pointer,:values=>z)
+          # term_values_append(:parent_select=>parent_xpath,:parent_index=>0,:template=>template_pointer,:values=>z)
           new_array_index = find_by_terms(*pointer).length - 1
           result[hn][new_array_index.to_s] = z
         else
@@ -91,10 +92,32 @@ module OM::XML::TermValueOperators
   
   def term_values_append(opts={})
     parent_select = Array( opts[:parent_select] )
-    child_index = opts[:child_index]
+    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?
+      parent_node, parent_select = build_ancestors(parent_select, parent_index)
+      # parent_nodeset = find_by_terms(*parent_select)
+      # parent_node = node_from_set(parent_nodeset, :last)
+      # raise OM::XML::ParentNodeNotFoundError, "Failed to find a parent node to insert values into based on :parent_select #{parent_select.inspect} with :parent_index #{parent_index.inspect}"
+    end
+
+    insert_from_template(parent_node, new_values, template)
+    
+    return parent_node
+    
+  end
   
+  # 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.
+  # @return [Nokogiri::XML::Node] the parent_node with new chldren inserted into it
+  def insert_from_template(parent_node, new_values, template)
     # If template is a string, use it as the template, otherwise use it as arguments to xml_builder_template
     unless template.instance_of?(String)
       template_args = Array(template)
@@ -102,14 +125,8 @@ module OM::XML::TermValueOperators
         template_opts = template_args.delete_at(template_args.length - 1)
         template_args << template_opts
       end
+      template_args = OM.pointers_to_flat_array(template_args,false)
       template = self.class.terminology.xml_builder_template( *template_args )
-    end    
-    
-    parent_nodeset = find_by_terms(*parent_select)
-    parent_node = node_from_set(parent_nodeset, child_index)
-    
-    if parent_node.nil?
-      raise OM::XML::ParentNodeNotFoundError, "Failed to find a parent node to insert values into based on :parent_select #{parent_select.inspect} with :child_index #{child_index.inspect}"
     end
     
     builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
@@ -118,17 +135,61 @@ module OM::XML::TermValueOperators
         eval(builder_arg)
       end
     end
-        
-    # Nokogiri::XML::Node.new(builder.to_xml, foo)
-    
     return parent_node
-    
   end
   
-  def term_value_update(node_select,child_index,new_value,opts={})
+  # 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
+  # @return [Nokogiri::XML::Node] the 'parent' (the final node in the ancestor tree)
+  # @return [Array] corrected pointer array for retrieving this parent
+  def build_ancestors(parent_select, parent_index)
+    parent_select = Array(parent_select)
+    parent_nodeset = find_by_terms(*parent_select)
+    starting_point = node_from_set(parent_nodeset, parent_index)
+    if starting_point.nil? 
+      starting_point = [] 
+    end
+    to_build = []
+    until !starting_point.empty?
+      to_build = [parent_select.pop] + to_build
+      starting_point = find_by_terms(*parent_select)
+    end
+    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)
+          suspect_pointer = parent_select.pop
+          term_key = suspect_pointer.keys.first
+          if parent_select.empty?
+            corrected_term_index = find_by_terms(term_key).length
+          else
+            corrected_term_index = find_by_terms(*parent_select+[{}]).length
+          end
+          parent_select << {term_key => corrected_term_index}
+        end
+      end
+      template_pointer = OM.pointers_to_flat_array(parent_select,false)
+      new_values = [""]
+      insert_from_template(starting_point.first, new_values, template_pointer)
+      starting_point = find_by_terms(*parent_select+[{}])
+      # If pointers in parent_select don't match with the indexes of built ancestors, correct the hash
+      if starting_point.empty?
+        raise StandardError "Oops.  Something went wrong adding #{term_pointer} to #{parent_select} while building ancestors"
+      end
+    end
+    if parent_index > starting_point.length
+      parent_index = starting_point.length - 1
+    end
+    return node_from_set(starting_point, parent_index), parent_select
+  end
+  
+  def term_value_update(node_select,node_index,new_value,opts={})
     # template = opts.fetch(:template,nil)
     
-    node = find_by_terms_and_value(*node_select)[child_index]
+    node = find_by_terms_and_value(*node_select)[node_index]
     if new_value == "" || new_value == :delete
       node.remove
     else

data/lib/om/xml/term_xpath_generator.rb

@@ -102,7 +102,10 @@ module OM::XML::TermXpathGenerator
     query_constraints = nil
     
     if pointers.length > 1 && pointers.last.kind_of?(Hash)
-      query_constraints = pointers.pop
+      constraints = pointers.pop
+      unless constraints.empty?
+        query_constraints = constraints
+      end 
     end
 
     if pointers.length == 1 && pointers.first.instance_of?(String)

data/lib/om/xml/terminology.rb

@@ -3,6 +3,11 @@ class OM::XML::Terminology
   class BadPointerError < StandardError; end
   class CircularReferenceError < StandardError; end
   
+  # Terminology::Builder Class Definition
+  #
+  # When coding against Builders, remember that they rely on MethodMissing, 
+  # so any time you call a method on the Builder that it doesn't explicitly recognize, 
+  # the Builder will add your method & arguments to the it's settings and return itself.
   class Builder
     
     attr_accessor :schema, :namespaces

data/om.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{om}
-  s.version = "1.0.1"
+  s.version = "1.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt"]
-  s.date = %q{2010-12-06}
+  s.date = %q{2010-12-15}
   s.description = %q{OM (Opinionated Metadata): A library to help you tame sprawling XML schemas like MODS.  Wraps Nokogiri documents in objects with miscellaneous helper methods for doing things like retrieve generated xpath queries or look up properties based on a simplified DSL}
   s.email = %q{matt.zumwalt@yourmediashelf.com}
   s.extra_rdoc_files = [

data/spec/unit/term_value_operators_spec.rb

@@ -45,15 +45,17 @@ describe "OM::XML::TermValueOperators" do
       @article.expects(:term_value_update).with('//oxns:titleInfo/oxns:title', 0, "My New Title")
       @article.update_values( {[:title_info, :main_title] => "My New Title"} )
     end
+    
     it "should call term_values_append if the corresponding node does not already exist or if the requested index is -1" do
       expected_args = {
-        :parent_select => OM::Samples::ModsArticle.terminology.xpath_with_indexes(*[{:person=>0}]) ,
-        :child_index => 0,
+        # :parent_select => OM::Samples::ModsArticle.terminology.xpath_with_indexes(*[{:person=>0}]) ,
+        :parent_select => [{:person=>0}],
+        :parent_index => 0,
         :template => [:person, :role],
         :values => "My New Role"
       }
       @article.expects(:term_values_append).with(expected_args).times(2)
-      @article.update_values( {[{:person=>0}, :role] => {"4"=>"My New Role"}} )
+      @article.update_values( {[{:person=>0}, :role] => {"6"=>"My New Role"}} )
       @article.update_values( {[{:person=>0}, :role] => {"-1"=>"My New Role"}} )
     end
     
@@ -84,6 +86,24 @@ describe "OM::XML::TermValueOperators" do
       @article.term_values( :journal, :issue, :pages, :start).should == ["108"]
     end
     
+    it "should create the necessary ancestor nodes when necessary" do
+  	  @sample.find_by_terms(:person).length.should == 4
+  	  @sample.update_values([{:person=>8}, :role, :text]=>"my role")
+      person_entries = @sample.find_by_terms(:person)
+      person_entries.length.should == 5
+      person_entries[4].search("./ns3:role").first.text.should == "my role" 
+	  end
+	  
+    it "should create deep trees of ancestor nodes" do
+      result = @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>{"0"=>"434"} })
+      @article.find_by_terms({:journal=>0}, :issue).length.should == 2
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages).length.should == 1
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages, :start).length.should == 1
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages, :start).first.text.should == "434"
+	  end
+	  
+	  
+    
     ### Examples copied over form nokogiri_datastream_spec
     
     it "should apply submitted hash to corresponding datastream field values" do
@@ -168,10 +188,10 @@ describe "OM::XML::TermValueOperators" do
   
   describe ".term_values_append" do
 	
-  	it "looks up the parent using :parent_select, uses :child_index to choose the parent node from the result set, uses :template to build the node(s) to be inserted, inserts the :values(s) into the node(s) and adds the node(s) to the parent" do      
+  	it "looks up the parent using :parent_select, uses :parent_index to choose the parent node from the result set, uses :template to build the node(s) to be inserted, inserts the :values(s) into the node(s) and adds the node(s) to the parent" do      
 	    @sample.term_values_append(
         :parent_select => [:person, {:first_name=>"Tim", :last_name=>"Berners-Lee"}] ,
-        :child_index => :first,
+        :parent_index => :first,
         :template => [:person, :affiliation],
         :values => ["my new value", "another new value"] 
       )
@@ -190,7 +210,7 @@ describe "OM::XML::TermValueOperators" do
       
 	    @sample.term_values_append(
         :parent_select => [:person, {:first_name=>"Tim", :last_name=>"Berners-Lee"}] ,
-        :child_index => :first,
+        :parent_index => :first,
         :template => [:person, :affiliation],
         :values => ["my new value", "another new value"] 
       ).to_xml.should == expected_result
@@ -204,7 +224,7 @@ describe "OM::XML::TermValueOperators" do
       test_val = "language value"
       @article.term_values_append( 
         :parent_select => :title_info,
-        :child_index => :first,
+        :parent_index => :first,
         :template => [:title_info, :language],
         :values => test_val
       )
@@ -215,7 +235,7 @@ describe "OM::XML::TermValueOperators" do
       # this appends a role of "my role" into the third "person" node in the document
       @sample.term_values_append(
         :parent_select => :person ,
-        :child_index => 3,
+        :parent_index => 3,
         :template => :role,
         :values => "my role" 
       ).to_xml.should #== expected_result
@@ -230,7 +250,7 @@ describe "OM::XML::TermValueOperators" do
       
       @sample.term_values_append(
         :parent_select =>'//oxns:name[@type="personal"]',
-        :child_index => 0,
+        :parent_index => 0,
         :template => 'xml.role { xml.roleTerm( \'#{builder_new_value}\', :type=>\'code\', :authority=>\'marcrelator\') }',
         :values => "founder" 
       )
@@ -246,7 +266,7 @@ describe "OM::XML::TermValueOperators" do
       @sample.ng_xml.xpath('//oxns:name[@type="personal"][2]/oxns:role[1]/oxns:roleTerm', @sample.ox_namespaces).length.should == 2
 	    @sample.term_values_append(
         :parent_select =>'//oxns:name[@type="personal"][2]/oxns:role',
-        :child_index => 0,
+        :parent_index => 0,
         :template => [ :person, :role, :text, {:attributes=>{"authority"=>"marcrelator"}} ],
         :values => "foo" 
       )
@@ -255,8 +275,36 @@ describe "OM::XML::TermValueOperators" do
       @sample.find_by_terms({:person=>1},:role)[0].search("./oxns:roleTerm[@type=\"text\" and @authority=\"marcrelator\"]", @sample.ox_namespaces).first.text.should == "foo"
 	  end
 	  
-	  it "should raise exception if no node corresponds to the provided :parent_select and :child_index"
-  	
+  	it "should create the necessary ancestor nodes when you insert a new term value" do
+  	  @sample.find_by_terms(:person).length.should == 4
+  	  @sample.term_values_append(
+        :parent_select => :person ,
+        :parent_index => 8,
+        :template => :role,
+        :values => "my role" 
+      )
+      person_entries = @sample.find_by_terms(:person)
+      person_entries.length.should == 5
+      person_entries[4].search("./ns3:role").first.text.should == "my role" 
+	  end
+	  
+	  it "should create the necessary ancestor nodes for deep trees of ancestors" do
+  	  deep_pointer = [{:journal=>0}, {:issue=>3}, :pages, :start]
+  	  @article.find_by_terms({:journal=>0}).length.should == 1
+  	  @article.find_by_terms({:journal=>0}, :issue).length.should == 1
+  	  @article.term_values_append(
+        :parent_select => deep_pointer[0..deep_pointer.length-2] ,
+        :parent_index => 0,
+        :template => deep_pointer,
+        :values => "451" 
+      )
+      @article.find_by_terms({:journal=>0}, :issue).length.should == 2
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages).length.should == 1
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages, :start).length.should == 1
+      @article.find_by_terms({:journal=>0}, {:issue=>1}, :pages, :start).first.text.should == "451"
+      
+	  end
+	  
   end
   
   describe ".term_value_update" do
@@ -277,7 +325,7 @@ describe "OM::XML::TermValueOperators" do
       pending
       @sample.term_value_update(
         :parent_select =>'//oxns:name[@type="personal"]',
-        :child_index => 1,
+        :parent_index => 1,
         :template => [ :person, :role, {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}} ],
         :value => "foo"
       )
@@ -318,7 +366,7 @@ describe "OM::XML::TermValueOperators" do
       # Check that the specific node we want to delete no longer exists
       @sample.find_by_terms_and_value(specific_xpath).length.should == 0
     end 
-    it "should accept :parent_select, :parent_index and :child_index options instead of a :select" do
+    it "should accept :parent_select, :parent_index and :parent_index options instead of a :select" do
             
       generic_xpath = '//oxns:name[@type="personal" and position()=4]/oxns:role/oxns:roleTerm'
       specific_xpath = '//oxns:name[@type="personal" and position()=4]/oxns:role[oxns:roleTerm="visionary"]'
@@ -340,7 +388,7 @@ describe "OM::XML::TermValueOperators" do
       # Check that the specific node we want to delete no longer exists
       @sample.find_by_terms_and_value(specific_xpath).length.should == 1
     end
-    it "should work if only :parent_select and :child_index are provided" do
+    it "should work if only :parent_select and :parent_index are provided" do
       generic_xpath = '//oxns:name[@type="personal"]/oxns:role'
       # specific_xpath = '//oxns:name[@type="personal"]/oxns:role'
       

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: om
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Matt Zumwalt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-06 00:00:00 -06:00
+date: 2010-12-15 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency