om 1.8.0 → 1.8.1

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?
-    return false
+    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 
-    return self.proxied_term.send(method, *args)
+  def method_missing method, *args, &block
+    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
-    
-    return builder.doc
+
+    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,11 +77,9 @@ class OM::XML::TemplateRegistry
     result = create_detached_node(nil, node_type, *args)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
     result.traverse { |node|
-      if node.is_a?(Nokogiri::XML::CharacterData)
-        node.namespace = nil
-      end
+      node.namespace = nil if node.is_a?(Nokogiri::XML::CharacterData)
     }
-    return result
+    result
   end
 
   # +instantiate+ a node and add it as a child of the [Nokogiri::XML::Node] specified by +target_node+
@@ -125,7 +123,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
@@ -140,7 +138,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.
@@ -148,13 +146,9 @@ class OM::XML::TemplateRegistry
   # @param [Array] args any additional args
   def create_detached_node(builder_node, node_type, *args)
     proc = @templates[node_type]
-    if proc.nil?
-      raise NameError, "Unknown node type: #{node_type.to_s}"
-    end
-    if builder_node.nil?
-      builder_node = empty_root_node
-    end
-    
+    raise NameError, "Unknown node type: #{node_type.to_s}" if proc.nil?
+    builder_node = empty_root_node if builder_node.nil?
+
     builder = Nokogiri::XML::Builder.with(builder_node) do |xml|
       proc.call(xml,*args)
     end
@@ -165,11 +159,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) and target_node.length == 1
+    if target_node.is_a?(Nokogiri::XML::NodeSet) && target_node.length == 1
       target_node = target_node.first
     end
     builder_node = builder_node_offset == :parent ? target_node.parent : target_node
@@ -177,9 +171,7 @@ class OM::XML::TemplateRegistry
     result = target_node.send(method, new_node)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
     new_node.traverse { |node|
-      if node.is_a?(Nokogiri::XML::CharacterData)
-        node.namespace = nil
-      end
+      node.namespace = nil if node.is_a?(Nokogiri::XML::CharacterData)
     }
     if block_given?
       yield result
@@ -187,9 +179,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,16 +56,14 @@ class OM::XML::Term
           trail = ""
           nodes_visited.each_with_index do |node, z|
             trail << node.name.inspect
-            unless z == nodes_visited.length-1
-              trail << " => "
-            end
+            trail << " => " unless z == nodes_visited.length-1
           end
           raise OM::XML::Terminology::CircularReferenceError, "Circular reference in Terminology: #{trail}"
         end
         result << target
         result.concat( target.lookup_refs(nodes_visited << self) )
       end
-      return result
+      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
@@ -81,7 +79,7 @@ class OM::XML::Term
         @settings[:path] = name_of_last_ref.to_s
       end
       @settings.delete :ref
-      return self
+      self
     end
 
     # Returns a new Hash that merges +downstream_hash+ with +upstream_hash+
@@ -96,7 +94,7 @@ class OM::XML::Term
           up.delete(setting_name)
         end
       end
-      return up.merge(dn)
+      up.merge(dn)
     end
 
     # Builds a new OM::XML::Term based on the Builder object's current settings
@@ -121,31 +119,29 @@ class OM::XML::Term
         term.generate_xpath_queries!
       end
 
-      return term
+      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
-      return self
+      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
-      return self
+      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
-      if args.length == 1
-        args = args.first
-      end
+      args = args.first if args.length == 1
       @settings[method] = args
-      return self
+      self
     end
   end
 
@@ -197,9 +193,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)
@@ -211,15 +207,11 @@ class OM::XML::Term
 
     unless terminology.nil?
       if opts[:namespace_prefix].nil?
-        unless terminology.namespaces["xmlns"].nil?
-          @namespace_prefix = "oxns"
-        end
+        @namespace_prefix = "oxns" unless terminology.namespaces["xmlns"].nil?
       end
     end
     @name = name
-    if @path.nil? || @path.empty?
-      @path = name.to_s
-    end
+    @path = name.to_s if @path.nil? || @path.empty?
   end
 
 
@@ -237,7 +229,7 @@ class OM::XML::Term
       end
       new_values
   end
-  
+
   # @param val [String,Date,Integer]
   def serialize (val)
     case type
@@ -245,7 +237,7 @@ class OM::XML::Term
       val.to_s
     when :boolean
       val.to_s
-    else 
+    else
       val
     end
   end
@@ -255,14 +247,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
@@ -287,7 +279,7 @@ class OM::XML::Term
       new_mapper.add_child(child)
     end
 
-    return new_mapper
+    new_mapper
   end
 
   ##
@@ -312,7 +304,7 @@ class OM::XML::Term
         return nil
       end
     end
-    return target
+    target
   end
 
   def is_root_term?
@@ -336,7 +328,7 @@ class OM::XML::Term
     else
       node_options = ["\':::builder_new_value:::\'"]
     end
-    if !self.attributes.nil?
+    unless self.attributes.nil?
       self.attributes.merge(extra_attributes).each_pair do |k,v|
         node_options << "\'#{k}\'=>\'#{v}\'" unless v == :none
       end
@@ -346,7 +338,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? and self.namespace_prefix != 'oxns'
+    elsif !self.namespace_prefix.nil? && self.namespace_prefix != 'oxns'
       builder_ref = "xml['#{self.namespace_prefix}']"
     elsif self.path.kind_of?(Hash) && self.path[:attribute]
       builder_method = "@#{self.path[:attribute]}"
@@ -355,7 +347,7 @@ class OM::XML::Term
       builder_method += "_"
     end
     template = "#{builder_ref}.#{builder_method}( #{OM::XML.delimited_list(node_options)} )" + node_child_template
-    return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
+    template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
   end
 
   # Generates absolute, relative, and constrained xpaths for the term, setting xpath, xpath_relative, and xpath_constrained accordingly.
@@ -365,7 +357,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! }
-    return self
+    self
   end
 
   # Return an XML representation of the Term
@@ -380,9 +372,7 @@ 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) {
-        if is_root_term?
-          xml.is_root_term("true")
-        end
+        xml.is_root_term("true") if is_root_term?
         xml.path path
         xml.namespace_prefix namespace_prefix
         unless attributes.nil? || attributes.empty?
@@ -393,15 +383,11 @@ class OM::XML::Term
           }
         end
         xml.index_as {
-          unless index_as.nil?
-            index_as.each  { |index_type| xml.index_type }
-          end
+          index_as.each  { |index_type| xml.index_type } unless index_as.nil?
         }
         xml.required required
         xml.data_type type
-        unless variant_of.nil?
-          xml.variant_of variant_of
-        end
+        xml.variant_of variant_of unless variant_of.nil?
         unless default_content_path.nil?
           xml.default_content_path default_content_path
         end
@@ -410,16 +396,14 @@ class OM::XML::Term
           xml.absolute xpath
           xml.constrained xpath_constrained
         }
-        if options.fetch(:children, true)
-          xml.children
-        end
+        xml.children if options.fetch(:children, true)
       }
     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
-    return doc
+    doc
   end
 
   # private :update_xpath_values

data/lib/om/xml/term_value_operators.rb

@@ -3,12 +3,12 @@ require "logger"
 
 class OM::XML::ParentNodeNotFoundError < RuntimeError; end
 module OM::XML::TermValueOperators
-  
+
   # Retrieves all of the nodes from the current document that match +term_pointer+ and returns an array of their values
   def term_values(*term_pointer)
     result = []
     xpath = self.class.terminology.xpath_with_indexes(*term_pointer)
-    #if value is on line by itself sometimes does not trim leading and trailing whitespace for a text node so will detect and fix it
+    # if value is on line by itself sometimes does not trim leading and trailing whitespace for a text node so will detect and fix it
     trim_text = !xpath.nil? && !xpath.index("text()").nil?
     find_by_terms(*term_pointer).each {|node| result << (trim_text ? node.text.strip : node.text) }
 
@@ -20,61 +20,59 @@ module OM::XML::TermValueOperators
       term.deserialize(result)
     end
   end
-  
+
   # alias for term_values
   def property_values(*lookup_args)
     term_values(*lookup_args)
   end
-  
-  # 
+
+  #
   # example term 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_values(params={})
-    # remove any terms from params that this datastream doesn't recognize    
-    
-    params.delete_if do |term_pointer,new_values| 
+    # remove any terms from params that this datastream doesn't recognize
+
+    params.delete_if do |term_pointer,new_values|
       if term_pointer.kind_of?(String)
         true
       else
         !self.class.terminology.has_term?(*OM.destringify(term_pointer))
       end
     end
-    
+
     result = params.dup
-    
+
     params.each_pair do |term_pointer,new_values|
       pointer = OM.destringify(term_pointer)
       template_pointer = OM.pointers_to_flat_array(pointer,false)
       hn = OM::XML::Terminology.term_hierarchical_name(*pointer)
-      
+
       term = self.class.terminology.retrieve_term( *OM.pointers_to_flat_array(pointer,false) )
 
       # Sanitize new_values to always be a hash with indexes
       new_values = term.sanitize_new_values(new_values)
-      
+
       # Populate the response hash appropriately, using hierarchical names for terms as keys rather than the given pointers.
       result.delete(term_pointer)
       result[hn] = new_values.dup
-      
+
       # Skip any submitted values if the new value matches the current values
       current_values = term_values(*pointer)
       new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y|
         z = new_values[y]
-        if current_values[y.to_i]==z and y.to_i > -1
-          new_values.delete(y)
-        end
-      end 
-      
+        new_values.delete(y) if current_values[y.to_i]==z && y.to_i > -1
+      end
+
       # Fill out the pointer completely if the final term is a NamedTermProxy
       if term.kind_of? OM::XML::NamedTermProxy
         pointer.pop
         pointer = pointer.concat(term.proxy_pointer)
       end
-      
+
       xpath = self.class.terminology.xpath_with_indexes(*pointer)
       parent_pointer = pointer.dup
       parent_pointer.pop
       parent_xpath = self.class.terminology.xpath_with_indexes(*parent_pointer)
-      
+
       # If the value doesn't exist yet, append it.  Otherwise, update the existing value.
       new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y|
         z = new_values[y]
@@ -89,18 +87,18 @@ module OM::XML::TermValueOperators
         end
       end
     end
-    return result
+    result
   end
-  
+
   def term_values_append(opts={})
     parent_select = Array( opts[:parent_select] )
     parent_index = opts[:parent_index]
     template = opts[:template]
-    new_values = Array( opts[:values] )  
-    
+    new_values = Array( opts[:values] )
+
     parent_nodeset = find_by_terms(*parent_select)
     parent_node = node_from_set(parent_nodeset, parent_index)
-    
+
     if parent_node.nil?
       if parent_select.empty?
         parent_node = ng_xml.root
@@ -110,12 +108,12 @@ module OM::XML::TermValueOperators
     end
 
     insert_from_template(parent_node, new_values, template)
-    
-    return parent_node
-    
+
+    parent_node
+
   end
 
-  # Insert xml containing +new_values+ into +parent_node+.  Generate the xml based on +template+ 
+  # Insert xml containing +new_values+ into +parent_node+.  Generate the xml based on +template+
   # @param [Nokogiri::XML::Node] parent_node to insert new xml into
   # @param [Array] new_values to build the xml around
   # @param [Array -- (OM term pointer array) OR String -- (like what you would pass into Nokogiri::XML::Builder.new)] template for building the new xml.  Use the syntax that Nokogiri::XML::Builder uses.
@@ -133,23 +131,23 @@ module OM::XML::TermValueOperators
       template = self.class.terminology.xml_builder_template( *template_args )
     end
 
-    #if there is an xpath element pointing to text() need to change to just 'text' so it references the text method for the parent node
+    # if there is an xpath element pointing to text() need to change to just 'text' so it references the text method for the parent node
     template.gsub!(/text\(\)/, 'text')
-    
+
     builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
       new_values.each do |builder_new_value|
         builder_new_value = builder_new_value.gsub(/'/, "\\\\'") # escape any apostrophes in the new value
         if matchdata = /xml\.@(\w+)/.match(template)
           parent_node.set_attribute(matchdata[1], builder_new_value)
-        else 
+        else
           builder_arg = eval('"'+ template + '"') # this inserts builder_new_value into the builder template
           eval(builder_arg)
         end
       end
     end
-    return parent_node
+    parent_node
   end
-  
+
   # Creates necesary ancestor nodes to support inserting a new term value where the ancestor node(s) don't exist yet.
   # Corrects node indexes in the pointer array to correspond to the ancestors that it creates.
   # Returns a two-value array with the 'parent' node and a corrected pointer array
@@ -159,20 +157,18 @@ module OM::XML::TermValueOperators
     parent_select = Array(parent_select)
     parent_nodeset = find_by_terms(*parent_select)
     starting_point = node_from_set(parent_nodeset, parent_index)
-    if starting_point.nil? 
-      starting_point = [] 
-    end
+    starting_point = [] if starting_point.nil?
     to_build = []
-    until !starting_point.empty?
+    while starting_point.empty?
       to_build = [parent_select.pop] + to_build
       starting_point = find_by_terms(*parent_select)
-      if starting_point.empty? && parent_select.empty? 
+      if starting_point.empty? && parent_select.empty?
         raise OM::XML::TemplateMissingException, "Cannot insert nodes into the document because it is empty.  Try defining self.xml_template on the #{self.class} class."
       end
     end
-    to_build.each do |term_pointer|      
+    to_build.each do |term_pointer|
       parent_select << term_pointer
-      
+
       # If pointers in parent_select don't match with the indexes of built ancestors, correct the hash
       if find_by_terms(*parent_select+[{}]).length == 0
         if parent_select.last.kind_of?(Hash)
@@ -198,13 +194,13 @@ module OM::XML::TermValueOperators
     if parent_index > starting_point.length
       parent_index = starting_point.length - 1
     end
-    return node_from_set(starting_point, parent_index)
+    node_from_set(starting_point, parent_index)
   end
-  
+
   def term_value_update(node_select,node_index,new_value,opts={})
     ng_xml_will_change!
     # template = opts.fetch(:template,nil)
-    
+
     node = find_by_terms_and_value(*node_select)[node_index]
     if delete_on_update?(node, new_value)
       node.remove
@@ -216,23 +212,23 @@ module OM::XML::TermValueOperators
   def delete_on_update?(node, new_value)
     new_value == "" || new_value == :delete
   end
-  
+
   # def term_value_set(term_ref, query_opts, node_index, new_value)
   # end
-  
+
   def term_value_delete(opts={})
     ng_xml_will_change!
     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 = find_by_terms_and_value(xpath_select).first
     else
       # parent_nodeset = find_by_terms_and_value(parent_select, parent_select)
       parent_nodeset = find_by_terms_and_value(*parent_select)
-      
+
       if parent_index.nil?
         node = node_from_set(parent_nodeset, child_index)
       else
@@ -241,24 +237,24 @@ module OM::XML::TermValueOperators
         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) 
+    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
+
+    node
   end
-  
+
   private :node_from_set
-  
+
 end