om 0.1.10 → 1.0.0

data/spec/unit/term_value_operators_spec.rb

@@ -0,0 +1,361 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::TermValueOperators" do
+  
+  before(:each) do
+    @sample = OM::Samples::ModsArticle.from_xml( fixture( File.join("test_dummy_mods.xml") ) )
+    @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
+  end
+  
+  describe ".term_values" do
+
+    it "should return build an array of values from the nodeset corresponding to the given term" do
+      expected_values = ["Berners-Lee", "Jobs", "Wozniak", "Klimt"]
+      result = @sample.term_values(:person, :last_name)
+      result.length.should == expected_values.length
+      expected_values.each {|v| result.should include(v)}
+    end
+  
+  end
+  
+  
+  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", "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
+      result = @article.update_values(terms_update_hash)
+      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"
+      person_0_affiliation[1].text.should == "affiliation2"
+      person_0_affiliation[2].text.should == "affiliation3"
+      
+      person_1_last_names = @article.find_by_terms({:person=>1}, :last_name)
+      person_1_last_names.length.should == 1
+      person_1_last_names.first.text.should == "Andronicus"
+      
+      person_1_first_names = @article.find_by_terms({:person=>1}, :first_name)
+      person_1_first_names.first.text.should == "Titus"
+      
+      person_1_roles = @article.find_by_terms({:person=>1}, :role)
+      person_1_roles[0].text.should == "otherrole1"
+      person_1_roles[1].text.should == "otherrole2"
+    end
+    it "should call term_value_update if the corresponding node already exists" 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,
+        :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] => {"-1"=>"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.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.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.expects(:xpath_with_indexes).with( *[{:person=>0}, :role]).times(7).returns("//oxns:name[@type=\"personal\"][1]/oxns:role")
+      OM::Samples::ModsArticle.terminology.stubs(:xpath_with_indexes).with( *[{:person=>0}]).returns("//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" } )
+    end
+    
+    it "should traverse named term proxies transparently" do
+      @article.term_values( :journal, :issue, :start_page).should_not == ["108"]      
+      @article.update_values( { ["journal", "issue", "start_page"]=>"108" } )
+      @article.term_values( :journal, :issue, :start_page).should == ["108"]      
+      @article.term_values( :journal, :issue, :pages, :start).should == ["108"]
+    end
+    
+    ### 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.should == {"person_0_first_name"=>{"0"=>"Billy", "1"=>"Bob", "2"=>"Joe"}}
+      # xpath = ds.class.xpath_with_indexes(*field_key)
+      # result = ds.term_values(xpath)
+      @article.term_values({:person=>0}, :first_name).should == ["Billy","Bob","Joe"]
+      @article.term_values('//oxns:name[@type="personal"][1]/oxns:namePart[@type="given"]').should == ["Billy","Bob","Joe"]
+    end
+    it "should support single-value arguments (as opposed to a hash of values with array indexes as keys)" do
+      # In other words, { [:journal, :title_info]=>"dork" } should have the same effect as { [:journal, :title_info]=>{"0"=>"dork"} }
+      result = @article.update_values( { [{":person"=>"0"}, "role"]=>"the role" } )
+      result.should == {"person_0_role"=>{"0"=>"the role"}}
+      @article.term_values({:person=>0}, :role).first.should == "the role"     
+      @article.term_values('//oxns:name[@type="personal"][1]/oxns:role').first.should == "the role"
+    end
+    it "should do nothing if field key is a string (must be an array or symbol).  Will not accept xpath queries!" do
+      xml_before = @article.to_xml
+      @article.update_values( { "fubar"=>"the role" } ).should == {}
+      @article.to_xml.should == xml_before
+    end
+    it "should do nothing if there is no term corresponding to the given field key" do
+      xml_before = @article.to_xml
+      @article.update_values( { [{"fubar"=>"0"}]=>"the role" } ).should == {}
+      @article.to_xml.should == xml_before
+    end
+    
+    it "should work for text fields" do 
+      att= {[{"person"=>"0"},"description"]=>{"-1"=>"mork", "1"=>"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"}}
+      result2 = @article.update_values(att)
+      result2.should == {"person_0_description"=>{"2"=>"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'}}
+      result = @article.update_values(att)
+      result.should == {"journal_title_info"=>{"3"=>"glory"}}
+      @article.term_values(:journal, :title_info).should == ["all", "for", "the", "glory"]
+    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'}}
+      @article.term_values(:journal, :issue, :pages, :end).should == []
+      result = @article.update_values(att)
+      result.should == {"journal_issue_pages_end"=>{"0"=>"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"}}
+      @article.update_values(att)
+      @article.term_values(:journal, :title_info).should == ['york', 'mangle', 'mork']
+      
+      @article.update_values({[:journal, :title_info]=>{"1"=>""}})
+      @article.term_values(:journal, :title_info).should == ['york', 'mork']
+      
+      @article.update_values({[:journal, :title_info]=>{"0"=>:delete}})
+      @article.term_values(:journal, :title_info).should == ['mork']
+    end
+    
+  end
+  
+  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      
+	    @sample.term_values_append(
+        :parent_select => [:person, {:first_name=>"Tim", :last_name=>"Berners-Lee"}] ,
+        :child_index => :first,
+        :template => [:person, :affiliation],
+        :values => ["my new value", "another new value"] 
+      )
+    end
+    
+    it "should accept parent_select and template [term_reference, find_by_terms_and_value_opts] as argument arrays for generators/find_by_terms_and_values" do
+      # this appends two affiliation nodes into the first person node whose name is Tim Berners-Lee
+      expected_result = '<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:affiliation>my new value</ns3:affiliation><ns3:affiliation>another new value</ns3:affiliation></ns3:name>'
+      
+	    @sample.term_values_append(
+        :parent_select => [:person, {:first_name=>"Tim", :last_name=>"Berners-Lee"}] ,
+        :child_index => :first,
+        :template => [:person, :affiliation],
+        :values => ["my new value", "another new value"] 
+      ).to_xml.should == expected_result
+      
+      @sample.find_by_terms(:person, {:first_name=>"Tim", :last_name=>"Berners-Lee"}).first.to_xml.should == expected_result
+    end
+    
+    it "should support adding attribute values" do
+      pending 
+      pointer = [:title_info, :language]
+      test_val = "language value"
+      @article.term_values_append( 
+        :parent_select => :title_info,
+        :child_index => :first,
+        :template => [:title_info, :language],
+        :values => test_val
+      )
+      @article.term_values(*pointer).first.should == test_val
+    end
+    
+    it "should accept symbols as arguments for generators/find_by_terms_and_values" 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,
+        :template => :role,
+        :values => "my role" 
+      ).to_xml.should #== expected_result
+      @sample.find_by_terms(:person)[3].search("./ns3:role[3]").first.text.should == "my role" 
+    end
+    
+    it "should accept parent_select as an (xpath) string and template as a (template) string" do
+      # this uses the provided template to add a node into the first node resulting from the xpath '//oxns:name[@type="personal"]'
+      expected_result = "<ns3:name type=\"personal\">\n      <ns3:namePart type=\"family\">Berners-Lee</ns3:namePart>\n      <ns3:namePart type=\"given\">Tim</ns3:namePart>\n      <ns3:role>\n          <ns3:roleTerm type=\"text\" authority=\"marcrelator\">creator</ns3:roleTerm>\n          <ns3:roleTerm type=\"code\" authority=\"marcrelator\">cre</ns3:roleTerm>\n      </ns3:role>\n  <ns3:role type=\"code\" authority=\"marcrelator\"><ns3:roleTerm>creator</ns3:roleTerm></ns3:role></ns3:name>"
+      
+      @sample.ng_xml.xpath('//oxns:name[@type="personal" and position()=1]/oxns:role', @sample.ox_namespaces).length.should == 1
+      
+      @sample.term_values_append(
+        :parent_select =>'//oxns:name[@type="personal"]',
+        :child_index => 0,
+        :template => 'xml.role { xml.roleTerm( \'#{builder_new_value}\', :type=>\'code\', :authority=>\'marcrelator\') }',
+        :values => "founder" 
+      )
+
+      @sample.ng_xml.xpath('//oxns:name[@type="personal" and position()=1]/oxns:role', @sample.ox_namespaces).length.should == 2
+      @sample.ng_xml.xpath('//oxns:name[@type="personal" and position()=1]/oxns:role[last()]/oxns:roleTerm', @sample.ox_namespaces).first.text.should == "founder"
+
+      # @sample.find_by_terms_and_value(:person).first.to_xml.should == expected_result
+    end
+	  
+	  it "should support more complex mixing & matching" do
+	    pending "not working because builder_template is not returning the correct template (returns builder for role instead of roleTerm)"
+      @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,
+        :template => [ :person, :role, :text, {:attributes=>{"authority"=>"marcrelator"}} ],
+        :values => "foo" 
+      )
+
+      @sample.ng_xml.xpath('//oxns:name[@type="personal"][2]/oxns:role[1]/oxns:roleTerm', @sample.ox_namespaces).length.should == 3
+      @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"
+  	
+  end
+  
+  describe ".term_value_update" do
+    
+    it "should accept an xpath as :parent_select" do
+	    sample_xpath = '//oxns:name[@type="personal"][4]/oxns:role/oxns:roleTerm[@type="text"]'
+	    @sample.term_value_update(sample_xpath,1,"artist")
+      @sample.ng_xml.xpath(sample_xpath, @sample.ox_namespaces)[1].text.should == "artist"
+    end
+    
+    it "if :select is provided, should update the first node provided by that xpath statement" do
+      sample_xpath = '//oxns:name[@type="personal"][1]/oxns:namePart[@type="given"]'
+      @sample.term_value_update(sample_xpath,0,"Timmeh")
+      @sample.ng_xml.xpath(sample_xpath, @sample.ox_namespaces).first.text.should == "Timmeh"
+    end
+    
+    it "should replace the existing node if you pass a template and values" do
+      pending
+      @sample.term_value_update(
+        :parent_select =>'//oxns:name[@type="personal"]',
+        :child_index => 1,
+        :template => [ :person, :role, {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}} ],
+        :value => "foo"
+      )
+      1.should == 2
+    end
+    it "should delete nodes if value is :delete or empty string" do
+      @article.update_values([:title_info]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"})
+      xpath = @article.class.terminology.xpath_for(:title_info)
+      
+      @article.term_value_update([:title_info], 1, "")
+      @article.term_values(:title_info).should == ['york', 'mork']
+      
+      @article.term_value_update([:title_info], 1, :delete)
+      @article.term_values(:title_info).should == ['york']
+    end
+    it "should create empty nodes if value is nil" do
+      @article.update_values([:title_info]=>{"0"=>"york", "1"=>nil,"2"=>"mork"})
+      @article.term_values(:title_info).should == ['york', "", "mork"]
+    end
+  end
+  
+  describe ".term_value_delete" do
+    it "should accept an xpath query as :select option" do
+      generic_xpath = '//oxns:name[@type="personal" and position()=4]/oxns:role'
+      specific_xpath = '//oxns:name[@type="personal" and position()=4]/oxns:role[oxns:roleTerm="visionary"]'
+      select_xpath = '//oxns:name[@type="personal" and position()=4]/oxns:role[last()]'
+      
+      # Check that we're starting with 2 roles
+      # Check that the specific node we want to delete exists
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 2
+      @sample.find_by_terms_and_value(specific_xpath).length.should == 1
+
+      @sample.term_value_delete(
+        :select =>select_xpath
+      )
+      # Check that we're finishing with 1 role
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 1
+      # 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
+            
+      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"]'
+      
+      # Check that we're starting with 2 roles
+      # Check that the specific node we want to delete exists
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 4
+      @sample.find_by_terms_and_value(specific_xpath).length.should == 1
+
+      # this is attempting to delete the last child (in this case roleTerm) from the 3rd role in the document. 
+      @sample.term_value_delete(
+        :parent_select => [:person, :role],
+        :parent_index => 3,
+        :child_index => :last
+      )
+      
+      # Check that we're finishing with 1 role
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 3
+      # 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
+      generic_xpath = '//oxns:name[@type="personal"]/oxns:role'
+      # specific_xpath = '//oxns:name[@type="personal"]/oxns:role'
+      
+      # Check that we're starting with 2 roles
+      # Check that the specific node we want to delete exists
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 4
+      # @sample.find_by_terms_and_value(specific_xpath).length.should == 1
+
+      @sample.term_value_delete(
+        :parent_select => [:person, :role],
+        :child_index => 3
+      )
+      # Check that we're finishing with 1 role
+      @sample.find_by_terms_and_value(generic_xpath).length.should == 3
+    end
+  end
+  
+end

data/spec/unit/term_xpath_generator_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::TermXpathGeneratorSpec" do
+
+  before(:all) do
+    builder = OM::XML::Terminology::Builder.new do |t|
+      t.root(:path=>"mods")
+      t.name_ {
+        t.family_name(:path=>"namePart", :attributes=>{:type=>"family"})
+        t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+      }
+      # lookup :person, :first_name        
+      t.person(:ref=>:name, :attributes=>{:type=>"personal"})
+    end
+    @sample_terminology = builder.build 
+    @rootless_terminology = OM::XML::Terminology.new   
+  end
+  
+  before(:each) do
+    @test_term = OM::XML::Term.new(:terms_of_address, :path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+    @test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+    @test_role_text = OM::XML::Term.new(:role_text, :path=>"roleTerm", :attributes=>{:type=>"text"})
+    @test_lang_attribute = OM::XML::Term.new(:language, :path=>{:attribute=>"lang"})
+  end
+  
+  it "should support terms that are pointers to attribute values" do
+    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :absolute).should == "//@lang"
+    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :relative).should == "@lang"
+    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :constrained).should == '//@lang[contains(., "#{constraint_value}")]'.gsub('"', '\"')  
+  end
+  
+  describe "generate_xpath" do
+    it "should generate an xpath based on the given mapper and options" do
+      OM::XML::TermXpathGenerator.expects(:generate_absolute_xpath).with(@test_term)
+      OM::XML::TermXpathGenerator.generate_xpath(@test_term, :absolute)
+      
+      OM::XML::TermXpathGenerator.expects(:generate_relative_xpath).with(@test_term)
+      OM::XML::TermXpathGenerator.generate_xpath(@test_term, :relative)
+      
+      OM::XML::TermXpathGenerator.expects(:generate_constrained_xpath).with(@test_term)
+      OM::XML::TermXpathGenerator.generate_xpath(@test_term, :constrained)
+    end
+  end
+    
+  describe "generate_relative_xpath" do
+    it "should generate a relative xpath based on the given mapper" do
+      OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'oxns:namePart[@type="termsOfAddress"]'
+    end
+    it "should support mappers without namespaces" do
+      @test_term.namespace_prefix = nil
+      OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
+    end
+  end
+  
+  describe "generate_absolute_xpath" do
+    it "should generate an absolute xpath based on the given mapper" do
+      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//oxns:namePart[@type="termsOfAddress"]'
+    end
+    it "should prepend the xpath for any parent nodes" do  
+      mock_parent_mapper = mock("Term", :xpath_absolute=>'//oxns:name[@type="conference"]/oxns:role')
+      @test_role_text.stubs(:parent).returns(mock_parent_mapper)
+      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text).should == '//oxns:name[@type="conference"]/oxns:role/oxns:roleTerm[@type="text"]'
+    end
+  end
+
+  describe "generate_constrained_xpath" do
+    it "should generate a constrained xpath based on the given mapper" do
+      OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term).should == '//oxns:namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"')   
+    end
+  end
+  
+  it "should support mappers without namespaces" do
+    @test_term.namespace_prefix = nil
+    OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
+    OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//namePart[@type="termsOfAddress"]'
+    OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term).should == '//namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"')   
+  end
+  
+  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"} )
+      # 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\"\).*\]/ )  
+    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'
+    end
+    it "should return the xpath of the terminology's root node if term pointer is nil" do
+      OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, nil ).should == @sample_terminology.root_terms.first.xpath
+    end
+    it "should return / if term pointer is nil and the terminology does not have a root term defined" do
+      OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @rootless_terminology, nil ).should == "/"
+    end
+    it "should destringify term pointers before using them" do
+      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, {"person"=>"1"}, "first_name" ).should == '//oxns:name[@type="personal"][2]/oxns:namePart[@type="given"]'
+    end
+  end
+  
+  it "should support mappers with default_content_path" do
+    pending "need to implement mapper_set first"
+    #@test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+    
+    OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term_with_default_path).should == 'oxns:detail[@type="volume"]'
+    OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term_with_default_path).should == '//oxns:detail[@type="volume"]'
+    OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term_with_default_path).should == '//oxns:detail[contains(oxns:number[@type="volume"], "#{constraint_value}")]'.gsub('"', '\"')  
+  end
+  
+end

data/spec/unit/terminology_builder_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::Terminology::Builder" do
+  
+    before(:each) do
+      @test_builder = OM::XML::Terminology::Builder.new
+      
+      @builder_with_block = OM::XML::Terminology::Builder.new do |t|
+        t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+
+        t.title_info(:path=>"titleInfo") {
+          t.main_title(:path=>"title", :label=>"title")
+          t.language(:path=>{:attribute=>"lang"})
+        }          
+        # t.title(:path=>"titleInfo", :default_content_path=>"title") {
+        #   t.@language(:path=>{:attribute=>"lang"})
+        # }            
+        # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
+        t.name_ {
+          # this is a namepart
+          t.namePart(:index_as=>[:searchable, :displayable, :facetable, :sortable], :required=>:true, :type=>:string, :label=>"generic name")
+          # affiliations are great
+          t.affiliation
+          t.displayForm
+          t.role(:ref=>[:role])
+          t.description
+          t.date(:path=>"namePart", :attributes=>{:type=>"date"})
+          t.family_name(:path=>"namePart", :attributes=>{:type=>"family"})
+          t.given_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+          t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        }
+        # lookup :person, :first_name        
+        t.person(:ref=>:name, :attributes=>{:type=>"personal"})
+
+        t.role {
+          t.text(:path=>"roleTerm",:attributes=>{:type=>"text"})
+          t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
+        }
+        t.journal(:path=>'relatedItem', :attributes=>{:type=>"host"}) {
+          t.title_info
+          t.origin_info(:path=>"originInfo")
+          t.issn(:path=>"identifier", :attributes=>{:type=>"issn"})
+          t.issue(:ref=>[:issue])
+        }
+        t.issue(:path=>"part") {
+          t.volume(:path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+          t.level(:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number")
+          t.pages(:path=>"extent", :attributes=>{:unit=>"pages"}) {
+            t.start
+            t.end
+          }
+          # t.start_page(:path=>"pages", :attributes=>{:type=>"start"})
+          # t.end_page(:path=>"pages", :attributes=>{:type=>"end"})
+          # t.start_page(:path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "start")
+          # t.end_page(:path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "end")
+          t.publication_date(:path=>"date")
+          # t.my_absolute_proxy(:proxy_absolute=>[:name, :role]) # this should always point to [:name, :role]
+          t.start_page(:proxy=>[:pages, :start])
+          t.start_page(:proxy=>[:pages, :end])
+        }
+      end
+
+      # @test_full_terminology = @builder_with_block.build
+      
+    end
+    
+    describe '#new' do
+      it "should return an instance of OM::XML::Terminology::Builder" do
+        OM::XML::Terminology::Builder.new.should be_instance_of OM::XML::Terminology::Builder
+      end
+      it "should process the input block, creating a new Term Builder for each entry and its children" do
+        expected_root_terms = [:mods, :title_info, :issue, :person, :name, :journal, :role]
+        expected_root_terms.each do |name|
+          @builder_with_block.term_builders.should have_key(name)
+        end
+        @builder_with_block.term_builders.length.should == expected_root_terms.length
+        
+        @builder_with_block.term_builders[:journal].should be_instance_of OM::XML::Term::Builder
+        @builder_with_block.term_builders[:journal].settings[:path].should == "relatedItem"
+        @builder_with_block.term_builders[:journal].settings[:attributes].should == {:type=>"host"}
+
+        @builder_with_block.term_builders[:journal].children[:issn].should be_instance_of OM::XML::Term::Builder
+        @builder_with_block.term_builders[:journal].children[:issn].settings[:path].should == "identifier"
+        @builder_with_block.term_builders[:journal].children[:issn].settings[:attributes].should == {:type=>"issn"}
+      end
+      it "should clip the underscore off the end of any Term names" do
+        @builder_with_block.term_builders[:name].should be_instance_of OM::XML::Term::Builder
+        @builder_with_block.term_builders[:name].name.should == :name
+
+        @builder_with_block.term_builders[:name].children[:date].should be_instance_of OM::XML::Term::Builder
+        @builder_with_block.term_builders[:name].children[:date].settings[:path].should == "namePart"
+        @builder_with_block.term_builders[:name].children[:date].settings[:attributes].should == {:type=>"date"}
+      end
+    end
+    
+    describe '#from_xml' do
+      it "should let you load mappings from an xml file" do
+        pending
+        vocab = OM::XML::Terminology.from_xml( fixture("sample_mappings.xml") )
+        vocab.should be_instance_of OM::XML::Terminology
+        vocab.mappers.should == {}
+      end
+    end
+    
+    describe ".retrieve_term_builder" do
+      it "should support looking up Term Builders by pointer" do
+        expected = @builder_with_block.term_builders[:name].children[:date]
+        @builder_with_block.retrieve_term_builder(:name, :date).should == expected
+      end
+    end
+    
+    describe "build" do
+      it "should generate the new Terminology, calling .build on its Term builders"
+      it "should resolve :refs" do
+        @builder_with_block.retrieve_term_builder(:name, :role).settings[:ref].should == [:role]
+        @builder_with_block.retrieve_term_builder(:role).children[:text].should be_instance_of OM::XML::Term::Builder
+        
+        built_terminology = @builder_with_block.build
+        
+        built_terminology.retrieve_term(:name, :role, :text).should be_instance_of OM::XML::Term
+        built_terminology.retrieve_term(:name, :role, :text).path.should == "roleTerm"
+        built_terminology.retrieve_term(:name, :role, :text).attributes.should == {:type=>"text"}
+      end
+      it "should put copies of the entire terminology under any root terms" do
+        @builder_with_block.root_term_builders.should include(@builder_with_block.retrieve_term_builder(:mods))
+        
+        built_terminology = @builder_with_block.build
+        expected_keys = [:title_info, :issue, :person, :name, :journal, :role]
+        
+        built_terminology.retrieve_term(:mods).children.length.should == expected_keys.length
+        expected_keys.each do |key|
+          built_terminology.retrieve_term(:mods).children.keys.should include(key)
+        end
+        built_terminology.retrieve_term(:mods, :name, :role, :text).should be_instance_of OM::XML::Term
+        built_terminology.retrieve_term(:mods, :person, :role, :text).should be_instance_of OM::XML::Term
+
+      end
+    end
+    
+    describe '.insert_term' do
+      it "should create a new OM::XML::Term::Builder and insert it into the class mappings hash" do
+        pending
+        
+        result = @test_builder.insert_mapper(:name_, :namePart).index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)  
+        @test_builder.mapper_builders(:name_, :namePart).should == result
+        result.should be_instance_of OM::XML::Mapper::Builder
+      end
+    end
+    
+    describe ".root" do
+      it "should accept options for the root node, such as namespace(s)  and schema and those values should impact the resulting Terminology" do
+        root_term_builder = @test_builder.root(:path=>"mods", :xmlns => 'one:two', 'xmlns:foo' => 'bar', :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+        root_term_builder.settings[:is_root_term].should == true
+        
+        @test_builder.schema.should == "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
+        @test_builder.namespaces.should == { "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' }
+        @test_builder.term_builders[:mods].should == root_term_builder      
+        
+        terminology = @test_builder.build
+        terminology.schema.should == "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
+        terminology.namespaces.should == { "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' }
+        terminology.retrieve_term(:mods).should be_instance_of OM::XML::Term
+        terminology.retrieve_term(:mods).is_root_term?.should == true
+      end
+      it "should work within a builder block" do
+        @builder_with_block.term_builders[:mods].settings[:is_root_term].should == true
+      end
+    end
+    
+    describe ".root_term_builders" do
+      it "should return the terms that have been marked root" do
+        @builder_with_block.root_term_builders.length.should == 1
+        @builder_with_block.root_term_builders.first.should == @builder_with_block.term_builders[:mods]
+      end
+    end
+    
+end