om 0.1.0

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'om'
+require 'spec'
+require 'spec/autorun'
+require 'ruby-debug'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+def fixture(file)
+  File.new(File.join(File.dirname(__FILE__), 'fixtures', file))
+end

data/spec/unit/accessors_spec.rb

@@ -0,0 +1,156 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "nokogiri"
+require "om"
+
+describe "OM::XML::Accessors" do
+  
+  before(:all) do
+    class AccessorTest
+    
+      include OM::XML::Container      
+      include OM::XML::Accessors
+      #accessor :title, :relative_xpath=>[:titleInfo, :title]}}         
+    
+      accessor :title_info, :relative_xpath=>'oxns:titleInfo', :children=>[
+        {:main_title=>{:relative_xpath=>'oxns:title'}},         
+        {:language =>{:relative_xpath=>{:attribute=>"lang"} }}
+        ]  # this allows you to access the language attribute as if it was a regular child accessor
+      accessor :abstract
+      accessor :topic_tag, :relative_xpath=>'oxns:subject/oxns:topic'
+      accessor :person, :relative_xpath=>'oxns:name[@type="personal"]',  :children=>[
+        {:last_name=>{:relative_xpath=>'oxns:namePart[@type="family"]'}}, 
+        {:first_name=>{:relative_xpath=>'oxns:namePart[@type="given"]'}}, 
+        {:institution=>{:relative_xpath=>'oxns:affiliation'}}, 
+        {:role=>{:children=>[
+          {:text=>{:relative_xpath=>'oxns:roleTerm[@type="text"]'}},
+          {:code=>{:relative_xpath=>'oxns:roleTerm[@type="code"]'}}
+        ]}}
+      ]
+      accessor :organization, :relative_xpath=>'oxns:name[@type="institutional"]', :children=>[
+        {:role=>{:children=>[
+          {:text=>{:relative_xpath=>'oxns:roleTerm[@type="text"]'}},
+          {:code=>{:relative_xpath=>'oxns:roleTerm[@type="code"]'}}
+        ]}}
+      ]
+      accessor :conference, :relative_xpath=>'oxns:name[@type="conference"]', :children=>[
+        {:role=>{:children=>[
+          {:text=>{:relative_xpath=>'oxns:roleTerm[@type="text"]'}},
+          {:code=>{:relative_xpath=>'oxns:roleTerm[@type="code"]'}}
+        ]}}
+      ]
+      accessor :journal, :relative_xpath=>'oxns:relatedItem[@type="host"]', :children=>[
+        # allows for children that are hashes...
+        # this allows for more robust handling of nested values (in generating views and when generating solr field names)
+          {:title=>{:relative_xpath=>'oxns:titleInfo/oxns:title'}}, 
+          {:publisher=>{:relative_xpath=>'oxns:originInfo/oxns:publisher'}},
+          {:issn=>{:relative_xpath=>'oxns:identifier[@type="issn"]'}}, 
+          {:date_issued=>{:relative_xpath=>'oxns:originInfo/oxns:dateIssued'}},
+          {:issue => {:relative_xpath=>"oxns:part", :children=>[
+            {:volume=>{:relative_xpath=>'oxns:detail[@type="volume"]'}},
+            {:level=>{:relative_xpath=>'oxns:detail[@type="level"]'}},
+            {:start_page=>{:relative_xpath=>'oxns:extent[@unit="pages"]/oxns:start'}},
+            {:end_page=>{:relative_xpath=>'oxns:extent[@unit="pages"]/oxns:end'}},
+            {:publication_date=>{:relative_xpath=>'oxns:date'}}
+          ]}}
+      ]    
+    end
+    
+  end
+
+  before(:each) do
+    article_xml = fixture( File.join("mods_articles", "hydrangea_article1.xml") )
+    @sample = AccessorTest.from_xml(article_xml)
+  end
+  
+  describe '#accessor' do
+    it "should populate the .accessors hash" do
+      AccessorTest.accessors[:abstract][:relative_xpath].should == "oxns:abstract"
+      AccessorTest.accessors[:journal][:relative_xpath].should == 'oxns:relatedItem[@type="host"]'
+      AccessorTest.accessors[:journal][:children][:issue][:relative_xpath].should == "oxns:part"
+      AccessorTest.accessors[:journal][:children][:issue][:children][:end_page][:relative_xpath].should == 'oxns:extent[@unit="pages"]/oxns:end'
+
+      AccessorTest.accessors[:person][:children][:role][:children][:text][:relative_xpath].should == 'oxns:roleTerm[@type="text"]'
+    end
+  end
+  
+  describe ".retrieve" do
+    it "should use Nokogiri to retrieve a NodeSet corresponding to the combination of accessor keys and array/nodeset indexes" do
+      @sample.retrieve( :person ).length.should == 2
+      
+      @sample.retrieve( :person, 1 ).first.should == @sample.ng_xml.xpath('//oxns:name[@type="personal" and position()=2]', "oxns"=>"http://www.loc.gov/mods/v3").first
+      @sample.retrieve( :person, 1, :first_name ).class.should == Nokogiri::XML::NodeSet
+      @sample.retrieve( :person, 1, :first_name ).first.text.should == "Siddartha"
+    end
+    
+    it "should support accessors whose relative_xpath is a lookup array instead of an xpath string" do
+      # pending "this only impacts scenarios where we want to display & edit"
+      AccessorTest.accessors[:title_info][:children][:language][:relative_xpath].should == {:attribute=>"lang"}
+      # @sample.retrieve( :title, 1 ).first.text.should == "Artikkelin otsikko Hydrangea artiklan 1"
+      @sample.retrieve( :title_info, 1, :language ).first.text.should == "finnish"
+    end
+    
+  end
+  
+  describe ".retrieve_at" do
+    it "should return the first node in the resulting set (uses Nokogiri xpath_at)" do
+      pending "might be able to make this implicit in the last value of call to .retrieve"
+      @sample.retrieve_at(:person, 1, :first_name).text.should == "Siddartha"
+      @sample.retrieve_at(:person, 1, :first_name).should == @sample.retrieve( :person, 1, :first_name).first
+    end
+  end
+
+  describe "generated accessor methods" do
+    it "should mix accessor methods into nodesets so you can use regular array syntax to access stuff" do
+      pending "This is tempting, but somewhat difficult to implement and potentially slow at runtime.  Might never be worth it?"
+      @sample.persons.length.should == 2
+      @sample.persons[1].first_name.text.should == "Siddartha" 
+      @sample.persons.last.roles.length.should == 1
+      @sample.persons.last.roles[0].text.should == "teacher"
+    end
+  end
+  
+  describe "#accessor_info" do
+    it "should return the xpath given in the call to #accessor" do
+      AccessorTest.accessor_info( :abstract ).should == AccessorTest.accessors[:abstract]
+    end
+    it "should return the xpath given in the call to #accessor" do
+      AccessorTest.accessor_info( :abstract ).should == AccessorTest.accessors[:abstract]
+    end
+    it "should dig into the accessors hash as far as you want, ignoring index values" do
+      AccessorTest.accessor_info( :conference, 0, :role, 1, :text ).should == AccessorTest.accessors[:conference][:children][:role][:children][:text]
+      AccessorTest.accessor_info( :conference, :role, :text ).should  == AccessorTest.accessors[:conference][:children][:role][:children][:text]
+    end
+  end
+    
+  describe "#accessor_xpath" do
+    it "should return the xpath given in the call to #accessor" do
+      AccessorTest.accessor_xpath( :abstract ).should == '//oxns:abstract'
+    end   
+    # Note: Ruby array indexes begin from 0.  In xpath queries (which start from 1 instead of 0), this will be translated accordingly.
+    it "should prepend the xpath for any parent nodes, inserting calls to xpath:position() function where necessary" do
+      AccessorTest.accessor_xpath( :conference, 0, :role, 1, :text ).should == '//oxns:name[@type="conference" and position()=1]/oxns:role[position()=2]/oxns:roleTerm[@type="text"]'
+    end
+  end
+  # describe ".accessor_xpath (instance method)" do
+  #   it "should delegate to the class method" do
+  #     AccessorTest.expects(:accessor_xpath).with( [:conference, conference_index, :text_role] )
+  #     @sample.accessor_xpath( [:conference, conference_index, :role] )
+  #   end
+  # end
+  # 
+  # describe "generated catchall xpaths" do
+  #   it "should return an xpath query that will catch all nodes corresponding to the specified accessor" do
+  #     AccessorTest.journal_issue_end_page_xpath.should == 'oxns:relatedItem[@type="host"]/oxns:part/oxns:extent[@unit="pages"]/oxns:end'
+  #   end
+  #   it "should rely on #catchall_xpath" do
+  #     AccessorTest.expects(:catchall_xpath).with(:journal, :issue, :end_page)
+  #     AccessorTest.journal_issue_end_page_xpath
+  #   end
+  # end
+  # 
+  # describe ".catchall_xpath" do
+  #   it "should return an xpath query that will catch all nodes corresponding to the specified accessor" do
+  #     AccessorTest.catchall_xpath(:journal, :issue, :end_page).should == 'oxns:relatedItem[@type="host"]/oxns:part/oxns:extent[@unit="pages"]/oxns:end'
+  #   end
+  # end
+end

data/spec/unit/container_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "nokogiri"
+require "om"
+
+describe "OM::XML::Container" do
+  
+  before(:all) do
+    class ContainerTest
+      include OM::XML::Container
+    end
+  end
+  
+  before(:each) do
+    @container = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
+  end
+  
+  it "should automatically include the other modules" do
+    pending
+    ContainerTest.included_modules.should include(OM::XML::Accessor)
+    ContainerTest.included_modules.should include(OM::XML::Schema)
+  end
+  
+  it "should add .ng_xml accessor" do
+    @container.should respond_to(:ng_xml)
+    @container.should respond_to(:ng_xml=)    
+  end
+  
+  describe "new" do
+    it "should populate ng_xml with an instance of Nokogiri::XML::Document" do
+      @container.ng_xml.class.should == Nokogiri::XML::Document
+    end
+  end
+  
+  describe "#from_xml" do
+    it "should accept a String, parse it and store it in .ng_xml" do
+      Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
+      container1 = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
+      container1.ng_xml.should == "parsed xml"
+    end
+    it "should accept a File, parse it and store it in .ng_xml" do
+      file = fixture(File.join("mods_articles", "hydrangea_article1.xml"))
+      Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
+      container1 = ContainerTest.from_xml(file)
+      container1.ng_xml.should == "parsed xml"
+    end
+    it "should accept Nokogiri nodes as input and leave them as-is" do
+      parsed_xml = Nokogiri::XML::Document.parse("<foo><bar>1</bar></foo>")
+      container1 = ContainerTest.from_xml(parsed_xml)
+      container1.ng_xml.should == parsed_xml
+    end
+  end
+  
+  describe ".to_xml" do
+    it  "should call .ng_xml.to_xml" do
+      @container.ng_xml.expects(:to_xml).returns("ng xml")
+      @container.to_xml.should == "ng xml"
+    end
+  end
+  
+end

data/spec/unit/properties_spec.rb

@@ -0,0 +1,247 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::Properties" do
+  
+  before(:all) do
+    #ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
+    class FakeOxMods 
+
+      include OM::XML::Container            
+      include OM::XML::Properties      
+      
+      # Could add support for multiple root declarations.  
+      #  For now, assume that any modsCollections have already been broken up and fed in as individual mods documents
+      # root :mods_collection, :path=>"modsCollection", 
+      #           :attributes=>[],
+      #           :subelements => :mods
+                     
+      root_property :mods, "mods", "http://www.loc.gov/mods/v3", :attributes=>["id", "version"], :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"          
+                
+                
+      property :name_, :path=>"name", 
+                  :attributes=>[:xlink, :lang, "xml:lang", :script, :transliteration, {:type=>["personal", "enumerated", "corporate"]} ],
+                  :subelements=>["namePart", "displayForm", "affiliation", :role, "description"],
+                  :default_content_path => "namePart",
+                  :convenience_methods => {
+                    :date => {:path=>"namePart", :attributes=>{:type=>"date"}},
+                    :family_name => {:path=>"namePart", :attributes=>{:type=>"family"}},
+                    :given_name => {:path=>"namePart", :attributes=>{:type=>"given"}},
+                    :terms_of_address => {:path=>"namePart", :attributes=>{:type=>"termsOfAddress"}}
+                  }
+                  
+      property :person, :variant_of=>:name_, :attributes=>{:type=>"personal"}
+      
+      property :role, :path=>"role",
+                  :parents=>[:name_],
+                  :attributes=>[ { "type"=>["text", "code"] } , "authority"],
+                  :default_content_path => "roleTerm"
+                  
+                  
+    end
+    
+    class FakeOtherOx < Nokogiri::XML::Document
+      
+      include OM::XML::Properties
+      # extend OX::ClassMethods
+      
+      root_property :other, "other", "http://www.foo.com"        
+      
+    end
+        
+  end
+  
+  before(:each) do
+    @fixturemods = FakeOxMods.from_xml( fixture( File.join("CBF_MODS", "ARS0025_016.xml") ) )
+  end
+  
+  after(:all) do
+    Object.send(:remove_const, :FakeOxMods)
+  end
+  
+  describe "#new" do
+    it "should set up namespaces" do
+      @fixturemods.ox_namespaces.should == {"oxns"=>"http://www.loc.gov/mods/v3", "xmlns:ns2"=>"http://www.w3.org/1999/xlink", "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "xmlns:ns3"=>"http://www.loc.gov/mods/v3"}
+    end
+  end
+  
+  describe "#root_property" do
+    it "should initialize root_property class attributes without attributes bleeding over to other OX classes" do
+      FakeOxMods.root_property_ref.should == :mods
+      FakeOxMods.root_config.should == {:ref=>:mods, :path=>"mods", :namespace=>"http://www.loc.gov/mods/v3", :attributes=>["id", "version"], :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"}
+      FakeOxMods.ox_namespaces.should == {"oxns"=>"http://www.loc.gov/mods/v3"}
+      
+      FakeOtherOx.root_property_ref.should == :other
+      FakeOtherOx.root_config.should == {:namespace=>"http://www.foo.com", :path=>"other", :ref=>:other}
+    end
+  end
+  
+  describe "#property" do
+    
+    it "fails gracefully if you try to look up nodes for an undefined property" do
+      @fixturemods.lookup(:nobody_home).should == []
+    end
+  
+    it "constructs xpath queries for finding properties" do
+      FakeOxMods.properties[:name_][:xpath].should == '//oxns:name'   
+      FakeOxMods.properties[:name_][:xpath_relative].should == 'oxns:name'               
+                  
+      FakeOxMods.properties[:person][:xpath].should == '//oxns:name[@type="personal"]'
+      FakeOxMods.properties[:person][:xpath_relative].should == 'oxns:name[@type="personal"]'
+    end
+    
+    it "constructs templates for value-driven searches" do
+      FakeOxMods.properties[:name_][:xpath_constrained].should == '//oxns:name[contains(oxns:namePart, "#{constraint_value}")]'.gsub('"', '\"')
+      FakeOxMods.properties[:person][:xpath_constrained].should == '//oxns:name[@type="personal" and contains(oxns:namePart, "#{constraint_value}")]'.gsub('"', '\"')
+      
+      # Example of how you could use these templates:
+      constraint_value = "SAMPLE CONSTRAINT VALUE"
+      constrained_query = eval( '"' + FakeOxMods.properties[:person][:xpath_constrained] + '"' )
+      constrained_query.should == '//oxns:name[@type="personal" and contains(oxns:namePart, "SAMPLE CONSTRAINT VALUE")]'
+    end
+    
+    it "constructs xpath queries & templates for convenience methods" do
+      FakeOxMods.properties[:name_][:convenience_methods][:date][:xpath].should == '//oxns:name/oxns:namePart[@type="date"]'
+      FakeOxMods.properties[:name_][:convenience_methods][:date][:xpath_relative].should == 'oxns:namePart[@type="date"]'
+      FakeOxMods.properties[:name_][:convenience_methods][:date][:xpath_constrained].should == '//oxns:name[contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')      
+            
+      FakeOxMods.properties[:person][:convenience_methods][:date][:xpath].should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+      FakeOxMods.properties[:person][:convenience_methods][:date][:xpath_relative].should == 'oxns:namePart[@type="date"]'      
+      FakeOxMods.properties[:person][:convenience_methods][:date][:xpath_constrained].should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')
+          
+    end
+    
+    it "constructs xpath queries & templates for subelements too" do
+      FakeOxMods.properties[:person][:convenience_methods][:displayForm][:xpath].should == '//oxns:name[@type="personal"]/oxns:displayForm'
+      FakeOxMods.properties[:person][:convenience_methods][:displayForm][:xpath_relative].should == 'oxns:displayForm'      
+      FakeOxMods.properties[:person][:convenience_methods][:displayForm][:xpath_constrained].should == '//oxns:name[@type="personal" and contains(oxns:displayForm, "#{constraint_value}")]'.gsub('"', '\"')
+    end
+    
+    it "supports subelements that are specified as separate properties" do
+      FakeOxMods.properties[:name_][:convenience_methods][:role][:xpath].should == '//oxns:name/oxns:role'
+      FakeOxMods.properties[:name_][:convenience_methods][:role][:xpath_relative].should == 'oxns:role'
+      FakeOxMods.properties[:name_][:convenience_methods][:role][:xpath_constrained].should == '//oxns:name[contains(oxns:role/oxns:roleTerm, "#{constraint_value}")]'.gsub('"', '\"')
+    end
+    
+    it "should not overwrite default property info when adding a variant property" do
+      FakeOxMods.properties[:name_].should_not equal(FakeOxMods.properties[:person])
+      FakeOxMods.properties[:name_][:convenience_methods].should_not equal(FakeOxMods.properties[:person][:convenience_methods])
+
+      FakeOxMods.properties[:name_][:xpath].should_not == FakeOxMods.properties[:person][:xpath]
+      FakeOxMods.properties[:name_][:convenience_methods][:date][:xpath_constrained].should_not == FakeOxMods.properties[:person][:convenience_methods][:date][:xpath_constrained]
+    end
+  
+  end
+  
+  describe ".lookup"  do
+    
+    it "uses the generated xpath queries" do
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal"]', @fixturemods.ox_namespaces)
+      @fixturemods.lookup(:person)
+      
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal" and contains(oxns:namePart, "Beethoven, Ludwig van")]', @fixturemods.ox_namespaces)
+      @fixturemods.lookup(:person, "Beethoven, Ludwig van")
+      
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]', @fixturemods.ox_namespaces)
+      @fixturemods.lookup(:person, :date=>"2010")
+      
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "donor")]', @fixturemods.ox_namespaces)
+      @fixturemods.lookup(:person, :role=>"donor")
+      
+      # @fixturemods.expects(:xpath).with('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]', @fixturemods.ox_namespaces)
+      # @fixturemods.lookup([:person,:date])
+      
+      # @fixturemods.expects(:xpath).with('//oxns:name[contains(oxns:namePart[@type="date"], "2010")]', @fixturemods.ox_namespaces)
+      # @fixturemods.lookup([:person,:date], "2010")
+    end
+  
+  end
+  
+  describe ".xpath_query_for" do
+
+    it "retrieves the generated xpath query to match your desires" do    
+      @fixturemods.xpath_query_for(:person).should == '//oxns:name[@type="personal"]'
+          
+      @fixturemods.xpath_query_for(:person, "Beethoven, Ludwig van").should == '//oxns:name[@type="personal" and contains(oxns:namePart, "Beethoven, Ludwig van")]'
+          
+      @fixturemods.xpath_query_for(:person, :date=>"2010").should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]'
+          
+      @fixturemods.xpath_query_for(:person, :role=>"donor").should == '//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "donor")]'
+          
+      @fixturemods.xpath_query_for([:person,:date]).should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+          
+      @fixturemods.xpath_query_for([:person,:date], "2010").should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]'
+    end
+    
+    it "parrots any strings back to you (in case you already have an xpath query)" do
+      @fixturemods.xpath_query_for('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]').should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+    end
+    
+  end
+  
+  describe "#generate_xpath" do
+    it "should generate an xpath query from the options in the provided hash and should support generating xpaths with constraint values" do
+      opts1 = {:path=>"name", :default_content_path=>"namePart"}
+      opts2 = {:path=>"originInfo"}
+      opts3 = {:path=>["name", "namePart"]}
+      FakeOxMods.generate_xpath( opts1 ).should == '//oxns:name'
+      FakeOxMods.generate_xpath( opts1, :constraints=>:default ).should == '//oxns:name[contains(oxns:namePart, "#{constraint_value}")]'
+      FakeOxMods.generate_xpath( opts2, :constraints=>:default ).should == '//oxns:originInfo[contains("#{constraint_value}")]'
+
+      FakeOxMods.generate_xpath( opts1, :variations=>{:attributes=>{:type=>"personal"}} ).should == '//oxns:name[@type="personal"]'
+      FakeOxMods.generate_xpath( opts1, :variations=>{:attributes=>{:type=>"personal"}}, :constraints=>:default ).should == '//oxns:name[@type="personal" and contains(oxns:namePart, "#{constraint_value}")]'
+             
+      FakeOxMods.generate_xpath( opts1, :constraints=>{:path=>"namePart", :attributes=>{:type=>"date"}} ).should == '//oxns:name[contains(oxns:namePart[@type="date"], "#{constraint_value}")]'
+      FakeOxMods.generate_xpath( opts1, :constraints=>{:path=>"namePart", :attributes=>{:type=>"date"}}, :variations=>{:attributes=>{:type=>"personal"}} ).should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "#{constraint_value}")]'
+      FakeOxMods.generate_xpath(FakeOxMods.properties[:person], :variations=>{:attributes=>{:type=>"personal"}}, :constraints=>{:path=>"role", :default_content_path=>"roleTerm"}, :subelement_of=>":person").should == '//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "#{constraint_value}")]'
+      
+      FakeOxMods.generate_xpath(opts1,  :variations=>{:attributes=>{:type=>"personal"}, :subelement_path=>"displayForm" } ).should == '//oxns:name[@type="personal"]/oxns:displayForm'
+      FakeOxMods.generate_xpath(opts1,  :variations=>{:attributes=>{:type=>"personal"}}, :constraints=>{:path=>"displayForm"} ).should == '//oxns:name[@type="personal" and contains(oxns:displayForm, "#{constraint_value}")]'
+      FakeOxMods.generate_xpath(opts1,  :variations=>{:attributes=>{:type=>"personal"}, :subelement_path=>["role", "roleTerm"] } ).should == '//oxns:name[@type="personal"]/oxns:role/oxns:roleTerm'
+      
+      FakeOxMods.generate_xpath( opts3, :variations=>{:attributes=>{:type=>"date"}} ).should == '//oxns:name/oxns:namePart[@type="date"]'
+    end
+    
+    it "should support relative paths" do
+      relative_opts = {:path=>"namePart"}
+      FakeOxMods.generate_xpath( relative_opts, :variations=>{:attributes=>{:type=>"date"}}, :relative=>true).should == 'oxns:namePart[@type="date"]'
+    end
+    
+    it "should work with real properties hashes" do
+      FakeOxMods.generate_xpath(FakeOxMods.properties[:person], :variations=>FakeOxMods.properties[:person]).should == "//oxns:name[@type=\"personal\"]"
+      FakeOxMods.generate_xpath(FakeOxMods.properties[:person], :variations=>FakeOxMods.properties[:person], :constraints=>{:path=>"role", :default_content_path=>"roleTerm"}, :subelement_of=>":person").should == '//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "#{constraint_value}")]'
+      date_hash = FakeOxMods.properties[:person][:convenience_methods][:date]
+      FakeOxMods.generate_xpath( date_hash, :variations=>date_hash, :relative=>true ).should == 'oxns:namePart[@type="date"]'
+    end
+    
+    it "should support custom templates" do
+      opts = {:path=>"name", :default_content_path=>"namePart"}
+      FakeOxMods.generate_xpath( opts, :template=>'/#{prefix}:sampleNode/#{prefix}:#{path}[contains(#{default_content_path}, \":::constraint_value:::\")]' ).should == '/oxns:sampleNode/oxns:name[contains(namePart, "#{constraint_value}")]'      
+    end
+  end
+  
+  describe "#builder_template" do
+    
+    it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
+      FakeOxMods.builder_template([:person,:date]).should == 'xml.namePart( \'#{builder_new_value}\', :type=>\'date\' )'
+      FakeOxMods.builder_template([:name_,:affiliation]).should == 'xml.affiliation( \'#{builder_new_value}\' )'
+      
+      simple_role_builder_template = 'xml.role( :type=>\'text\' ) { xml.roleTerm( \'#{builder_new_value}\' ) }'  
+      FakeOxMods.builder_template([:role]).should == simple_role_builder_template
+      FakeOxMods.builder_template([:person,:role]).should == simple_role_builder_template
+      
+      marcrelator_role_builder_template = 'xml.role( :type=>\'code\', :authority=>\'marcrelator\' ) { xml.roleTerm( \'#{builder_new_value}\' ) }'  
+      FakeOxMods.builder_template([:role], {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}} ).should == marcrelator_role_builder_template
+      FakeOxMods.builder_template([:person,:role], {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}} ).should == marcrelator_role_builder_template
+    end
+    
+  end
+  
+  describe "#applicable_attributes" do
+    it "returns a Hash where all of the values are strings" do
+      FakeOxMods.send(:applicable_attributes, {:type=>"date"} ).should == {:type=>"date"} 
+      FakeOxMods.send(:applicable_attributes, ["authority", {:type=>["text","code"]}] ).should == {:type=>"text"} 
+    end
+  end
+   
+end