om 1.8.1 → 1.9.0.pre1

data/lib/om/xml/dynamic_node.rb

@@ -3,8 +3,8 @@ module OM
     #
     # Provides a natural syntax for using OM Terminologies to access values from xml Documents
     #
-    # *Note*: All of these examples assume that @article is an instance of OM::Samples::ModsArticle.  Look at that file to see the Terminology.
-    #
+    # *Note*: All of these examples assume that @article is an instance of OM::Samples::ModsArticle.  Look at that file to see the Terminology. 
+    # 
     # @example Return an array of the value(s) "start page" node(s) from the second issue node within the first journal node
     #   # Using DynamicNode syntax:
     #   @article.journal(0).issue(1).pages.start
@@ -30,7 +30,7 @@ module OM
       instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
 
       attr_accessor :key, :index, :parent, :addressed_node, :term
-      def initialize(key, index, document, term, parent=nil)  # #TODO a real term object in here would make it easier to lookup
+      def initialize(key, index, document, term, parent=nil)  ##TODO a real term object in here would make it easier to lookup
         self.key = key
         self.index = index
         @document = document
@@ -38,23 +38,33 @@ module OM
         self.parent = parent
       end
 
-      # In practice, method_missing will respond 4 different ways:
-      # (1) ALL assignment operations are accepted/attempted as new nodes,
-      # (2) ANY operation with multiple arguments is accepted/attempted as a new node (w/ index),
-      # (3) With an auto-constructed sub DynamicNode object,
-      # (4) By handing off to val.  This is the only route that will return NoMethodError.
-      #
-      # Here we don't have args, so we cannot handle cases 2 and 3.  But we can at least do 1 and 4.
-      def respond_to_missing?(name, include_private = false)
-        /=$/.match(name.to_s) || val.respond_to?(name, include_private) || super
+      def method_missing (name, *args, &block)
+        if /=$/.match(name.to_s)
+          new_update_node(name, args)
+        elsif args.length > 1
+          new_update_node_with_index(name, args)
+        else
+          child =  term_child_by_name(term.nil? ? parent.term : term, name)
+          if child
+            OM::XML::DynamicNode.new(name, args.first, @document, child, self)
+          else 
+            val.send(name, *args, &block)
+          end
+        end
+      end
+
+      def new_update_node(name, args)
+        modified_name = name.to_s.chop.to_sym
+        child = term.retrieve_term(modified_name)
+        node = OM::XML::DynamicNode.new(modified_name, nil, @document, child, self)
+        node.val=args
       end
 
-      def method_missing(name, *args, &block)
-        return new_update_node(name.to_s.chop.to_sym, nil, args) if /=$/.match(name.to_s)
-        return new_update_node(name, args.shift, args) if args.length > 1
-        child = term_child_by_name(term.nil? ? parent.term : term, name)
-        return OM::XML::DynamicNode.new(name, args.first, @document, child, self) if child
-        val.send(name, *args, &block)
+      def new_update_node_with_index(name, args)
+        index = args.shift
+        child = term.retrieve_term(name)
+        node = OM::XML::DynamicNode.new(name, index, @document, child, self)
+        node.val=args
       end
 
       def val=(args)
@@ -72,7 +82,16 @@ module OM
         end
       end
 
-      def val
+
+      def term_child_by_name(term, name)
+        if (term.kind_of? NamedTermProxy)
+           @document.class.terminology.retrieve_node(*(term.proxy_pointer.dup << name)) 
+        else
+          term.retrieve_term(name)
+        end
+      end
+
+      def val 
         query = xpath
         trim_text = !query.index("text()").nil?
         val = @document.find_by_xpath(query).collect {|node| (trim_text ? node.text.strip : node.text) }
@@ -82,13 +101,13 @@ module OM
       def nodeset
         query = xpath
         trim_text = !query.index("text()").nil?
-        @document.find_by_xpath(query)
+        return @document.find_by_xpath(query)
       end
 
       def delete
         nodeset.delete
       end
-
+      
       def inspect
         val.inspect
       end
@@ -107,7 +126,7 @@ module OM
         else ### A pointer
           parent.nil? ? [key] : parent.to_pointer << key
         end
-      end
+      end 
 
       def xpath
         if parent.nil?
@@ -116,8 +135,10 @@ module OM
           chain = retrieve_addressed_node( )
           '//' + chain.map { |n| n.xpath}.join('/')
         end
+        
       end
 
+
       class AddressedNode
         attr_accessor :xpath, :key, :pointer
         def initialize (pointer, xpath, key)
@@ -126,12 +147,15 @@ module OM
           self.pointer = pointer
         end
       end
-
+     
       ##
       # This is very similar to Terminology#retrieve_term, however it expands proxy paths out into their cannonical paths
       def retrieve_addressed_node()
          chain = []
-         chain += parent.retrieve_addressed_node() if parent
+            
+         if parent
+           chain += parent.retrieve_addressed_node()
+         end
          if (self.index)
            ### This is an index
            node = AddressedNode.new(key, term.xpath_relative, self)
@@ -142,36 +166,17 @@ module OM
             first = proxy.shift
             p = @document.class.terminology.retrieve_node(*first)
             chain << AddressedNode.new(p, p.xpath_relative, self)
-            until proxy.empty?
+            while !proxy.empty?
               first = proxy.shift
               p = p.retrieve_term(first)
               chain << AddressedNode.new(p, p.xpath_relative, self)
             end
-         else
+         else 
            chain << AddressedNode.new(key, term.xpath_relative, self)
          end
          chain
       end
 
-      private
-
-      # Only to be called by method_missing, hence the NoMethodError.
-      # We know term.sanitize_new_values would fail in .val= if we pass a nil term.
-      def new_update_node(name, index, args)
-        child = term.retrieve_term(name)
-        raise NoMethodError, "undefined method `#{name}' in OM::XML::DynamicNode for #{self}:#{self.class}" if child.nil?
-        node = OM::XML::DynamicNode.new(name, index, @document, child, self)
-        node.val = args
-      end
-
-      # Only to be called by method_missing
-      def term_child_by_name(term, name)
-        if (term.kind_of? NamedTermProxy)
-          @document.class.terminology.retrieve_node(*(term.proxy_pointer.dup << name))
-        else
-          term.retrieve_term(name)
-        end
-      end
 
     end
   end

data/lib/om/xml/named_term_proxy.rb

@@ -1,9 +1,9 @@
 class OM::XML::NamedTermProxy
-
+  
   attr_accessor :proxy_pointer, :name, :terminology
-
+  
   include OM::TreeNode
-
+  
   # Creates a Named Proxy that points to another term in the Terminology.
   # Unlike regular terms, NamedTermProxy requires you to provide a reference to the containing Terminology.
   # This is to ensure that it will always be able to look up the term that it's referencing.
@@ -14,13 +14,13 @@ class OM::XML::NamedTermProxy
   def initialize(name, proxy_pointer, terminology, opts={})
     opts = {:namespace_prefix=>"oxns", :ancestors=>[], :children=>{}}.merge(opts)
     [:children, :ancestors, :index_as].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
     @terminology = terminology
     @name = name
     @proxy_pointer = proxy_pointer
   end
-
+  
   def proxied_term
     if self.parent.nil?
       pt = self.terminology.retrieve_term(*self.proxy_pointer)
@@ -33,18 +33,18 @@ class OM::XML::NamedTermProxy
       return pt
     end
   end
-
+  
   # do nothing -- this is to prevent errors when the parent term calls generate_xpath_queries! on its children
   def generate_xpath_queries!
     # do nothing
   end
-
+  
   # A proxy term can never serve as the root term of a Terminology.
   # Explicitly setting is_root_term? to return false to support proxies that are _at_ the root of the Terminology but aren't _the_ root term.
   def is_root_term?
-    false
+    return false
   end
-
+  
   ##
   # Always co-erce :index_as attributes into an Array
   def index_as
@@ -54,10 +54,10 @@ class OM::XML::NamedTermProxy
       self.proxied_term.index_as
     end
   end
-
+  
   # Any unknown method calls will be proxied to the proxied term
-  def method_missing method, *args, &block
-    self.proxied_term.send(method, *args)
+  def method_missing method, *args, &block 
+    return self.proxied_term.send(method, *args)
   end
-
+  
 end

data/lib/om/xml/node_generator.rb

@@ -1,5 +1,5 @@
 module OM::XML::NodeGenerator
-
+    
   # Module Methods -- These methods can be called directly on the Module itself
   # @param OM::XML::Term term The term to generate a node based on
   # @param String builder_new_value The new value to insert into the generated node
@@ -14,8 +14,8 @@ module OM::XML::NodeGenerator
     builder = Nokogiri::XML::Builder.new do |xml|
       eval( builder_call_body )
     end
-
-    builder.doc
+    
+    return builder.doc
   end
 
 end

data/lib/om/xml/template_registry.rb

@@ -1,10 +1,10 @@
-# Extend an OM::XML::Document with reusable templates, then use them to add content to
+# Extend an OM::XML::Document with reusable templates, then use them to add content to 
 # instance documents.
 #
 # Example:
 #
 #   require 'om/samples/mods_article'
-#
+# 
 #   class OM::Samples::ModsArticle
 #     define_template :personalName do |xml, family, given, address|
 #       xml.name(:type => 'personal') do
@@ -13,7 +13,7 @@
 #         xml.namePart(:type => 'termsOfAddress') { xml.text(address) }
 #       end
 #     end
-#
+# 
 #     define_template :role do |xml, text, attrs|
 #       xml.role do
 #         attrs = { :type => 'text' }.merge(attrs)
@@ -21,9 +21,9 @@
 #       end
 #     end
 #   end
-#
+# 
 #   mods = OM::Samples::ModsArticle.from_xml(File.read('./spec/fixtures/CBF_MODS/ARS0025_016.xml'))
-#
+# 
 #   mods.add_previous_sibling_node([:person => 0], :personalName, 'Shmoe', 'Joseph', 'Dr.') { |person|
 #     person.add_child(mods.template(:role, 'author', :authority => 'marcrelator'))
 #     person.add_child(mods.template(:role, 'sub', :authority => 'local', :type => 'code'))
@@ -44,7 +44,7 @@ class OM::XML::TemplateRegistry
     unless node_type.is_a?(Symbol)
       raise TypeError, "Registered node type must be a Symbol (e.g., :person)"
     end
-
+  
     @templates[node_type] = block
     node_type
   end
@@ -77,9 +77,11 @@ class OM::XML::TemplateRegistry
     result = create_detached_node(nil, node_type, *args)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
     result.traverse { |node|
-      node.namespace = nil if node.is_a?(Nokogiri::XML::CharacterData)
+      if node.is_a?(Nokogiri::XML::CharacterData)
+        node.namespace = nil
+      end
     }
-    result
+    return result
   end
 
   # +instantiate+ a node and add it as a child of the [Nokogiri::XML::Node] specified by +target_node+
@@ -123,7 +125,7 @@ class OM::XML::TemplateRegistry
   def swap(target_node, node_type, *args, &block)
     attach_node(:swap, target_node, :parent, node_type, *args, &block)
   end
-
+  
   def methods
     super + @templates.keys.collect { |k| k.to_s }
   end
@@ -138,7 +140,7 @@ class OM::XML::TemplateRegistry
   end
 
   private
-
+  
   # Create a new Nokogiri::XML::Node based on the template for +node_type+
   #
   # @param [Nokogiri::XML::Node] builder_node The node to use as starting point for building the node using Nokogiri::XML::Builder.with(builder_node).  This provides namespace info, etc for constructing the new Node object. If nil, defaults to {OM::XML::TemplateRegistry#empty_root_node}.  This is just used to create the new node and will not be included in the response.
@@ -146,9 +148,13 @@ class OM::XML::TemplateRegistry
   # @param [Array] args any additional args
   def create_detached_node(builder_node, node_type, *args)
     proc = @templates[node_type]
-    raise NameError, "Unknown node type: #{node_type.to_s}" if proc.nil?
-    builder_node = empty_root_node if builder_node.nil?
-
+    if proc.nil?
+      raise NameError, "Unknown node type: #{node_type.to_s}"
+    end
+    if builder_node.nil?
+      builder_node = empty_root_node
+    end
+    
     builder = Nokogiri::XML::Builder.with(builder_node) do |xml|
       proc.call(xml,*args)
     end
@@ -159,11 +165,11 @@ class OM::XML::TemplateRegistry
   #
   # @param [Symbol] method name that should be called on +target_node+, usually a Nokogiri::XML::Node instance method
   # @param [Nokogiri::XML::Node or Nokogiri::XML::NodeSet with only one Node in it] target_node
-  # @param [Symbol] builder_node_offset Indicates node to use as the starting point for _constructing_ the new node using {OM::XML::TemplateRegistry#create_detached_node}. If this is set to :parent, target_node.parent will be used.  Otherwise, target_node will be used.
+  # @param [Symbol] builder_node_offset Indicates node to use as the starting point for _constructing_ the new node using {OM::XML::TemplateRegistry#create_detached_node}. If this is set to :parent, target_node.parent will be used.  Otherwise, target_node will be used. 
   # @param node_type
   # @param [Array] args any additional arguments for creating the node
   def attach_node(method, target_node, builder_node_offset, node_type, *args, &block)
-    if target_node.is_a?(Nokogiri::XML::NodeSet) && target_node.length == 1
+    if target_node.is_a?(Nokogiri::XML::NodeSet) and target_node.length == 1
       target_node = target_node.first
     end
     builder_node = builder_node_offset == :parent ? target_node.parent : target_node
@@ -171,7 +177,9 @@ class OM::XML::TemplateRegistry
     result = target_node.send(method, new_node)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
     new_node.traverse { |node|
-      node.namespace = nil if node.is_a?(Nokogiri::XML::CharacterData)
+      if node.is_a?(Nokogiri::XML::CharacterData)
+        node.namespace = nil
+      end
     }
     if block_given?
       yield result
@@ -179,9 +187,9 @@ class OM::XML::TemplateRegistry
       return result
     end
   end
-
+  
   def empty_root_node
     Nokogiri::XML('<root/>').root
   end
-
+  
 end

data/lib/om/xml/term.rb

@@ -56,14 +56,16 @@ class OM::XML::Term
           trail = ""
           nodes_visited.each_with_index do |node, z|
             trail << node.name.inspect
-            trail << " => " unless z == nodes_visited.length-1
+            unless z == nodes_visited.length-1
+              trail << " => "
+            end
           end
           raise OM::XML::Terminology::CircularReferenceError, "Circular reference in Terminology: #{trail}"
         end
         result << target
         result.concat( target.lookup_refs(nodes_visited << self) )
       end
-      result
+      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
@@ -79,7 +81,7 @@ class OM::XML::Term
         @settings[:path] = name_of_last_ref.to_s
       end
       @settings.delete :ref
-      self
+      return self
     end
 
     # Returns a new Hash that merges +downstream_hash+ with +upstream_hash+
@@ -94,7 +96,7 @@ class OM::XML::Term
           up.delete(setting_name)
         end
       end
-      up.merge(dn)
+      return up.merge(dn)
     end
 
     # Builds a new OM::XML::Term based on the Builder object's current settings
@@ -119,29 +121,31 @@ class OM::XML::Term
         term.generate_xpath_queries!
       end
 
-      term
+      return term
     end
 
     # :data_type accessor has been deprecated in favor of :type
     # Any value set for :data_type will get set for :type instead
     def data_type value
       @settings[:type] = value
-      self
+      return self
     end
     deprecation_deprecate :data_type
 
     # We have to add this method so it will play nice with ruby 1.8.7
     def type value
       @settings[:type] = value
-      self
+      return self
     end
 
 
     # Any unknown method calls will add an entry to the settings hash and return the current object
     def method_missing method, *args, &block
-      args = args.first if args.length == 1
+      if args.length == 1
+        args = args.first
+      end
       @settings[method] = args
-      self
+      return self
     end
   end
 
@@ -193,9 +197,9 @@ class OM::XML::Term
   # @param name [Symbol] the name to refer to this term by
   # @param opts [Hash]
   # @options opts [Array]  :index_as a list of indexing hints provided to to_solr
-  # @options opts [String] :path partial xpath that points to the node.
-  # @options opts [Hash]   :attributes xml attributes to match in the selector
-  # @options opts [String] :namespace_prefix xml namespace for this node
+  # @options opts [String] :path partial xpath that points to the node.  
+  # @options opts [Hash]   :attributes xml attributes to match in the selector 
+  # @options opts [String] :namespace_prefix xml namespace for this node 
   # @options opts [Symbol] :type one of :string, :date, :integer. Defaults to :string
   def initialize(name, opts={}, terminology=nil)
     opts = {:ancestors=>[], :children=>{}}.merge(opts)
@@ -207,11 +211,15 @@ class OM::XML::Term
 
     unless terminology.nil?
       if opts[:namespace_prefix].nil?
-        @namespace_prefix = "oxns" unless terminology.namespaces["xmlns"].nil?
+        unless terminology.namespaces["xmlns"].nil?
+          @namespace_prefix = "oxns"
+        end
       end
     end
     @name = name
-    @path = name.to_s if @path.nil? || @path.empty?
+    if @path.nil? || @path.empty?
+      @path = name.to_s
+    end
   end
 
 
@@ -229,7 +237,7 @@ class OM::XML::Term
       end
       new_values
   end
-
+  
   # @param val [String,Date,Integer]
   def serialize (val)
     case type
@@ -237,7 +245,7 @@ class OM::XML::Term
       val.to_s
     when :boolean
       val.to_s
-    else
+    else 
       val
     end
   end
@@ -247,14 +255,14 @@ class OM::XML::Term
   def deserialize(val)
     case type
     when :date
-      # TODO use present?
+      #TODO use present?
       val.map { |v| !v.empty? ? Date.parse(v) : nil}
     when :integer
-      # TODO use blank?
+      #TODO use blank?
       val.map { |v| v.empty? ? nil : v.to_i}
     when :boolean
       val.map { |v| v == 'true' }
-    else
+    else 
       val
     end
   end
@@ -279,7 +287,7 @@ class OM::XML::Term
       new_mapper.add_child(child)
     end
 
-    new_mapper
+    return new_mapper
   end
 
   ##
@@ -304,7 +312,7 @@ class OM::XML::Term
         return nil
       end
     end
-    target
+    return target
   end
 
   def is_root_term?
@@ -328,7 +336,7 @@ class OM::XML::Term
     else
       node_options = ["\':::builder_new_value:::\'"]
     end
-    unless self.attributes.nil?
+    if !self.attributes.nil?
       self.attributes.merge(extra_attributes).each_pair do |k,v|
         node_options << "\'#{k}\'=>\'#{v}\'" unless v == :none
       end
@@ -338,7 +346,7 @@ class OM::XML::Term
     if builder_method.include?(":")
       builder_ref = "xml['#{self.path[0..path.index(":")-1]}']"
       builder_method = self.path[path.index(":")+1..-1]
-    elsif !self.namespace_prefix.nil? && self.namespace_prefix != 'oxns'
+    elsif !self.namespace_prefix.nil? and self.namespace_prefix != 'oxns'
       builder_ref = "xml['#{self.namespace_prefix}']"
     elsif self.path.kind_of?(Hash) && self.path[:attribute]
       builder_method = "@#{self.path[:attribute]}"
@@ -347,7 +355,7 @@ class OM::XML::Term
       builder_method += "_"
     end
     template = "#{builder_ref}.#{builder_method}( #{OM::XML.delimited_list(node_options)} )" + node_child_template
-    template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
+    return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
   end
 
   # Generates absolute, relative, and constrained xpaths for the term, setting xpath, xpath_relative, and xpath_constrained accordingly.
@@ -357,7 +365,7 @@ class OM::XML::Term
     self.xpath_constrained = OM::XML::TermXpathGenerator.generate_constrained_xpath(self)
     self.xpath_relative = OM::XML::TermXpathGenerator.generate_relative_xpath(self)
     self.children.each_value {|child| child.generate_xpath_queries! }
-    self
+    return self
   end
 
   # Return an XML representation of the Term
@@ -372,7 +380,9 @@ class OM::XML::Term
   def to_xml(options={}, document=Nokogiri::XML::Document.new)
     builder = Nokogiri::XML::Builder.with(document) do |xml|
       xml.term(:name=>name) {
-        xml.is_root_term("true") if is_root_term?
+        if is_root_term?
+          xml.is_root_term("true")
+        end
         xml.path path
         xml.namespace_prefix namespace_prefix
         unless attributes.nil? || attributes.empty?
@@ -383,11 +393,15 @@ class OM::XML::Term
           }
         end
         xml.index_as {
-          index_as.each  { |index_type| xml.index_type } unless index_as.nil?
+          unless index_as.nil?
+            index_as.each  { |index_type| xml.index_type }
+          end
         }
         xml.required required
         xml.data_type type
-        xml.variant_of variant_of unless variant_of.nil?
+        unless variant_of.nil?
+          xml.variant_of variant_of
+        end
         unless default_content_path.nil?
           xml.default_content_path default_content_path
         end
@@ -396,14 +410,16 @@ class OM::XML::Term
           xml.absolute xpath
           xml.constrained xpath_constrained
         }
-        xml.children if options.fetch(:children, true)
+        if options.fetch(:children, true)
+          xml.children
+        end
       }
     end
     doc = builder.doc
     if options.fetch(:children, true)
       children.values.each {|child| child.to_xml(options, doc.xpath("//term[@name=\"#{name}\"]/children").first)}
     end
-    doc
+    return doc
   end
 
   # private :update_xpath_values