om 2.2.1 → 3.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 047198eb8ea0cf1f0b32818fb21ea09be9f4edd7
-  data.tar.gz: 771c06c6304173f63d98db27a490eaf9adc38205
+  metadata.gz: 311c97a223b0160f5766d16da7ec636a85073c39
+  data.tar.gz: 907162fe5292c1316732f68be31d987a3892e402
 SHA512:
-  metadata.gz: d7c61df6a42241e45281c0831dbf822282c2630a019617d13c3e8aca005e9b017a6b16adfb10541df0553091e272b428a90d73eb9a29a7c3f0816a863415aca5
-  data.tar.gz: 2d5a6d8d73f56fd06ac885a55468c38c62f642d3d5090ce7c1c7e81af32dc0f93183647a63bc5f919a771223df8347374846b8798b413fbdda66b761b7fd1c82
+  metadata.gz: 249f1349616500b6fbf03cb8d2168fe87e19ea2084f29a77ea5a15996f349ed4b71a84c17a0b9b636f70f522d89f8be4d5f2dda3b3d41d442d5e4eea1830586e
+  data.tar.gz: 10386c58e84a42859682dc6e70b9fe11c548befbaec48185194d7c4897803d6ab8e5876ac4d5c6f57b62b943a34e5419502fc99575b8d4ed1b1fbc8fd82b5ebe

data/History.textile

@@ -1,9 +1,3 @@
-h3. 2.2.0 (20 June 2013)
-  Deprecate passing Hash values into DynamicNode#val= or 
-  Document#update_attributes. This behavior will be removed in 3.0.0
-  Rails 4 support
-  Pass nil in order to remove a node (instead of blank string)
-
 h3. 2.1.2 (3 May 2013)
   Fix missing comma after exception
 

data/lib/om/version.rb

@@ -1,3 +1,3 @@
 module Om
-  VERSION = "2.2.1"
+  VERSION = "3.0.0.beta1"
 end

data/lib/om/xml/dynamic_node.rb

@@ -69,11 +69,19 @@ module OM
 
       def val=(args)
         @document.ng_xml_will_change!
+        raise ArgumentError, "The new_values passed to #{to_pointer} must be an array or a string. You provided #{args.first.inspect}" unless [Array, String, NilClass].include?(args.first.class)
         new_values = term.sanitize_new_values(args.first)
+        existing_nodes = @document.find_by_xpath(xpath)
+        if existing_nodes.length > new_values.length
+          starting_index = new_values.length + 1
+          starting_index.upto(existing_nodes.size).each do |index|
+            @document.term_value_delete select: xpath, child_index: index
+          end
+        end
         new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y|
           z = new_values[y]
 ## If we pass something that already has an index on it, we should be able to add it.
-          if @document.find_by_xpath(xpath)[y.to_i].nil? || y.to_i == -1
+          if existing_nodes[y.to_i].nil? || y.to_i == -1
             parent_pointer = parent ? parent.to_pointer : nil
             @document.term_values_append(:parent_select=> parent_pointer,:parent_index=>0,:template=>to_pointer,:values=>z)
           else

data/lib/om/xml/term_value_operators.rb

@@ -29,10 +29,7 @@ module OM::XML::TermValueOperators
   # 
   # @param [Hash] params
   # @example
-  #   {[{":person"=>"0"}, "role", "text"]=>["role1", "role2", "role3"], 
-  #     [{:person=>1}, :family_name]=>"Andronicus", 
-  #     [{"person"=>"1"},:given_name]=>["Titus"],
-  #     [{:person=>1},:role,:text]=>["otherrole1","otherrole2"] }
+  #   {[{":person"=>"0"}, "role", "text"]=>["role1", "role2", "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    
     
@@ -47,35 +44,45 @@ module OM::XML::TermValueOperators
     result = params.dup
     
     params.each_pair do |term_pointer,new_values|
+      raise ArgumentError, "The new_values passed to update_values must be an array or string. You provided #{new_values}." unless [Array, String, NilClass, Symbol].include?(new_values.class)
       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) )
 
+      xpath = self.class.terminology.xpath_with_indexes(*pointer)
+      current_values = term_values(*pointer)
+
+      if new_values.is_a?(Array) && current_values.length > new_values.length
+        starting_index = new_values.length + 1
+        starting_index.upto(current_values.size).each do |index|
+          term_value_delete select: xpath, child_index: index
+        end
+      end
+
       # 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]
-        if current_values[y.to_i]==z and y.to_i > -1
+        if !z.nil? && 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)

data/lib/om/xml/term_xpath_generator.rb

@@ -206,17 +206,24 @@ module OM::XML::TermXpathGenerator
     if query_constraints.kind_of?(Hash)
       contains_functions = []
       query_constraints.each_pair do |k,v|
-        if k.instance_of?(Symbol)
-          constraint_path = final_term.children[k].xpath_relative
+
+        if v.is_a?(Integer) || v == "0" || v.to_i != 0
+          # lookup sub element 
+          xpath = '(' + xpath +  '/' + final_term.children[query_constraints.keys.first].xpath_relative + ")[#{v.to_i + 1}]"
         else
-          constraint_path = k
+          if k.instance_of?(Symbol)
+            constraint_path = final_term.children[k].xpath_relative
+          else
+            constraint_path = k
+          end
+          # match for text
+          contains_functions << "#{constraint_path}[text()=\"#{v}\"]"
+          xpath = add_predicate(xpath, delimited_list(contains_functions, " and ") )
         end
-        contains_functions << "contains(#{constraint_path}, \"#{v}\")"
       end
       
-      xpath = add_predicate(xpath, delimited_list(contains_functions, " and ") )
     end
-    
+    # 
     return xpath
   end
   

data/lib/om/xml/terminology.rb

@@ -222,6 +222,8 @@ class OM::XML::Terminology
   # Use the current terminology to generate an xpath with (optional) node indexes for each of the term pointers.
   # Ex.  terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, :text )
   #      will yield an xpath like this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+  # Ex.  terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, {:text => 0} )
+  #      will yield an xpath like this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"][1]'
   def xpath_with_indexes(*pointers)
     OM::XML::TermXpathGenerator.generate_xpath_with_indexes(self, *pointers)
   end

data/spec/unit/dynamic_node_spec.rb

@@ -126,7 +126,7 @@ describe "OM::XML::DynamicNode" do
       end
 
       it "Should be addressable to a specific node" do
-        @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>{"0"=>"434"} })
+        @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>"434"})
 
         @article.subject.topic(1).to_pointer == [:subject, {:topic => 1}]
         @article.journal(0).issue.length.should == 2
@@ -141,7 +141,7 @@ describe "OM::XML::DynamicNode" do
       
       describe ".nodeset" do
         it "should return a Nokogiri NodeSet" do
-          @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>{"0"=>"434"} })
+          @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>"434" })
           nodeset = @article.journal(0).issue(1).pages.start.nodeset
           nodeset.should be_kind_of Nokogiri::XML::NodeSet
           nodeset.length.should == @article.journal(0).issue(1).pages.start.length
@@ -156,6 +156,11 @@ describe "OM::XML::DynamicNode" do
         @article.should be_changed
       end
     
+      it "should remove extra nodes if fewer are given than currently exist" do
+        @article.journal.title_info = %W(one two three four five)
+        @article.journal.title_info = %W(six seven)
+        @article.journal.title_info.should == ["six", "seven"]
+      end
     end
   end
 end

data/spec/unit/nokogiri_sanity_spec.rb

@@ -18,55 +18,53 @@ describe "OM::XML::TermValueOperators" do
     end
   
     it "should respond with a hash of updated values and their indexes" do
-      test_args = {[{"person"=>"0"},"description"]=>{"-1"=>"mork", "1"=>"york"}}      
+      test_args = {[{"person"=>"0"},"description"]=>["mork", "york"]}      
       result = @article.update_values(test_args)
       result.should == {"person_0_description"=>{"0"=>"mork","1"=>"york"}}
     end
     
-    it "should update the xml in the specified datatsream and save those changes to Fedora" do
+    it "should update the xml in the specified datastream and know that changes have been made" do
       @article.term_values({:person=>0}, :first_name).should == ["GIVEN NAMES"]
-      test_args = {[{:person=>0}, :first_name]=>{"0"=>"Replacement FirstName"}}
+      test_args = {[{:person=>0}, :first_name]=>"Replacement FirstName"}
       @article.update_values(test_args)
       @article.term_values({:person=>0}, :first_name).should == ["Replacement FirstName"]
       @article.should be_changed
     end
     
     it "should update the xml according to the find_by_terms_and_values in the given hash" do
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
-      result = @article.update_values(terms_update_hash)
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
+      result = @article.update_values(terms_attributes)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
       
       # Trying again with a more complex update hash
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
-      result = @article.update_values(terms_update_hash)
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
+      result = @article.update_values(terms_attributes)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, "person_1_last_name"=>{"0"=>"Andronicus"},"person_1_first_name"=>{"0"=>"Titus"}, "person_1_role"=>{"0"=>"otherrole1","1"=>"otherrole2"}}
       @article.should be_changed
     end
     
     it "should work when you re-run the command" do
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
-      result = @article.update_values(terms_update_hash)
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
+      result = @article.update_values(terms_attributes)
       @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
       
-      # result = @article.update_values(terms_update_hash)
-      # result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
-      result = @article.update_values(terms_update_hash)
+      result = @article.update_values(terms_attributes)
       @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
-      result = @article.update_values(terms_update_hash)
+      result = @article.update_values(terms_attributes)
       
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
-      result = @article.update_values(terms_update_hash)
+      result = @article.update_values(terms_attributes)
       @article.term_values( {":person"=>"0"}, "affiliation" ).should == ["affiliation1", "affiliation2", "affiliation3"]
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}}
       
       # Trying again with a more complex update hash
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
-      result = @article.update_values(terms_update_hash)
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
+      result = @article.update_values(terms_attributes)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, "person_1_last_name"=>{"0"=>"Andronicus"},"person_1_first_name"=>{"0"=>"Titus"}, "person_1_role"=>{"0"=>"otherrole1","1"=>"otherrole2"}}
       @article.should be_changed
     end

data/spec/unit/term_value_operators_spec.rb

@@ -17,6 +17,11 @@ describe "OM::XML::TermValueOperators" do
       expected_values.each {|v| result.should include(v)}
     end
 
+    it "should look at the index" do
+      result = @sample.term_values(:role, {:text => 3})
+      result.should == ['visionary']
+    end
+
     it "should ignore whitespace elements for a term pointing to a text() node for an element that contains children" do
       @article.term_values(:name, :name_content).should == ["Describes a person"]
     end
@@ -26,8 +31,8 @@ describe "OM::XML::TermValueOperators" do
   
   describe ".update_values" do
     it "should update the xml according to the find_by_terms_and_values in the given hash" do
-      terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2".freeze, "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
-      result = @article.update_values(terms_update_hash)
+      terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2".freeze, "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
+      result = @article.update_values(terms_attributes)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, "person_1_last_name"=>{"0"=>"Andronicus"},"person_1_first_name"=>{"0"=>"Titus"}, "person_1_role"=>{"0"=>"otherrole1","1"=>"otherrole2"}}
       person_0_affiliation = @article.find_by_terms({:person=>0}, :affiliation)
       person_0_affiliation[0].text.should == "affiliation1"
@@ -47,8 +52,9 @@ describe "OM::XML::TermValueOperators" do
     end
 
     it "should allow setting a blank string " do
-      @article.update_values({[:title_info, :main_title]=>['']})
-      @article.term_values(:title_info, :main_title).should == ["", "Artikkelin otsikko Hydrangea artiklan 1", "TITLE OF HOST JOURNAL"]    end
+      @article.update_values([:abstract]=>[''])
+      @article.term_values(:abstract).should == [""]
+    end
 
     it "should call term_value_update if the corresponding node already exists" do
       @article.should_receive(:term_value_update).with('//oxns:titleInfo/oxns:title', 0, "My New Title")
@@ -64,28 +70,27 @@ describe "OM::XML::TermValueOperators" do
         :values => "My New Role"
       }
       @article.should_receive(:term_values_append).with(expected_args).twice
-      @article.update_values( {[{:person=>0}, :role] => {"6"=>"My New Role"}} )
-      @article.update_values( {[{:person=>0}, :role] => {"-1"=>"My New Role"}} )
+      @article.update_values( {[{:person=>0}, {:role => 6}] => "My New Role"} )
+      @article.update_values( {[{:person=>0}, {:role => 7}] => "My New Role"} )
     end
     
     it "should support updating attribute values" do
       pointer = [:title_info, :language]
       test_val = "language value"
-      @article.update_values( {pointer=>{"0"=>test_val}} )
+      @article.update_values( {pointer=>test_val} )
       @article.term_values(*pointer).first.should == test_val
     end
     
     it "should not get tripped up on root nodes" do
-      @article.update_values([:title_info]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"})
+      @article.update_values([:title_info]=>["york", "mangle","mork"])
       @article.term_values(*[:title_info]).should == ["york", "mangle", "mork"]
     end
 
     it "should destringify the field key/find_by_terms_and_value pointer" do
-      OM::Samples::ModsArticle.terminology.should_receive(:xpath_with_indexes).with( *[{:person=>0}, :role]).exactly(10).times.and_return("//oxns:name[@type=\"personal\"][1]/oxns:role")
-      OM::Samples::ModsArticle.terminology.stub(:xpath_with_indexes).with( *[{:person=>0}]).and_return("//oxns:name[@type=\"personal\"][1]")
-      @article.update_values( { [{":person"=>"0"}, "role"]=>"the role" } )
-      @article.update_values( { [{"person"=>"0"}, "role"]=>"the role" } )
-      @article.update_values( { [{:person=>0}, :role]=>"the role" } )
+      expected_result = {"person_0_role"=>{"0"=>"the role"}}
+      @article.update_values( { [{":person"=>"0"}, "role"]=>"the role" }).should == expected_result
+      @article.update_values( { [{"person"=>"0"}, "role"]=>"the role" }).should == expected_result
+      @article.update_values( { [{:person=>0}, :role]=>"the role" }).should == expected_result
     end
     
     it "should traverse named term proxies transparently" do
@@ -104,7 +109,7 @@ describe "OM::XML::TermValueOperators" do
 	  end
 	  
     it "should create deep trees of ancestor nodes" do
-      result = @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>{"0"=>"434"} })
+      result = @article.update_values( {[{:journal=>0}, {:issue=>3}, :pages, :start]=>"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
@@ -143,7 +148,7 @@ describe "OM::XML::TermValueOperators" do
     ### Examples copied over form nokogiri_datastream_spec
     
     it "should apply submitted hash to corresponding datastream field values" do
-      result = @article.update_values( {[{":person"=>"0"}, "first_name"]=>{"0"=>"Billy", "1"=>"Bob", "2"=>"Joe"} })
+      result = @article.update_values( {[{":person"=>"0"}, "first_name"]=>["Billy", "Bob", "Joe"] })
       result.should == {"person_0_first_name"=>{"0"=>"Billy", "1"=>"Bob", "2"=>"Joe"}}
       # xpath = ds.class.xpath_with_indexes(*field_key)
       # result = ds.term_values(xpath)
@@ -169,73 +174,66 @@ describe "OM::XML::TermValueOperators" do
     end
     
     it "should work for text fields" do 
-      att= {[{"person"=>"0"},"description"]=>{"-1"=>"mork", "1"=>"york"}}
+      att= {[{"person"=>"0"},"description"]=>["mork", "york"]}
       result = @article.update_values(att)
       result.should == {"person_0_description"=>{"0"=>"mork","1"=>"york"}}
       @article.term_values({:person=>0},:description).should == ['mork', 'york']
-      att= {[{"person"=>"0"},"description"]=>{"-1"=>"dork"}}
+      att= {[{"person"=>"0"},{"description" => 2}]=>"dork"}
       result2 = @article.update_values(att)
-      result2.should == {"person_0_description"=>{"2"=>"dork"}}
+      result2.should == {"person_0_description_2"=>{"0"=>"dork"}}
       @article.term_values({:person=>0},:description).should == ['mork', 'york', 'dork']
     end
     
-    it "should return the new index of any added values" do
-      @article.term_values({:title_info=>0},:main_title).should == ["ARTICLE TITLE HYDRANGEA ARTICLE 1", "TITLE OF HOST JOURNAL"]
-      result = @article.update_values [{"title_info"=>"0"},"main_title"]=>{"-1"=>"mork"}
-      result.should == {"title_info_0_main_title"=>{"2"=>"mork"}}
-    end
-    
-    it "should return accurate response when multiple values have been added in a single run" do
-      pending "THIS SHOULD BE FIXED"
-      att= {[:journal, :title_info]=>{"-1"=>"mork", "0"=>"york"}}
-      @article.update_values(att).should == {"journal_title_info"=>{"0"=>"york", "1"=>"mork"}}
-      @article.term_values(*att.keys.first).should == ["york", "mork"]
-    end
-    
     it "should append nodes at the specified index if possible" do
       @article.update_values([:journal, :title_info]=>["all", "for", "the"])
-      att = {[:journal, :title_info]=>{"3"=>'glory'}}
+      att = {[:journal, {:title_info => 3}]=>'glory'}
       result = @article.update_values(att)
-      result.should == {"journal_title_info"=>{"3"=>"glory"}}
+      result.should == {"journal_title_info_3"=>{"0"=>"glory"}}
       @article.term_values(:journal, :title_info).should == ["all", "for", "the", "glory"]
     end
+
+    it "should remove extra nodes if fewer are given than currently exist" do
+      @article.update_values([:journal, :title_info]=>%W(one two three four five))
+      result = @article.update_values({[:journal, :title_info]=>["six", "seven"]})
+      @article.term_values(:journal, :title_info).should == ["six", "seven"]
+    end
     
     it "should append values to the end of the array if the specified index is higher than the length of the values array" do
-      att = {[:journal, :issue, :pages, :end]=>{"3"=>'108'}}
+      att = {[:journal, :issue, :pages, {:end => 3}]=>'108'}
       @article.term_values(:journal, :issue, :pages, :end).should == []
       result = @article.update_values(att)
-      result.should == {"journal_issue_pages_end"=>{"0"=>"108"}}
+      result.should == {"journal_issue_pages_end_3"=>{"-1"=>"108"}}
       @article.term_values(:journal, :issue, :pages, :end).should == ["108"]
     end
     
     it "should allow deleting of values and should delete values so that to_xml does not return emtpy nodes" do
-      att= {[:journal, :title_info]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"}}
+      att= {[:journal, :title_info]=>["york", "mangle","mork"]}
       @article.update_values(att)
       @article.term_values(:journal, :title_info).should == ['york', 'mangle', 'mork']
       
-      @article.update_values({[:journal, :title_info]=>{"1"=>nil}})
+      @article.update_values({[:journal, {:title_info => 1}]=>nil})
       @article.term_values(:journal, :title_info).should == ['york', 'mork']
       
-      @article.update_values({[:journal, :title_info]=>{"0"=>:delete}})
+      @article.update_values({[:journal, {:title_info => 0}]=>:delete})
       @article.term_values(:journal, :title_info).should == ['mork']
     end
 
     describe "delete_on_update?" do
 
       before(:each) do
-        att= {[:journal, :title_info]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"}}
+        att= {[:journal, :title_info]=>["york", "mangle","mork"]}
         @article.update_values(att)
         @article.term_values(:journal, :title_info).should == ['york', 'mangle', 'mork']
       end
 
-      it "by default, setting to empty string deletes the node" do
-        @article.update_values({[:journal, :title_info]=>{"1"=>nil}})
+      it "by default, setting to nil deletes the node" do
+        @article.update_values({[:journal, {:title_info => 1}]=>nil})
         @article.term_values(:journal, :title_info).should == ['york', 'mork']
       end
 
       it "if delete_on_update? returns false, setting to nil won't delete node" do
         @article.stub('delete_on_update?').and_return(false)
-        @article.update_values({[:journal, :title_info]=>{"1"=>""}})
+        @article.update_values({[:journal, {:title_info => 1}]=>""})
         @article.term_values(:journal, :title_info).should == ['york', '', 'mork']
       end
 
@@ -395,7 +393,7 @@ describe "OM::XML::TermValueOperators" do
       1.should == 2
     end
     it "should delete nodes if value is :delete or nil" do
-      @article.update_values([:title_info]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"})
+      @article.update_values([:title_info]=>["york", "mangle","mork"])
       xpath = @article.class.terminology.xpath_for(:title_info)
       
       @article.term_value_update([:title_info], 1, nil)
@@ -405,7 +403,7 @@ describe "OM::XML::TermValueOperators" do
       @article.term_values(:title_info).should == ['york']
     end
     it "should create empty nodes if value is empty string" do
-      @article.update_values([:title_info]=>{"0"=>"york", "1"=>'',"2"=>"mork"})
+      @article.update_values([:title_info]=>["york", '', "mork"])
       @article.term_values(:title_info).should == ['york', "", "mork"]
     end
   end

data/spec/unit/term_xpath_generator_spec.rb

@@ -89,11 +89,38 @@ describe "OM::XML::TermXpathGeneratorSpec" do
 
   describe "generate_xpath_with_indexes" do
     it "should accept multiple constraints" do
-      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, :person, {:first_name=>"Tim", :family_name=>"Berners-Lee"} )
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
+                                                    :person, {:first_name=>"Tim", :family_name=>"Berners-Lee"} )
       # expect an xpath that looks like this: '//oxns:name[@type="personal" and contains(oxns:namePart[@type="family"], "Berners-Lee") and contains(oxns:namePart[@type="given"], "Tim")]'
-      # can't use string comparison because the contains functions can arrive in any order
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"given\"\], \"Tim\"\).*\]/ )
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"family\"\], \"Berners-Lee\"\).*\]/ )
+      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"given\"\]\[text\(\)=\"Tim\"\].*\]/ )
+      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"family\"\]\[text\(\)=\"Berners-Lee\"\].*\]/ )
+    end
+
+    it "should find matching nodes" do
+      ng = Nokogiri::XML(fixture( File.join("test_dummy_mods.xml")))
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
+                                                    :person, {:first_name=>"Tim", :family_name=>"Berners-Lee"} )
+      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").to_xml.should be_equivalent_to <<EOF
+      <ns3:name type="personal">
+          <ns3:namePart type="family">Berners-Lee</ns3:namePart>
+          <ns3:namePart type="given">Tim</ns3:namePart>
+          <ns3:role>
+              <ns3:roleTerm type="text" authority="marcrelator">creator</ns3:roleTerm>
+              <ns3:roleTerm type="code" authority="marcrelator">cre</ns3:roleTerm>
+          </ns3:role>
+      </ns3:name>
+EOF
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
+                                                    :person, {:first_name=>"Tim", :family_name=>"Berners"} )
+      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
+                                                    :person, {:first_name=>"Frank", :family_name=>"Berners-Lee"} )
+      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
+                                                     :person, {:first_name=>"Tim", :family_name=>"Howard"} )
+      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+
     end
     it "should support xpath queries as argument" do
       OM::XML::TermXpathGenerator.generate_xpath_with_indexes(@sample_terminology, '//oxns:name[@type="personal"][1]/oxns:namePart').should == '//oxns:name[@type="personal"][1]/oxns:namePart'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: om
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 3.0.0.beta1
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -293,9 +293,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3