om 1.4.4 → 1.5.0

data/lib/om/xml/terminology.rb

@@ -1,5 +1,5 @@
 # When you're defining a Terminology, you will usually use a "Terminology Builder":OM/XML/Terminology/Builder.html to create it
-# Each line you put into a "Terminology Builder":OM/XML/Terminology/Builder.html is passed to the constructor for a "Term Builder":OM/XML/Term/Builder.html. 
+# Each line you put into a "Terminology Builder":OM/XML/Terminology/Builder.html is passed to the constructor for a "Term Builder":OM/XML/Term/Builder.html.
 # See the "OM::XML::Term::Builder":OM/XML/Term/Builder.html API docs for complete description of your options for defining each Term.
 #
 # The most important thing to define in a Terminology is the root term.  This is the place where you set namespaces and schemas for the Terminology
@@ -8,23 +8,24 @@
 #     t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
 #   end
 #   terminology = terminology_builder.build
+# If you do not set a namespace, the terminology will assume there is no namespace on the xml document.
 class OM::XML::Terminology
-  
+
   class BadPointerError < StandardError; end
   class CircularReferenceError < StandardError; end
-  
+
   # Terminology::Builder Class Definition
   #
-  # When coding against Builders, remember that they rely on MethodMissing, 
-  # so any time you call a method on the Builder that it doesn't explicitly recognize, 
+  # When coding against Builders, remember that they rely on MethodMissing,
+  # so any time you call a method on the Builder that it doesn't explicitly recognize,
   # the Builder will add your method & arguments to the it's settings and return itself.
   class Builder
-    
+
     attr_accessor :schema, :namespaces
     attr_reader :term_builders
     ###
     # Create a new Terminology Builder object.  +options+ are sent to the top level
-    # Document that is being built.  
+    # Document that is being built.
     # (not yet supported:) +root+ can be a point in an existing Terminology that you want to add Mappers into
     #
     # Building a document with a particular encoding for example:
@@ -37,10 +38,10 @@ class OM::XML::Terminology
       @namespaces = options.fetch(:namespaces,{})
       @term_builders = {}
       @cur_term_builder = nil
-      
+
       yield self if block_given?
     end
-    
+
     # Set the root of the Terminology, along with namespace & schema info
     def root opts, &block
       @schema = opts.fetch(:schema,nil)
@@ -55,36 +56,36 @@ class OM::XML::Terminology
       term_opts.delete(:schema)
       root_term_builder.settings.merge!(term_opts)
       @term_builders[root_term_builder.name] = root_term_builder
-      
+
       return root_term_builder
     end
-    
+
     # Returns an array of Terms that have been marked as "root" terms
     def root_term_builders
       @term_builders.values.select {|term_builder| term_builder.settings[:is_root_term] == true }
     end
-    
+
     def method_missing method, *args, &block # :nodoc:
       parent_builder = @cur_term_builder
       @cur_term_builder = OM::XML::Term::Builder.new(method.to_s.sub(/[_!]$/, ''), self)
-      
+
       # Attach to parent
       if parent_builder
         parent_builder.add_child @cur_term_builder
       else
         @term_builders [@cur_term_builder.name] = @cur_term_builder
       end
-      
+
       # Apply options
       opts = args.shift
       @cur_term_builder.settings.merge!(opts) if opts
-      
+
       # Parse children
       yield if block
-      
+
       @cur_term_builder = parent_builder
     end
-    
+
     # Returns the TermBuilder corresponding to the given _pointer_.
     def retrieve_term_builder(*args)
       args_cp = args.dup
@@ -100,35 +101,35 @@ class OM::XML::Terminology
       end
       return current_term
     end
-    
+
     def build
       terminology = OM::XML::Terminology.new(:schema=>@schema, :namespaces=>@namespaces)
-      root_term_builders.each do |root_term_builder| 
-        root_term_builder.children = self.term_builders.dup 
+      root_term_builders.each do |root_term_builder|
+        root_term_builder.children = self.term_builders.dup
         root_term_builder.children.delete(root_term_builder.name)
-      end 
+      end
       @term_builders.each_value do |root_builder|
         terminology.add_term root_builder.build(terminology)
       end
       terminology
     end
   end
-  
+
   # Terminology Class Definition
-  
+
   attr_accessor :terms, :schema, :namespaces
-  
+
   def initialize(options={})
     @schema = options.fetch(:schema,nil)
     @namespaces = options.fetch(:namespaces,{})
     @terms = {}
   end
-  
+
   # Add a term to the root of the terminology
   def add_term(term)
     @terms[term.name.to_sym] = term
   end
-  
+
   # Returns true if the current terminology has a term defined at the location indicated by +pointers+ array
   def has_term?(*pointers)
     begin
@@ -138,7 +139,7 @@ class OM::XML::Terminology
       return false
     end
   end
-  
+
   # Returns the Term corresponding to the given _pointer_.
   # Proxies are not expanded
   def retrieve_term(*args)
@@ -162,11 +163,11 @@ class OM::XML::Terminology
     if current_term.kind_of? OM::XML::NamedTermProxy
       args = (current_term.proxy_pointer + args).flatten
       current_term = context.children[args.shift]
-    end 
+    end
     args.empty? ? current_term : retrieve_node_subsequent(args, current_term)
   end
 
- 
+
   ##
   # This is very similar to retrieve_term, however it expands proxy paths out into their cannonical paths
   def retrieve_node(*args)
@@ -174,7 +175,7 @@ class OM::XML::Terminology
     if current_term.kind_of? OM::XML::NamedTermProxy
       args = (current_term.proxy_pointer + args).flatten
       current_term = terms[args.shift]
-    end 
+    end
     args.empty? ? current_term : retrieve_node_subsequent(args, current_term)
   end
 
@@ -187,7 +188,7 @@ class OM::XML::Terminology
       return pointers.first
     end
     query_constraints = nil
-    
+
     if pointers.length > 1 && !pointers.last.kind_of?(Symbol)
       query_constraints = pointers.pop
     end
@@ -199,12 +200,12 @@ class OM::XML::Terminology
         constraint_value = query_constraints
         xpath_template = term.xpath_constrained
         xpath_query = eval( '"' + xpath_template + '"' )
-      elsif query_constraints.kind_of?(Hash) && !query_constraints.empty?       
-        key_value_pair = query_constraints.first 
+      elsif query_constraints.kind_of?(Hash) && !query_constraints.empty?
+        key_value_pair = query_constraints.first
         constraint_value = key_value_pair.last
         xpath_template = term.children[key_value_pair.first].xpath_constrained
-        xpath_query = eval( '"' + xpath_template + '"' )          
-      else 
+        xpath_query = eval( '"' + xpath_template + '"' )
+      else
         xpath_query = term.xpath
       end
     else
@@ -212,36 +213,36 @@ class OM::XML::Terminology
     end
     xpath_query
   end
-  
+
   # Use the current terminology to generate an xpath with (optional) node indexes for each of the term pointers.
-  # Ex.  terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, :text ) 
+  # Ex.  terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, :text )
   #      will yield an xpath like this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
   def xpath_with_indexes(*pointers)
     OM::XML::TermXpathGenerator.generate_xpath_with_indexes(self, *pointers)
   end
-  
+
   # Retrieves a Term corresponding to +term_pointers+ and return the corresponding xml_builder_template for that term.
   # The resulting xml_builder_template can be passed as a block into Nokogiri::XML::Builder.new
   #
   # +term_pointers+ point to the Term you want to generate a builder template for
   # If the last term_pointer is a String or a Hash, it will be passed into the Term's xml_builder_template method as extra_opts
   # see also: Term.xml_builder_template
-  def xml_builder_template(*term_pointers)    
+  def xml_builder_template(*term_pointers)
     extra_opts = {}
-    
+
     if term_pointers.length > 1 && !term_pointers.last.kind_of?(Symbol)
       extra_opts = term_pointers.pop
     end
-    
+
     term = retrieve_term(*term_pointers)
     return term.xml_builder_template(extra_opts)
   end
-  
+
   # Returns an array of Terms that have been marked as "root" terms
   def root_terms
     terms.values.select {|term| term.is_root_term? }
   end
-  
+
   # Return an XML representation of the Terminology and its terms
   # @param [Hash] options, the term will be added to it. If :children=>false, skips rendering child Terms
   # @param [Nokogiri::XML::Document] (optional) document to insert the term xml into
@@ -263,24 +264,24 @@ class OM::XML::Terminology
             }
           end
         }
-        xml.terms 
+        xml.terms
       }
     end
     document = builder.doc
     terms.values.each {|term| term.to_xml(options,document.xpath("//terms").first)}
     return document
   end
-  
+
   def self.term_generic_name(*pointers)
     pointers_to_flat_array(pointers, false).join("_")
   end
-  
+
   def self.term_hierarchical_name(*pointers)
     pointers_to_flat_array(pointers, true).join("_")
   end
-  
+
   def self.pointers_to_flat_array(pointers, include_indices=true)
     OM.pointers_to_flat_array(pointers, include_indices)
   end
-  
+
 end

data/spec/fixtures/no_namespace.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<note>
+<to>Tove</to>
+<from>Jani</from>
+<heading>Reminder</heading>
+<body>Don't forget me this weekend!</body>
+</note>

data/spec/unit/term_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require "om"
 
 describe "OM::XML::Term" do
-  
+
   before(:each) do
     @test_name_part = OM::XML::Term.new(:namePart, {}).generate_xpath_queries!
     @test_volume = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
@@ -10,11 +10,8 @@ describe "OM::XML::Term" do
     @test_affiliation = OM::XML::Term.new(:affiliation)
     @test_role_code = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
   end
-  
+
   describe '#new' do
-    it "should set default values" do
-      @test_name_part.namespace_prefix.should == "oxns"
-    end
     it "should set path from mapper name if no path is provided" do
       @test_name_part.path.should == "namePart"
     end
@@ -25,14 +22,14 @@ describe "OM::XML::Term" do
       local_mapping.xpath_constrained.should be_nil
     end
   end
-  
+
   describe 'inner_xml' do
     it "should be a kind of Nokogiri::XML::Node" do
       pending
       @test_mapping.inner_xml.should be_kind_of(Nokogiri::XML::Node)
     end
   end
-  
+
   describe '#from_node' do
     it "should create a mapper from a nokogiri node" do
       pending "probably should do this in the Builder"
@@ -52,7 +49,7 @@ describe "OM::XML::Term" do
       mapper.path.should == "name"
       mapper.attributes.should == {:type=>"personal"}
       mapper.internal_xml.should == node
-            
+
       child = mapper.children[:first_name]
 
       child.name.should == :first_name
@@ -61,35 +58,35 @@ describe "OM::XML::Term" do
       child.internal_xml.should == node.xpath("./mapper").first
     end
   end
-  
+
   describe ".label" do
     it "should default to the mapper name with underscores converted to spaces"
   end
-  
+
   describe ".retrieve_term" do
     it "should crawl down into mapper children to find the desired term" do
       mock_role = mock("mapper", :children =>{:text=>"the target"})
-      mock_conference = mock("mapper", :children =>{:role=>mock_role})   
-      @test_name_part.expects(:children).returns({:conference=>mock_conference})   
+      mock_conference = mock("mapper", :children =>{:role=>mock_role})
+      @test_name_part.expects(:children).returns({:conference=>mock_conference})
       @test_name_part.retrieve_term(:conference, :role, :text).should == "the target"
     end
     it "should return an empty hash if no term can be found" do
       @test_name_part.retrieve_term(:journal, :issue, :end_page).should == nil
     end
   end
-  
+
   describe 'inner_xml' do
     it "should be a kind of Nokogiri::XML::Node" do
       pending
       @test_name_part.inner_xml.should be_kind_of(Nokogiri::XML::Node)
     end
   end
-  
+
   describe "getters/setters" do
     it "should set the corresponding .settings value and return the current value" do
       [:path, :index_as, :required, :data_type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |method_name|
         @test_name_part.send(method_name.to_s+"=", "#{method_name.to_s}foo").should == "#{method_name.to_s}foo"
-        @test_name_part.send(method_name).should == "#{method_name.to_s}foo"        
+        @test_name_part.send(method_name).should == "#{method_name.to_s}foo"
       end
     end
   end
@@ -136,21 +133,21 @@ describe "OM::XML::Term" do
       @test_name_part.ancestors.should include(@test_volume)
     end
   end
-  
+
   describe "generate_xpath_queries!" do
     it "should return the current object" do
       @test_name_part.generate_xpath_queries!.should == @test_name_part
     end
-    it "should regenerate the xpath values" do      
+    it "should regenerate the xpath values" do
       @test_volume.xpath_relative.should be_nil
       @test_volume.xpath.should be_nil
       @test_volume.xpath_constrained.should be_nil
-      
+
       @test_volume.generate_xpath_queries!.should == @test_volume
-      
-      @test_volume.xpath_relative.should == 'oxns:detail[@type="volume"]'
-      @test_volume.xpath.should == '//oxns:detail[@type="volume"]'
-      @test_volume.xpath_constrained.should == '//oxns:detail[@type="volume" and contains(oxns:number, "#{constraint_value}")]'.gsub('"', '\"') 
+
+      @test_volume.xpath_relative.should == 'detail[@type="volume"]'
+      @test_volume.xpath.should == '//detail[@type="volume"]'
+      @test_volume.xpath_constrained.should == '//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"')
     end
     it "should trigger update on any child objects" do
       mock_child = mock("child term")
@@ -159,44 +156,44 @@ describe "OM::XML::Term" do
       @test_name_part.generate_xpath_queries!
     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_date.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
       @test_affiliation.xml_builder_template.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_role_code.xml_builder_template(:attributes=>{"authority"=>"marcrelator"}).should == marcrelator_role_xml_builder_template
     end
-    
+
     it "should work for namespaced nodes" do
       @ical_date = OM::XML::Term.new(:ical_date, :path=>"ical:date")
       @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
       @ical_date = OM::XML::Term.new(:ical_date, :path=>"date", :namespace_prefix=>"ical")
       @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
     end
-    
-    it "should work for nodes with default_content_path" do      
+
+    it "should work for nodes with default_content_path" do
       @test_volume.xml_builder_template.should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
     end
-    
+
     it "should support terms that are attributes" do
       @type_attribute_term = OM::XML::Term.new(:type_attribute, :path=>{:attribute=>:type})
       @type_attribute_term.xml_builder_template.should == "xml.@type( '\#{builder_new_value}' )"
     end
-    
+
     it "should support terms with namespaced attributes" do
       @french_title = OM::XML::Term.new(:french_title, :path=>"title", :attributes=>{"xml:lang"=>"fre"})
       @french_title.xml_builder_template.should == "xml.title( '\#{builder_new_value}', 'xml:lang'=>'fre' )"
     end
-    
+
     it "should support terms that are namespaced attributes" do
       @xml_lang_attribute_term = OM::XML::Term.new(:xml_lang_attribute, :path=>{:attribute=>"xml:lang"})
       @xml_lang_attribute_term.xml_builder_template.should == "xml.@xml:lang( '\#{builder_new_value}' )"
     end
-    
+
   end
-  
+
 end