om 1.4.4 → 1.5.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    om (1.4.3)
+    om (1.5.0)
       mediashelf-loggable
       nokogiri (>= 1.4.2)
 

data/History.textile

@@ -1,3 +1,7 @@
+h3. 1.5.0
+
+  HYDRA-358 Added support for namespaceless terminologies
+
 h3. 1.4.4
 
   HYDRA-415 https://jira.duraspace.org/browse/HYDRA-415 Fixed insert of attribute nodes

data/lib/om/version.rb

@@ -1,3 +1,3 @@
 module Om
-  VERSION = "1.4.4"
+  VERSION = "1.5.0"
 end

data/lib/om/xml/document.rb

@@ -1,27 +1,27 @@
 module OM::XML::Document
-    
-  
-  # Class Methods -- These methods will be available on classes that include this Module 
-  
+
+
+  # Class Methods -- These methods will be available on classes that include this Module
+
   module ClassMethods
-    
+
     attr_accessor :terminology, :template_registry
-  
+
     # Sets the OM::XML::Terminology for the Document
     # Expects +&block+ that will be passed into OM::XML::Terminology::Builder.new
     def set_terminology &block
       @terminology = OM::XML::Terminology::Builder.new( &block ).build
     end
-    
+
     # Define a new node template with the OM::XML::TemplateRegistry.
     # * +name+ is a Symbol indicating the name of the new template.
-    # * The +block+ does the work of creating the new node, and will receive 
+    # * The +block+ does the work of creating the new node, and will receive
     #   a Nokogiri::XML::Builder and any other args passed to one of the node instantiation methods.
     def define_template name, &block
       @template_registry ||= OM::XML::TemplateRegistry.new
       @template_registry.define name, &block
     end
-    
+
     # Returns any namespaces defined by the Class' Terminology
     def ox_namespaces
       if @terminology.nil?
@@ -30,16 +30,16 @@ module OM::XML::Document
         return @terminology.namespaces
       end
     end
-    
+
   end
-  
+
   # Instance Methods -- These methods will be available on instances of classes that include this module
-  
+
   attr_accessor :ox_namespaces
-  
+
   def self.included(klass)
     klass.extend(ClassMethods)
-  
+
     klass.send(:include, OM::XML::Container)
     klass.send(:include, OM::XML::TermValueOperators)
     klass.send(:include, OM::XML::Validation)
@@ -54,7 +54,7 @@ module OM::XML::Document
         node.val=args
       else
         super
-      end 
+      end
     else
       term = self.class.terminology.retrieve_term(name)
       if (term)
@@ -63,25 +63,29 @@ module OM::XML::Document
         super
       end
     end
-    
+
 
   end
 
 
   def find_by_xpath(xpath)
-    ng_xml.xpath(xpath, ox_namespaces) 
+    if ox_namespaces.values.compact.empty?
+      ng_xml.xpath(xpath)
+    else
+      ng_xml.xpath(xpath, ox_namespaces)
+    end
   end
-  
-  
+
+
   # Applies the property's corresponding xpath query, returning the result Nokogiri::XML::NodeSet
   def find_by_terms_and_value(*term_pointer)
-    xpath = self.class.terminology.xpath_for(*term_pointer)    
+    xpath = self.class.terminology.xpath_for(*term_pointer)
     find_by_xpath(xpath) unless xpath.nil?
   end
-  
+
 
   # +term_pointer+ Variable length array of values in format [:accessor_name, :accessor_name ...] or [{:accessor_name=>index}, :accessor_name ...]
-  # @example: 
+  # @example:
   #   find_by_terms( {:person => 1}, :first_name )
   # @example
   #   find_by_terms( [:person, 1, :first_name] )
@@ -89,10 +93,10 @@ module OM::XML::Document
   # @example Pass in your own xpath query if you don't want to bother with Term pointers but do want OM to handle namespaces for you.
   #   find_by_terms('//oxns:name[@type="personal"][contains(oxns:role, "donor")]')
   def find_by_terms(*term_pointer)
-    xpath = self.class.terminology.xpath_with_indexes(*term_pointer)   
+    xpath = self.class.terminology.xpath_with_indexes(*term_pointer)
     find_by_xpath(xpath) unless xpath.nil?
   end
-  
+
   # Test whether the document has a node corresponding to the given term_pointer
   # @param [Array] term_pointer to test
   def node_exists?(*term_pointer)
@@ -103,11 +107,11 @@ module OM::XML::Document
   def template_registry
     self.class.template_registry
   end
-  
+
   def template(node_type, *args)
     template_registry.instantiate(node_type, *args)
   end
-  
+
   # Instantiate a +node_type+ template and add it as a child of +target_node+, where +target_node+ is one of:
   # * a Nokogiri::XML::Node
   # * a single-element Nokogiri::XML::NodeSet
@@ -118,8 +122,8 @@ module OM::XML::Document
   def add_child_node(target_node, node_type, *args, &block)
     manipulate_node(:add_child, target_node, node_type, *args, &block)
   end
-  
-  # Instantiate a +node_type+ template and insert it as the following sibling of +target_node+. 
+
+  # Instantiate a +node_type+ template and insert it as the following sibling of +target_node+.
   # Returns the new Nokogiri::XML::Node.
   def add_next_sibling_node(target_node, node_type, *args, &block)
     manipulate_node(:add_next_sibling, target_node, node_type, *args, &block)
@@ -154,7 +158,7 @@ module OM::XML::Document
   def swap_node(target_node, node_type, *args, &block)
     manipulate_node(:swap, target_node, node_type, *args, &block)
   end
-  
+
   # Returns a hash combining the current documents namespaces (provided by nokogiri) and any namespaces that have been set up by your Terminology.
   # Most importantly, this matches the 'oxns' namespace to the namespace you provided in your Terminology's root term config
   def ox_namespaces

data/lib/om/xml/term.rb

@@ -1,37 +1,37 @@
-# Special options: 
-# data_type, index_as, attributes, 
+# Special options:
+# data_type, index_as, attributes,
 # is_root_term, required
 #
 class OM::XML::Term
-  
+
   # Term::Builder Class Definition
   #
   # @example
-  #   tb2 = OM::XML::Term::Builder.new("my_term_name").path("fooPath").attributes({:lang=>"foo"}).index_as([:searchable, :facetable]).required(true).data_type(:text) 
+  #   tb2 = OM::XML::Term::Builder.new("my_term_name").path("fooPath").attributes({:lang=>"foo"}).index_as([:searchable, :facetable]).required(true).data_type(:text)
+  #
   #
-  #   
   #
-  # 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 :name, :settings, :children, :terminology_builder
-    
+
     def initialize(name, terminology_builder=nil)
       @name = name.to_sym
       @terminology_builder = terminology_builder
       @settings = {:required=>false, :data_type=>:string}
       @children = {}
     end
-    
+
     def add_child(child)
       @children[child.name] = child
     end
-    
+
     def retrieve_child(child_name)
       child = @children.fetch(child_name, nil)
     end
-    
+
     def lookup_refs(nodes_visited=[])
       result = []
       if @settings[:ref]
@@ -40,7 +40,7 @@ class OM::XML::Term
           raise "Cannot perform lookup_ref for the #{self.name} builder.  It doesn't have a reference to any terminology builder"
         end
         target = self.terminology_builder.retrieve_term_builder(*@settings[:ref])
-        
+
         # Fail on circular references and return an intelligible error message
         if nodes_visited.include?(target)
           nodes_visited << self
@@ -59,12 +59,12 @@ class OM::XML::Term
       end
       return result
     end
-    
+
     # If a :ref value has been set, looks up the target of that ref and merges the target's settings & children with the current builder's settings & children
     # operates recursively, so it is possible to apply refs that in turn refer to other nodes.
     def resolve_refs!
       name_of_last_ref = nil
-      lookup_refs.each_with_index do |ref,z|        
+      lookup_refs.each_with_index do |ref,z|
         @settings = two_layer_merge(@settings, ref.settings)
         @children.merge!(ref.children)
         name_of_last_ref = ref.name
@@ -75,22 +75,22 @@ class OM::XML::Term
       @settings.delete :ref
       return self
     end
-    
+
     # Returns a new Hash that merges +downstream_hash+ with +upstream_hash+
-    # similar to calling +upstream_hash+.merge(+downstream_hash+) only it also merges 
+    # similar to calling +upstream_hash+.merge(+downstream_hash+) only it also merges
     # any internal values that are themselves Hashes.
     def two_layer_merge(downstream_hash, upstream_hash)
       up = upstream_hash.dup
       dn = downstream_hash.dup
       up.each_pair do |setting_name, value|
-        if value.kind_of?(Hash) && downstream_hash.has_key?(setting_name)  
+        if value.kind_of?(Hash) && downstream_hash.has_key?(setting_name)
           dn[setting_name] = value.merge(downstream_hash[setting_name])
           up.delete(setting_name)
         end
       end
       return up.merge(dn)
     end
-    
+
     # Builds a new OM::XML::Term based on the Builder object's current settings
     # If no path has been provided, uses the Builder object's name as the term's path
     # Recursively builds any children, appending the results as children of the Term that's being built.
@@ -100,9 +100,9 @@ class OM::XML::Term
       if term.self.settings.has_key?(:proxy)
         term = OM::XML::NamedTermProxy.new(self.name, self.settings[:proxy], terminology, self.settings)
       else
-        term = OM::XML::Term.new(self.name)
-      
-        self.settings.each do |name, values|  
+        term = OM::XML::Term.new(self.name, {}, terminology)
+
+        self.settings.each do |name, values|
           if term.respond_to?(name.to_s+"=")
             term.instance_variable_set("@#{name}", values)
           end
@@ -112,12 +112,12 @@ class OM::XML::Term
         end
         term.generate_xpath_queries!
       end
-      
+
       return term
     end
-    
+
     # Any unknown method calls will add an entry to the settings hash and return the current object
-    def method_missing method, *args, &block 
+    def method_missing method, *args, &block
       if args.length == 1
         args = args.first
       end
@@ -125,16 +125,16 @@ class OM::XML::Term
       return self
     end
   end
-  
+
   #
-  # Class Definition for Term 
+  # Class Definition for Term
   #
 
   include OM::TreeNode
 
   attr_accessor :name, :xpath, :xpath_constrained, :xpath_relative, :path, :index_as, :required, :data_type, :variant_of, :path, :default_content_path, :is_root_term
   attr_accessor :children, :internal_xml, :terminology
-  
+
   # Any XML attributes that qualify the Term.
   #
   # @example Declare a Term that has a given attribute (ie. //title[@xml:lang='eng'])
@@ -142,19 +142,19 @@ class OM::XML::Term
   # @example Use nil to point to nodes that do not have a given attribute (ie. //title[not(@xml:lang)])
   #   t.title_without_lang_attribute(:path=>"title", :attributes=>{"xml:lang"=>nil})
   attr_accessor :attributes
-  
+
   # Namespace Prefix (xmlns) for the Term.
   #
   # By default, OM assumes that all terms in a Terminology have the namespace set in the root of the document.  If you want to set a different namespace for a Term, pass :namespace_prefix into its initializer (or call .namespace_prefix= on its builder)
   # If a node has _no_ namespace, you must explicitly set namespace_prefix to nil.  Currently you have to do this on _each_ term, you can't set namespace_prefix to nil for an entire Terminology.
-  # 
+  #
   # @example
   #   # For xml like this
   #   <foo xmlns="http://foo.com/schemas/fooschema" xmlns:bar="http://bar.com/schemas/barschema">
   #     <address>1400 Pennsylvania Avenue</address>
   #     <bar:latitude>56</bar:latitude>
   #   </foo>
-  #   
+  #
   #   # The Terminology would look like this
   #   OM::XML::Terminology::Builder.new do |t|
   #     t.root(:name=>:foo, :path=>"foo", :xmlns=>"http://foo.com/schemas/fooschema", "xmlns:bar"=>"http://bar.com/schemas/barschema")
@@ -163,23 +163,32 @@ class OM::XML::Term
   #   end
   #
   attr_accessor :namespace_prefix
-  
-  
+
+
   # h2. Namespaces
-  # By default, OM assumes that all terms in a Terminology have the namespace set in the root of the document.  If you want to set a different namespace for a Term, pass :namespasce_prefix into its initializer (or call .namespace_prefix= on its builder)
-  # If a node has _no_ namespace, you must explicitly set namespace_prefix to nil.
-  def initialize(name, opts={})
-    opts = {:namespace_prefix=>"oxns", :ancestors=>[], :children=>{}}.merge(opts)
+  # By default, OM assumes you have no namespace defined unless it is explicitly defined at the root of your document.
+  # If you want to specify which namespace a term is using, use:
+  #   namspace_prefix => "bar"
+  # This value defaults to nil, in which case if a default namespace is set in the termnology, that namespace will be used.
+  def initialize(name, opts={}, terminology=nil)
+    opts = {:ancestors=>[], :children=>{}}.merge(opts)
     [:children, :ancestors,:path, :index_as, :required, :type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |accessor_name|
-      instance_variable_set("@#{accessor_name}", opts.fetch(accessor_name, nil) )     
+      instance_variable_set("@#{accessor_name}", opts.fetch(accessor_name, nil) )
+    end
+    unless terminology.nil?
+      if opts[:namespace_prefix].nil?
+        unless terminology.namespaces["xmlns"].nil?
+          @namespace_prefix = "oxns"
+        end
+      end
     end
     @name = name
     if @path.nil? || @path.empty?
       @path = name.to_s
     end
   end
-  
-  def self.from_node(mapper_xml)    
+
+  def self.from_node(mapper_xml)
     name = mapper_xml.attribute("name").text.to_sym
     attributes = {}
     mapper_xml.xpath("./attribute").each do |a|
@@ -189,19 +198,19 @@ class OM::XML::Term
     [:index_as, :required, :type, :variant_of, :path, :default_content_path, :namespace_prefix].each do |accessor_name|
       attribute =  mapper_xml.attribute(accessor_name.to_s)
       unless attribute.nil?
-        new_mapper.instance_variable_set("@#{accessor_name}", attribute.text )      
-      end     
+        new_mapper.instance_variable_set("@#{accessor_name}", attribute.text )
+      end
     end
     new_mapper.internal_xml = mapper_xml
-    
+
     mapper_xml.xpath("./mapper").each do |child_node|
       child = self.from_node(child_node)
       new_mapper.add_child(child)
     end
-    
+
     return new_mapper
   end
-  
+
   # crawl down into mapper's children hash to find the desired mapper
   # ie. @test_mapper.retrieve_mapper(:conference, :role, :text)
   def retrieve_term(*pointers)
@@ -220,19 +229,19 @@ class OM::XML::Term
     end
     return target
   end
-  
+
   def is_root_term?
     @is_root_term == true
   end
-  
+
   def xpath_absolute
     @xpath
   end
-  
+
   # +term_pointers+ reference to the property you want to generate a builder template for
   # @opts
   def xml_builder_template(extra_opts = {})
-    extra_attributes = extra_opts.fetch(:attributes, {})  
+    extra_attributes = extra_opts.fetch(:attributes, {})
 
     node_options = []
     node_child_template = ""
@@ -260,7 +269,7 @@ class OM::XML::Term
     end
     return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
   end
-  
+
   # Generates absolute, relative, and constrained xpaths for the term, setting xpath, xpath_relative, and xpath_constrained accordingly.
   # Also triggers update_xpath_values! on all child nodes, as their absolute paths rely on those of their parent nodes.
   def generate_xpath_queries!
@@ -270,7 +279,7 @@ class OM::XML::Term
     self.children.each_value {|child| child.generate_xpath_queries! }
     return self
   end
-  
+
   # Return an XML representation of the Term
   # @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
@@ -314,7 +323,7 @@ class OM::XML::Term
           xml.constrained xpath_constrained
         }
         if options.fetch(:children, true)
-          xml.children 
+          xml.children
         end
       }
     end
@@ -324,7 +333,7 @@ class OM::XML::Term
     end
     return doc
   end
-  
+
   # private :update_xpath_values
-  
+
 end