om 1.4.4 → 1.5.0

data/spec/unit/term_xpath_generator_spec.rb

@@ -5,50 +5,50 @@ describe "OM::XML::TermXpathGeneratorSpec" do
 
   before(:all) do
     builder = OM::XML::Terminology::Builder.new do |t|
-      t.root(:path=>"mods")
+      t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
       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        
+      # lookup :person, :first_name
       t.person(:ref=>:name, :attributes=>{:type=>"personal"})
       t.family_name(:proxy=>[:name, :family_name])
     end
-    @sample_terminology = builder.build 
-    @rootless_terminology = OM::XML::Terminology.new   
+    @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"})
     @test_none_attribute_value = OM::XML::Term.new(:person_id, :path=>"namePart", :attributes=>{:type=>:none})
-    
+
   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('"', '\"')  
+    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"]'
+      OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
     end
     it "should support mappers without namespaces" do
       @test_term.namespace_prefix = nil
@@ -59,42 +59,42 @@ describe "OM::XML::TermXpathGeneratorSpec" do
       OM::XML::TermXpathGenerator.generate_relative_xpath(text_term).should == 'text()[normalize-space(.)]'
     end
     it "should set a 'not' predicate if the attribute value is :none" do
-       OM::XML::TermXpathGenerator.generate_relative_xpath(@test_none_attribute_value).should == 'oxns:namePart[not(@type)]'
+       OM::XML::TermXpathGenerator.generate_relative_xpath(@test_none_attribute_value).should == 'namePart[not(@type)]'
     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"]'
+      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//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')
+    it "should prepend the xpath for any parent nodes" do
+      mock_parent_mapper = mock("Term", :xpath_absolute=>'//name[@type="conference"]/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"]'
+      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text).should == '//name[@type="conference"]/role/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('"', '\"')   
+      OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term).should == '//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('"', '\"')   
+    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\"\).*\]/ )  
+      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'
@@ -115,14 +115,22 @@ describe "OM::XML::TermXpathGeneratorSpec" do
       @sample_terminology.xpath_with_indexes({:family_name=>1}).should == "//oxns:name/oxns:namePart[@type=\"family\"]"
     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('"', '\"')  
+    OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term_with_default_path).should == '//oxns:detail[contains(oxns:number[@type="volume"], "#{constraint_value}")]'.gsub('"', '\"')
   end
-  
+
+  it "should default to using an inherited namspace prefix" do
+
+    term = @sample_terminology.retrieve_term(:person, :first_name)
+    OM::XML::TermXpathGenerator.generate_absolute_xpath(term).should == "//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]"
+
+
+  end
+
 end

data/spec/unit/terminology_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require "om"
 
 describe "OM::XML::Terminology" do
-  
+
   before(:each) do
     @test_terminology = OM::XML::Terminology.new
 
@@ -21,10 +21,10 @@ describe "OM::XML::Terminology" do
           t.main_title_lang(:path=>{:attribute=> "xml:lang"})
         }
         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
@@ -40,10 +40,10 @@ describe "OM::XML::Terminology" do
         t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
         t.person_id(:path=>"namePart", :attributes=>{:type=>:none})
       }
-      # lookup :person, :first_name        
+      # lookup :person, :first_name
       t.person(:ref=>:name, :attributes=>{:type=>"personal"})
       t.conference(:ref=>:name, :attributes=>{:type=>"conference"})
-      
+
       t.role {
         t.text(:path=>"roleTerm",:attributes=>{:type=>"text"})
         t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
@@ -72,14 +72,40 @@ describe "OM::XML::Terminology" do
 
     @test_full_terminology = @builder_with_block.build
 
+    @namespaceless_terminology = OM::XML::Terminology::Builder.new do |t|
+      t.root(:path=>"note", :xmlns=> nil )
+      t.to
+      t.from
+      t.heading
+      t.body
+    end
+    @namespaceless_terminology = @namespaceless_terminology.build
+
+    class NamespacelessTest
+      include OM::XML::Document
+    end
+    NamespacelessTest.terminology = @namespaceless_terminology
+    @namespaceless_doc = NamespacelessTest.from_xml(fixture("no_namespace.xml") )
+  end
+
+  describe "namespaceless terminologies" do
+    it "should generate xpath queries without namespaces" do
+      @namespaceless_terminology.xpath_for(:to).should == "//to"
+      @namespaceless_terminology.xpath_for(:note, :from).should == "//note/from"
+    end
+
+    it "should work with xml documents that have no namespaces" do
+      @namespaceless_doc.from.first.should == "Jani"
+      @namespaceless_doc.to.should == ["Tove"]
+    end
   end
-    
+
   describe "basics" do
 
     it "constructs xpath queries for finding properties" do
-      @test_full_terminology.retrieve_term(:name).xpath.should == '//oxns:name'   
-      @test_full_terminology.retrieve_term(:name).xpath_relative.should == 'oxns:name'  
-      
+      @test_full_terminology.retrieve_term(:name).xpath.should == '//oxns:name'
+      @test_full_terminology.retrieve_term(:name).xpath_relative.should == 'oxns:name'
+
       @test_full_terminology.retrieve_term(:person).xpath.should == '//oxns:name[@type="personal"]'
       @test_full_terminology.retrieve_term(:person).xpath_relative.should == 'oxns:name[@type="personal"]'
       @test_full_terminology.retrieve_term(:person, :person_id).xpath_relative.should == 'oxns:namePart[not(@type)]'
@@ -92,9 +118,9 @@ describe "OM::XML::Terminology" do
     end
 
     it "constructs templates for value-driven searches" do
-      @test_full_terminology.retrieve_term(:name).xpath_constrained.should == '//oxns:name[contains(., "#{constraint_value}")]'.gsub('"', '\"')  
+      @test_full_terminology.retrieve_term(:name).xpath_constrained.should == '//oxns:name[contains(., "#{constraint_value}")]'.gsub('"', '\"')
       @test_full_terminology.retrieve_term(:person).xpath_constrained.should == '//oxns:name[@type="personal" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
-      
+
       # Example of how you could use these templates:
       constraint_value = "SAMPLE CONSTRAINT VALUE"
       constrained_query = eval( '"' + @test_full_terminology.retrieve_term(:person).xpath_constrained + '"' )
@@ -105,9 +131,9 @@ describe "OM::XML::Terminology" do
       name_date_term = @test_full_terminology.retrieve_term(:name, :date)
       name_date_term.xpath.should == '//oxns:name/oxns:namePart[@type="date"]'
       name_date_term.xpath_relative.should == 'oxns:namePart[@type="date"]'
-      name_date_term.xpath_constrained.should == '//oxns:name/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"') 
-      # name_date_term.xpath_constrained.should == '//oxns:name[contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"') 
-      
+      name_date_term.xpath_constrained.should == '//oxns:name/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      # name_date_term.xpath_constrained.should == '//oxns:name[contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')
+
       person_date_term = @test_full_terminology.retrieve_term(:person, :date)
       person_date_term.xpath.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
       person_date_term.xpath_relative.should == 'oxns:namePart[@type="date"]'
@@ -115,7 +141,7 @@ describe "OM::XML::Terminology" do
       # person_date_term.xpath_constrained.should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')
     end
 
-    it "supports subelements that are specified using a :ref" do   
+    it "supports subelements that are specified using a :ref" do
       role_term = @test_full_terminology.retrieve_term(:name, :role)
       role_term.xpath.should == '//oxns:name/oxns:role'
       role_term.xpath_relative.should == 'oxns:role'
@@ -140,10 +166,10 @@ describe "OM::XML::Terminology" do
       volume_term.xpath_constrained.should == '//oxns:relatedItem[@type="host"]/oxns:part/oxns:detail[@type="volume" and contains(oxns:number, "#{constraint_value}")]'.gsub('"', '\"')
     end
 
-    it "should not overwrite default property info when adding a variant property" do  
+    it "should not overwrite default property info when adding a variant property" do
       name_term = @test_full_terminology.retrieve_term(:name)
       person_term = @test_full_terminology.retrieve_term(:person)
-          
+
       name_term.should_not equal(person_term)
       name_term.xpath.should_not equal(person_term.xpath)
       name_term.children.should_not equal(person_term.children)
@@ -151,7 +177,7 @@ describe "OM::XML::Terminology" do
     end
 
   end
-  
+
   describe '#from_xml' do
     it "should let you load mappings from an xml file" do
       pending
@@ -160,14 +186,14 @@ describe "OM::XML::Terminology" do
       vocab.mappers.should == {}
     end
   end
-  
+
   describe '#to_xml' do
     it "should let you serialize mappings to an xml document" do
       pending
       TerminologyTest.to_xml.should == ""
     end
   end
-  
+
   describe ".has_term?" do
     it "should return true if the specified term does exist in the terminology" do
       @test_full_terminology.has_term?(:journal,:issue,:end_page).should be_true
@@ -180,7 +206,7 @@ describe "OM::XML::Terminology" do
       @test_full_terminology.has_term?(:name, :date, :nonexistentTerm, :anotherTermName).should be_false
     end
   end
-  
+
   describe ".retrieve_term" do
     it "should return the mapper identified by the given pointer" do
       term = @test_terminology.retrieve_term(:name, :namePart)
@@ -192,29 +218,29 @@ describe "OM::XML::Terminology" do
       @test_full_terminology.retrieve_term(:name, :date).path.should == 'namePart'
       @test_full_terminology.retrieve_term(:name, :date).attributes.should == {:type=>"date"}
       @test_full_terminology.retrieve_term(:name, :affiliation).path.should == 'affiliation'
-      @test_full_terminology.retrieve_term(:name, :date).xpath.should == '//oxns:name/oxns:namePart[@type="date"]'          
+      @test_full_terminology.retrieve_term(:name, :date).xpath.should == '//oxns:name/oxns:namePart[@type="date"]'
     end
     it "should support looking up variant Terms" do
-      @test_full_terminology.retrieve_term(:person).path.should == 'name'        
-      @test_full_terminology.retrieve_term(:person).attributes.should == {:type=>"personal"}        
+      @test_full_terminology.retrieve_term(:person).path.should == 'name'
+      @test_full_terminology.retrieve_term(:person).attributes.should == {:type=>"personal"}
       @test_full_terminology.retrieve_term(:person, :affiliation).path.should == 'affiliation'
-      @test_full_terminology.retrieve_term(:person, :date).xpath.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'          
+      @test_full_terminology.retrieve_term(:person, :date).xpath.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
     end
     it "should support including root terms in pointer" do
       @test_full_terminology.retrieve_term(:mods).should be_instance_of OM::XML::Term
       @test_full_terminology.retrieve_term(:mods, :name, :date).should be_instance_of OM::XML::Term
       @test_full_terminology.retrieve_term(:mods, :name, :date).path.should == 'namePart'
       @test_full_terminology.retrieve_term(:mods, :name, :date).attributes.should == {:type=>"date"}
-      @test_full_terminology.retrieve_term(:mods, :name, :date).xpath.should == '//oxns:mods/oxns:name/oxns:namePart[@type="date"]'          
+      @test_full_terminology.retrieve_term(:mods, :name, :date).xpath.should == '//oxns:mods/oxns:name/oxns:namePart[@type="date"]'
     end
-    
+
     it "should raise an informative error if the desired Term doesn't exist" do
-      lambda { @test_full_terminology.retrieve_term(:name, :date, :nonexistentTerm, :anotherTermName) }.should raise_error(OM::XML::Terminology::BadPointerError, "You attempted to retrieve a Term using this pointer: [:name, :date, :nonexistentTerm, :anotherTermName] but no Term exists at that location. Everything is fine until \":nonexistentTerm\", which doesn't exist.") 
+      lambda { @test_full_terminology.retrieve_term(:name, :date, :nonexistentTerm, :anotherTermName) }.should raise_error(OM::XML::Terminology::BadPointerError, "You attempted to retrieve a Term using this pointer: [:name, :date, :nonexistentTerm, :anotherTermName] but no Term exists at that location. Everything is fine until \":nonexistentTerm\", which doesn't exist.")
     end
   end
-  
+
   describe ".term_xpath" do
-    it "should insert calls to xpath array lookup into parent xpaths if parents argument is provided" do    
+    it "should insert calls to xpath array lookup into parent xpaths if parents argument is provided" do
       pending
       # conference_mapper = TerminologyTest.retrieve_mapper(:conference)
       # role_mapper =  TerminologyTest.retrieve_mapper(:conference, :role)
@@ -223,10 +249,10 @@ describe "OM::XML::Terminology" do
       # OM::XML::TermXpathGenerator.expects(:generate_absolute_xpath).with({conference_mapper=>0}, {role_mapper=>1}, text_mapper)
     end
   end
-  
+
   describe ".xpath_for" do
 
-    it "should retrieve the generated xpath query to match your desires" do    
+    it "should retrieve the generated xpath query to match your desires" do
       @test_full_terminology.xpath_for(:person).should == '//oxns:name[@type="personal"]'
 
       @test_full_terminology.xpath_for(:person, "Beethoven, Ludwig van").should == '//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]'
@@ -234,21 +260,21 @@ describe "OM::XML::Terminology" do
       @test_full_terminology.xpath_for(:person, :date).should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
 
       @test_full_terminology.xpath_for(:person, :date, "2010").should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]'
-      
+
       @test_full_terminology.xpath_for(:person, :person_id).should == '//oxns:name[@type="personal"]/oxns:namePart[not(@type)]'
-      
+
     end
-    
+
     it "should support including root terms in term pointer" do
       @test_full_terminology.xpath_for(:mods, :person).should == '//oxns:mods/oxns:name[@type="personal"]'
       @test_full_terminology.xpath_for(:mods, :person, "Beethoven, Ludwig van").should == '//oxns:mods/oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]'
     end
-    
+
     it "should support queries with complex constraints" do
       pending
       @test_full_terminology.xpath_for(:person, {:date=>"2010"}).should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]'
     end
-    
+
     it "should support queries with multiple complex constraints" do
       pending
       @test_full_terminology.xpath_for(:person, {:role=>"donor", :last_name=>"Rockefeller"}).should == '//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "donor") and contains(oxns:namePart[@type="family"], "Rockefeller")]'
@@ -257,18 +283,18 @@ describe "OM::XML::Terminology" do
     it "should parrot any strings back to you (in case you already have an xpath query)" do
       @test_full_terminology.xpath_for('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]').should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
     end
-    
+
     it "should traverse named term proxies transparently" do
       proxied_xpath = @test_full_terminology.xpath_for(:journal, :issue, :pages, :start)
       @test_full_terminology.xpath_for( :journal, :issue, :start_page ).should == proxied_xpath
     end
-    
+
   end
-  
+
   describe ".xpath_with_indexes" do
     it "should return the xpath given in the call to #accessor" do
       @test_full_terminology.xpath_with_indexes( :title_info ).should == '//oxns:titleInfo'
-    end   
+    end
     it "should support xpath queries as argument" do
       @test_full_terminology.xpath_with_indexes('//oxns:name[@type="personal"][1]/oxns:namePart').should == '//oxns:name[@type="personal"][1]/oxns:namePart'
     end
@@ -286,32 +312,32 @@ describe "OM::XML::Terminology" do
       @test_full_terminology.xpath_with_indexes( :journal, :issue, :start_page ).should == proxied_xpath
     end
   end
-  
+
   describe "#xml_builder_template" do
-    
+
     it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
       @test_full_terminology.xml_builder_template(:person,:date).should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
       @test_full_terminology.xml_builder_template(:name,:affiliation).should == 'xml.affiliation( \'#{builder_new_value}\' )'
     end
     it "should accept extra options" do
-      marcrelator_role_xml_builder_template = 'xml.roleTerm( \'#{builder_new_value}\', \'type\'=>\'code\', \'authority\'=>\'marcrelator\' )'  
+      marcrelator_role_xml_builder_template = 'xml.roleTerm( \'#{builder_new_value}\', \'type\'=>\'code\', \'authority\'=>\'marcrelator\' )'
       @test_full_terminology.xml_builder_template(:role, :code, {:attributes=>{"authority"=>"marcrelator"}} ).should == marcrelator_role_xml_builder_template
-      @test_full_terminology.xml_builder_template(:person, :role, :code, {:attributes=>{"authority"=>"marcrelator"}} ).should == marcrelator_role_xml_builder_template      
+      @test_full_terminology.xml_builder_template(:person, :role, :code, {:attributes=>{"authority"=>"marcrelator"}} ).should == marcrelator_role_xml_builder_template
     end
-    
-    it "should work with deeply nested properties" do      
+
+    it "should work with deeply nested properties" do
       @test_full_terminology.xml_builder_template(:issue, :volume).should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
       @test_full_terminology.xml_builder_template(:journal, :issue, :level).should == "xml.detail( \'type\'=>'number' ) { xml.number( '\#{builder_new_value}' ) }"
       @test_full_terminology.xml_builder_template(:journal, :issue, :volume).should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
       @test_full_terminology.xml_builder_template(:journal, :issue, :pages, :start).should == "xml.start( '\#{builder_new_value}' )"
     end
-    
+
   end
 
   describe "#term_generic_name" do
     it "should generate a generic accessor name based on an array of pointers" do
       OM::XML::Terminology.term_generic_name( {:conference=>0}, {:role=>1}, :text ).should == "conference_role_text"
-      OM::XML::Terminology.term_generic_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_role_text"      
+      OM::XML::Terminology.term_generic_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_role_text"
     end
   end
 
@@ -321,18 +347,18 @@ describe "OM::XML::Terminology" do
       OM::XML::Terminology.term_hierarchical_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_0_role_1_text"
     end
   end
-  
+
   describe ".term_builders" do
     it "should return a hash terms that have been added to the root of the terminology, indexed by term name" do
       @test_terminology.terms[:name].should == @test_name
-    end 
+    end
   end
-  
+
   describe ".root_terms" do
     it "should return the terms that have been marked root" do
       @test_full_terminology.root_terms.length.should == 1
       @test_full_terminology.root_terms.first.should == @test_full_terminology.terms[:mods]
     end
   end
-  
+
 end