om 1.0.2 → 1.1.0

data/lib/om/xml/property_value_operators.rb

@@ -1,160 +0,0 @@
-require "open-uri"
-require "logger"
-
-class OM::XML::ParentNodeNotFoundError < RuntimeError; end
-module OM::XML::PropertyValueOperators
-  
-  def property_values(*lookup_args)
-    result = []
-    retrieve(*lookup_args).each {|node| result << node.text }
-    return result
-  end
-  
-  # 
-  # example properties values hash: {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] }
-  def update_properties(params={})
-    # remove any fields from params that this datastream doesn't recognize    
-    params.delete_if do |field_key,new_values| 
-      if field_key.kind_of?(String)
-        true
-      else
-        self.class.accessor_xpath(*OM.destringify(field_key) ).nil?
-      end
-    end
-    
-    result = params.dup
-    
-    params.each_pair do |property_pointer,new_values|
-      pointer = OM.destringify(property_pointer)
-      template = OM.pointers_to_flat_array(pointer,false)
-      hn = self.class.accessor_hierarchical_name(*pointer)
-      
-      case new_values
-      when Hash
-      when Array
-        nv = new_values.dup
-        new_values = {}
-        nv.each {|v| new_values[nv.index(v).to_s] = v}
-      else
-        new_values = {"0"=>new_values}
-      end
-      
-      result.delete(property_pointer)
-      result[hn] = new_values.dup
-      
-      current_values = property_values(*pointer)
-      new_values.delete_if do |y,z| 
-        if current_values[y.to_i]==z and y.to_i > -1
-          true
-        else
-          false
-        end
-      end 
-      xpath = self.class.accessor_xpath(*pointer)
-      parent_pointer = pointer.dup
-      parent_pointer.pop
-      parent_xpath = self.class.accessor_xpath(*parent_pointer)
-      new_values.each do |y,z|         
-        if retrieve(*pointer)[y.to_i].nil? || y.to_i == -1
-          result[hn].delete(y)
-          property_values_append(:parent_select=>parent_xpath,:child_index=>0,:template=>template,:values=>z)
-          new_array_index = retrieve(*pointer).length - 1
-          result[hn][new_array_index.to_s] = z
-        else
-          property_value_update(xpath, y.to_i, z)
-        end
-      end
-      # current_values.delete_if {|x| x == :delete || x == "" || x == nil}
-      # instance_eval("#{field_accessor_method}=(current_values)") #write it back to the ds
-      # result[field_name].delete("-1")
-    end
-    return result
-  end
-  
-  def property_values_append(opts={})
-    parent_select = Array( opts[:parent_select] )
-    child_index = opts[:child_index]
-    template = opts[:template]
-    new_values = Array( opts[:values] )
-  
-    # If template is a string, use it as the template, otherwise use it as arguments to builder_template
-    unless template.instance_of?(String)
-      template_args = Array(template)
-      if template_args.last.kind_of?(Hash)
-        template_opts = template_args.delete_at(template_args.length - 1)
-      else
-        template_opts = {}
-      end
-      template = self.class.builder_template( template_args, template_opts )
-    end    
-    
-    parent_nodeset = lookup(parent_select[0], parent_select[1])
-    parent_node = node_from_set(parent_nodeset, child_index)
-    
-    if parent_node.nil?
-      raise OM::XML::ParentNodeNotFoundError, "Failed to find a parent node to insert values into based on :parent_select #{parent_select.inspect} with :child_index #{child_index.inspect}"
-    end
-    
-    builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
-      new_values.each do |builder_new_value|
-        builder_arg = eval('"'+ template + '"') # this inserts builder_new_value into the builder template
-        eval(builder_arg)
-      end
-    end
-        
-    # Nokogiri::XML::Node.new(builder.to_xml, foo)
-    
-    return parent_node
-    
-  end
-  
-  def property_value_update(node_select,child_index,new_value,opts={})
-    # template = opts.fetch(:template,nil)
-    node = lookup(node_select, nil)[child_index]
-    node.content = new_value
-  end
-  
-  # def property_value_set(property_ref, query_opts, node_index, new_value)
-  # end
-  
-  def property_value_delete(opts={})
-    parent_select = Array( opts[:parent_select] )
-    parent_index = opts[:parent_index]
-    child_index = opts[:child_index]
-    xpath_select = opts[:select]
-    
-    if !xpath_select.nil?
-      node = lookup(xpath_select, nil).first
-    else
-      parent_nodeset = lookup(parent_select, parent_select)
-      # parent_nodeset = lookup(parent_select[0])
-      
-      if parent_index.nil?
-        node = node_from_set(parent_nodeset, child_index)
-      else
-        parent = node_from_set(parent_nodeset, parent_index)
-        # this next line is a hack around the fact that element_children() sometimes doesn't work.
-        node = node_from_set(parent.xpath("*"), child_index)
-      end
-    end
-    
-    node.remove
-  end
-   
-  
-  # Allows you to provide an array index _or_ a symbol representing the function to call on the nodeset in order to retrieve the node.
-  def node_from_set(nodeset, index)
-    if index.kind_of?(Integer)
-      node = nodeset[index]
-    elsif index.kind_of?(Symbol) && nodeset.respond_to?(index) 
-      node = nodeset.send(index)
-    else
-      raise "Could not retrieve node using index #{index}."
-    end
-    
-    return node
-  end
-  
-  private :node_from_set
-  
-end

data/spec/unit/accessors_spec.rb

@@ -1,216 +0,0 @@
-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)
-    @sample.stubs(:ox_namespaces).returns("oxns"=>"http://www.loc.gov/mods/v3")
-  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"][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
-    
-    it "should support xpath queries as the pointer" do
-      @sample.retrieve('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
-    end
-    
-    it "should return nil if the xpath fails to generate" do
-      @sample.retrieve( {:foo=>20}, :bar ).should == nil
-    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=>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 array lookup where necessary" do
-      AccessorTest.accessor_xpath( {:conference=>0}, {:role=>1}, :text ).should == '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
-    end
-    it "should support xpath queries as argument" do
-      AccessorTest.accessor_xpath('//oxns:name[@type="personal"][1]/oxns:namePart').should == '//oxns:name[@type="personal"][1]/oxns:namePart'
-    end
-    it "should return nil if no accessor_info is available" do
-      AccessorTest.accessor_xpath( :sample_undeclared_accessor ).should == nil
-    end
-    it "should be idempotent" do
-      AccessorTest.accessor_xpath( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
-      AccessorTest.accessor_xpath( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
-      AccessorTest.accessor_xpath( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
-    end
-  end
-  
-  describe "#accessor_constrained_xpath" do
-    it 'should append contains("#{constraint_value}") to query' do
-      # @sample.class.accessor_constrained_xpath_template([:journal, :issn]).should == '//oxns:relatedItem[@type="host"]/oxns:identifier[@type="issn" and contains("#{constraint_value}")]'
-      @sample.class.accessor_constrained_xpath([:journal, :issn], "123-456-ABC").should == '//oxns:relatedItem[@type="host"]/oxns:identifier[@type="issn" and contains(., "123-456-ABC")]'
-      @sample.class.accessor_constrained_xpath([:journal, :title], "My Journal Title").should == '//oxns:relatedItem[@type="host"]/oxns:titleInfo/oxns:title[contains(., "My Journal Title")]'
-    end
-  end
-  
-  describe "#accessor_generic_name" do
-    it "should generate a generic accessor name based on an array of pointers" do
-      AccessorTest.accessor_generic_name( {:conference=>0}, {:role=>1}, :text ).should == "conference_role_text"
-      AccessorTest.accessor_generic_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_role_text"      
-    end
-  end
-  
-  describe "#accessor_hierarchical_name" do
-    it "should generate a specific accessor name based on an array of pointers and indexes" do
-      AccessorTest.accessor_hierarchical_name( {:conference=>0}, {:role=>1}, :text ).should == "conference_0_role_1_text"
-      AccessorTest.accessor_hierarchical_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_0_role_1_text"
-    end
-  end
-  
-  describe '#generate_accessors_from_properties' do
-    before(:each) do
-      class AccessorTest2
-        include OM::XML::Accessors
-      end
-    end
-    
-    it "should generate accessors from the properties hash" do
-      sample_properties_hash = {:abstract=>{:xpath_relative=>"oxns:abstract", :path=>"abstract", :xpath_constrained=>"//oxns:abstract[contains(\\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:abstract", :ref=>:abstract, :convenience_methods=>{}}, :topic_tag=>{:xpath_relative=>"oxns:subject", :path=>"subject", :xpath_constrained=>"//oxns:subject[contains(oxns:topic, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:subject", :ref=>:topic_tag, :default_content_path=>"topic", :convenience_methods=>{}}, :title_info=>{:xpath_relative=>"oxns:titleInfo", :path=>"titleInfo", :xpath_constrained=>"//oxns:titleInfo[contains(\\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:titleInfo", :ref=>:title_info, :convenience_methods=>{:main_title=>{:xpath_relative=>"oxns:title", :path=>"title", :xpath_constrained=>"//oxns:titleInfo[contains(oxns:title, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:titleInfo/oxns:title"}, :language=>{:xpath_relative=>"@lang", :path=>{:attribute=>"lang"}, :xpath_constrained=>"//oxns:titleInfo[contains(@lang, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:titleInfo/@lang"}}}, :person=>{:xpath_relative=>"oxns:name[@type=\"personal\"]", :path=>"name", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart, \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"personal"}, :xpath=>"//oxns:name[@type=\"personal\"]", :ref=>:person, :default_content_path=>"namePart", :subelements=>["namePart", "displayForm", "affiliation", :role, "description"], :convenience_methods=>{:first_name=>{:xpath_relative=>"oxns:namePart[@type=\"given\"]", :path=>"namePart", :attributes=>{:type=>"given"}, :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart[@type=\\\"given\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]"}, :affiliation=>{:xpath_relative=>"oxns:affiliation", :path=>"affiliation", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:affiliation, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:affiliation"}, :terms_of_address=>{:xpath_relative=>"oxns:namePart[@type=\"termsOfAddress\"]", :path=>"namePart", :attributes=>{:type=>"termsOfAddress"}, :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart[@type=\\\"termsOfAddress\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"termsOfAddress\"]"}, :namePart=>{:xpath_relative=>"oxns:namePart", :path=>"namePart", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:namePart"}, :displayForm=>{:xpath_relative=>"oxns:displayForm", :path=>"displayForm", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:displayForm, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:displayForm"}, :role=>{:xpath_relative=>"oxns:role", :path=>"role", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:role, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:role", :ref=>:role, :convenience_methods=>{:text=>{:xpath_relative=>"oxns:roleTerm[@type=\"text\"]", :path=>"roleTerm", :attributes=>{:type=>"text"}, :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"text\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:role/oxns:roleTerm[@type=\"text\"]"}, :code=>{:xpath_relative=>"oxns:roleTerm[@type=\"code\"]", :path=>"roleTerm", :attributes=>{:type=>"code"}, :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"code\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:role/oxns:roleTerm[@type=\"code\"]"}}, :parents=>[:name_]}, :date=>{:xpath_relative=>"oxns:namePart[@type=\"date\"]", :path=>"namePart", :attributes=>{:type=>"date"}, :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart[@type=\\\"date\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"date\"]"}, :family_name=>{:xpath_relative=>"oxns:namePart[@type=\"family\"]", :path=>"namePart", :attributes=>{:type=>"family"}, :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:namePart[@type=\\\"family\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"family\"]"}, :description=>{:xpath_relative=>"oxns:description", :path=>"description", :xpath_constrained=>"//oxns:name[@type=\\\"personal\\\" and contains(oxns:description, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name[@type=\"personal\"]/oxns:description"}}, :variant_of=>:name_}, :name_=>{:xpath_relative=>"oxns:name", :path=>"name", :xpath_constrained=>"//oxns:name[contains(oxns:namePart, \\\"\#{constraint_value}\\\")]", :attributes=>[:xlink, :lang, "xml:lang", :script, :transliteration, {:type=>["personal", "enumerated", "corporate"]}], :xpath=>"//oxns:name", :ref=>:name_, :default_content_path=>"namePart", :subelements=>["namePart", "displayForm", "affiliation", :role, "description"], :convenience_methods=>{:affiliation=>{:xpath_relative=>"oxns:affiliation", :path=>"affiliation", :xpath_constrained=>"//oxns:name[contains(oxns:affiliation, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name/oxns:affiliation"}, :first_name=>{:xpath_relative=>"oxns:namePart[@type=\"given\"]", :path=>"namePart", :xpath_constrained=>"//oxns:name[contains(oxns:namePart[@type=\\\"given\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"given"}, :xpath=>"//oxns:name/oxns:namePart[@type=\"given\"]"}, :terms_of_address=>{:xpath_relative=>"oxns:namePart[@type=\"termsOfAddress\"]", :path=>"namePart", :xpath_constrained=>"//oxns:name[contains(oxns:namePart[@type=\\\"termsOfAddress\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"termsOfAddress"}, :xpath=>"//oxns:name/oxns:namePart[@type=\"termsOfAddress\"]"}, :displayForm=>{:xpath_relative=>"oxns:displayForm", :path=>"displayForm", :xpath_constrained=>"//oxns:name[contains(oxns:displayForm, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name/oxns:displayForm"}, :namePart=>{:xpath_relative=>"oxns:namePart", :path=>"namePart", :xpath_constrained=>"//oxns:name[contains(oxns:namePart, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name/oxns:namePart"}, :role=>{:xpath_relative=>"oxns:role", :path=>"role", :xpath_constrained=>"//oxns:name[contains(oxns:role, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name/oxns:role", :ref=>:role, :convenience_methods=>{:text=>{:xpath_relative=>"oxns:roleTerm[@type=\"text\"]", :path=>"roleTerm", :attributes=>{:type=>"text"}, :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"text\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:role/oxns:roleTerm[@type=\"text\"]"}, :code=>{:xpath_relative=>"oxns:roleTerm[@type=\"code\"]", :path=>"roleTerm", :attributes=>{:type=>"code"}, :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"code\\\"], \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:role/oxns:roleTerm[@type=\"code\"]"}}, :parents=>[:name_]}, :description=>{:xpath_relative=>"oxns:description", :path=>"description", :xpath_constrained=>"//oxns:name[contains(oxns:description, \\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:name/oxns:description"}, :family_name=>{:xpath_relative=>"oxns:namePart[@type=\"family\"]", :path=>"namePart", :xpath_constrained=>"//oxns:name[contains(oxns:namePart[@type=\\\"family\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"family"}, :xpath=>"//oxns:name/oxns:namePart[@type=\"family\"]"}, :date=>{:xpath_relative=>"oxns:namePart[@type=\"date\"]", :path=>"namePart", :xpath_constrained=>"//oxns:name[contains(oxns:namePart[@type=\\\"date\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"date"}, :xpath=>"//oxns:name/oxns:namePart[@type=\"date\"]"}}}, :role=>{:xpath_relative=>"oxns:role", :path=>"role", :xpath_constrained=>"//oxns:role[contains(\\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:role", :ref=>:role, :convenience_methods=>{:text=>{:xpath_relative=>"oxns:roleTerm[@type=\"text\"]", :path=>"roleTerm", :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"text\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"text"}, :xpath=>"//oxns:role/oxns:roleTerm[@type=\"text\"]"}, :code=>{:xpath_relative=>"oxns:roleTerm[@type=\"code\"]", :path=>"roleTerm", :xpath_constrained=>"//oxns:role[contains(oxns:roleTerm[@type=\\\"code\\\"], \\\"\#{constraint_value}\\\")]", :attributes=>{:type=>"code"}, :xpath=>"//oxns:role/oxns:roleTerm[@type=\"code\"]"}}, :parents=>[:name_]}, :unresolved=>{}, :mods=>{:xpath_relative=>"oxns:mods", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd", :path=>"mods", :xpath_constrained=>"//oxns:mods[contains(\\\"\#{constraint_value}\\\")]", :attributes=>["id", "version"], :xpath=>"//oxns:mods", :ref=>:mods, :convenience_methods=>{}}}      
-      AccessorTest2.stubs(:properties).returns(sample_properties_hash)
-      AccessorTest2.accessors.should be_nil
-      AccessorTest2.generate_accessors_from_properties.should_not be_nil
-      [:mods, :name_, :person, [:person,:first_name],[:person, :role], [:person, :role, :text] ].each do |pointer|
-        puts pointer
-        ai = AccessorTest2.accessor_info(*pointer)
-        ai.should_not be_nil
-        ai[:relative_xpath].should_not be_nil
-      end
-      AccessorTest2.accessor_info(*[:title_info, :language])[:relative_xpath].should == "@lang"
-    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/generator_spec.rb

@@ -1,67 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require "om"
-
-describe "OM::XML::Generator" do
-  
-  before(:all) do
-    #ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
-    class GeneratorTest 
-      
-      include OM::XML::Container     
-      include OM::XML::Properties
-      include OM::XML::Generator      
-      
-      # 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
-        
-  end
-  
-  before(:each) do
-    @sample = GeneratorTest.from_xml( fixture( File.join("test_dummy_mods.xml") ) )
-  end
-  
-  after(:all) do
-    Object.send(:remove_const, :GeneratorTest)
-  end
-  
-  describe '#generate' do
-    it "should use the corresponding builder template(s) to generate the node" do
-      GeneratorTest.generate(:mods, "foo").root.to_xml.should == "<mods>foo</mods>"
-      # GeneratorTest.generate([:person,:role], "creator", {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}}).root.to_xml.should == "<role authority=\"marcrelator\" type=\"code\">\n  <roleTerm>creator</roleTerm>\n</role>"
-      generated_node = GeneratorTest.generate([:person,:role], "creator", {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}})
-      # generated_node.should have_node 'role[@authority="marcrelator"][@type="code"]' do
-      #   with_node "roleTerm", "creator"
-      # end
-      generated_node.xpath('./role[@authority="marcrelator"][@type="code"]').xpath("./roleTerm").text.should == "creator"
-
-    end
-    it "should return Nokogiri Documents" do
-      GeneratorTest.generate(:mods, "foo").class.should == Nokogiri::XML::Document
-    end
-  end
-  
-end

data/spec/unit/properties_spec.rb

@@ -1,315 +0,0 @@
-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 :title_info, :path=>"titleInfo", 
-                  :convenience_methods => {
-                    :main_title => {:path=>"title"},
-                    :language => {:path=>{:attribute=>"lang"}},                    
-                  }
-                
-      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"
-                  
-      property :journal, :path=>'relatedItem', :attributes=>{:type=>"host"},
-                  :subelements=>[:title_info, :origin_info, :issue],
-                  :convenience_methods => {
-                    :issn => {:path=>"identifier", :attributes=>{:type=>"issn"}},
-                  }   
-
-      property :issue, :path=>'part',
-                  :subelements=>[:start_page, :end_page, :volume],
-                  :convenience_methods => {
-                    # :volume => {:path=>"detail", :attributes=>{:type=>"volume"}},
-                    :level => {:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number"},
-                    # Hack to support provisional spot for start & end page (nesting was too deep for this version of OM)
-                    :citation_start_page => {:path=>"pages", :attributes=>{:type=>"start"}},
-                    :citation_end_page => {:path=>"pages", :attributes=>{:type=>"end"}},
-                    :foo => {:path=>"foo", :attributes=>{:type=>"ness"}},
-                    :publication_date => {:path=>"date"}
-                  }
-                  
-      property :volume, :path=>"detail", :attributes=>{:type=>"volume"}, :subelements=>"number"
-      
-      property :start_page, :path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "start"
-      property :end_page, :path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "end"    
-    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
-    it "should add a corresponding entry into the properties hash" do
-      FakeOxMods.property_info_for(FakeOxMods.root_property_ref).should == {:schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd", :xpath_relative=>"oxns:mods", :path=>"mods", :xpath_constrained=>"//oxns:mods[contains(\\\"\#{constraint_value}\\\")]", :xpath=>"//oxns:mods", :ref=>:mods, :convenience_methods=>{}, :attributes=>["id", "version"]}
-      FakeOxMods.builder_template(FakeOxMods.root_property_ref).should == "xml.mods( '\#{builder_new_value}' )"
-    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 "supports treating attributes as properties" do
-      FakeOxMods.properties[:title_info][:convenience_methods][:language][:xpath].should == '//oxns:titleInfo/@lang'
-      FakeOxMods.properties[:title_info][:convenience_methods][:language][:xpath_relative].should == '@lang'
-      FakeOxMods.properties[:title_info][:convenience_methods][:language][:xpath_constrained].should == '//oxns:titleInfo[contains(@lang, "#{constraint_value}")]'.gsub('"', '\"')
-    end
-    
-    it "should support deep nesting of properties" do
-      pending "requires property method to be recursive"
-      
-      FakeOxMods.properties[:journal][:convenience_methods][:issue][:convenience_methods][:volume].should == {:xpath_constrained=>"//oxns:part[contains(oxns:detail[@type=\\\"volume\\\"], \\\"\#{constraint_value}\\\")]", :path=>"detail", :attributes=>{:type=>"volume"}, :xpath=>"//oxns:part/oxns:detail[@type=\"volume\"]", :xpath_relative=>"oxns:detail[@type=\"volume\"]"}
-      prop_info = FakeOxMods.property_info_for([:journal, :issue, :volume])
-      prop_info[:xpath_constrained].should == "//oxns:part[contains(oxns:detail[@type=\\\"volume\\\"], \\\"\#{constraint_value}\\\")]"
-      prop_info[:xpath].should == "//oxns:part/oxns:detail[@type=\"volume\"]"
-      prop_info[:xpath_relative].should == "oxns:detail[@type=\"volume\"]"
-    end
-    
-    it "should support even deeper nesting of properties" do
-      pending "requires property method to be recursive"
-      
-      FakeOxMods.properties[:journal][:convenience_methods][:issue][:convenience_methods][:start_page].should == {:xpath_constrained=>"//oxns:part[contains(oxns:detail[@type=\\\"volume\\\"], \\\"\#{constraint_value}\\\")]", :path=>"detail", :attributes=>{:type=>"volume"}, :xpath=>"//oxns:part/oxns:detail[@type=\"volume\"]", :xpath_relative=>"oxns:detail[@type=\"volume\"]"}
-      FakeOxMods.property_info_for([:journal, :issue, :end_page]).should == ""      
-    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")
-      
-      # 
-      # This is the way we want to move towards... (currently implementing part of this in accessor_constrained_xpath)
-      # @fixturemods.ng_xml.expects(:xpath).with('//oxns:relatedItem/oxns:identifier[@type=\'issn\'] and contains("123-ABC-44567")]', @fixturemods.ox_namespaces)
-      # @fixturemods.lookup([:journal, :issn], "123-ABC-44567")
-      
-    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"]'
-      FakeOxMods.generate_xpath( opts3, :variations=>{:attributes=>{:type=>"date"}}, :constraints=>:default ).should == '//oxns:name/oxns:namePart[@type="date" and contains("#{constraint_value}")]'
-
-      FakeOxMods.generate_xpath( {:path=>["relatedItem", "identifier"]}, :variations=>{:attributes=>{:type=>"issn"}}, :constraints=>:default ).should == '//oxns:relatedItem/oxns:identifier[@type="issn" and contains("#{constraint_value}")]'
-
-    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
-    
-    it "should work with deeply nested properties" do      
-      FakeOxMods.builder_template([:issue, :volume]).should == "xml.detail( '\#{builder_new_value}', :type=>'volume' )"
-      FakeOxMods.builder_template([:volume, :number]).should == "xml.number( '\#{builder_new_value}' )"
-      FakeOxMods.builder_template([:journal, :issue, :level]).should == "xml.detail( :type=>'number' ) { xml.number( '\#{builder_new_value}' ) }"
-      FakeOxMods.builder_template([:journal, :issue, :volume]).should == "xml.detail( '\#{builder_new_value}', :type=>'volume' )"
-      FakeOxMods.builder_template([:journal, :issue, :volume, :number]).should == "xml.number( '\#{builder_new_value}' )"
-      FakeOxMods.builder_template([:journal, :issue, :start_page]).should == "xml.extent( :unit=>'pages' ) { xml.start( '\#{builder_new_value}' ) }"
-    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