om 1.8.0 → 1.8.1

data/gemfiles/gemfile.rails3

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gemspec :path=>"../"
+
+gem 'activemodel', '~> 3.2.13'
+
+group :development, :test do
+  gem 'rcov', :platform => :mri_18
+  gem 'simplecov', :platform => :mri_19
+  gem 'simplecov-rcov', :platform => :mri_19
+end

data/gemfiles/gemfile.rails4

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec :path=>"../"
+
+gem 'activemodel', '4.0.0.rc1'
+
+group :development, :test do
+  gem 'simplecov', :platform => :mri_19
+  gem 'simplecov-rcov', :platform => :mri_19
+end

data/lib/om.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
-require 'active_support/concern'
-require 'active_model/dirty'
+require 'active_model'
 require 'deprecation'
 require 'nokogiri'
 
@@ -10,7 +9,7 @@ module OM
   # Converts [{":person"=>"0"}, ":last_name"] to [{:person=>0}, :last_name]
   def self.destringify(params)
     case params
-    when String       
+    when String
       if params == "0" || params.to_i != 0
         result = params.to_i
       elsif params[0,1] == ":"
@@ -19,13 +18,13 @@ module OM
         result = params.to_sym
       end
       return result
-    when Hash 
+    when Hash
       result = {}
       params.each_pair do |k,v|
         result[ destringify(k) ] = destringify(v)
       end
       return result
-    when Array 
+    when Array
       result = []
       params.each do |x|
         result << destringify(x)
@@ -35,31 +34,29 @@ module OM
       return params
     end
   end
-  
+
   # Convert a Term pointer into a flat array without Hashes.
   # If include_indices is set to false, node indices will be removed.
   #
   # @param [Array] pointers array that you would pass into other Accessor methods
   # @param [Boolean] include_indices (default: true) if set to false, parent indices will be excluded from the array
   # @example Turn a pointer into a flat array with node indices preserved
-  #   OM.pointers_to_flat_array( [{:conference=>0}, {:role=>1}, :text] ) 
+  #   OM.pointers_to_flat_array( [{:conference=>0}, {:role=>1}, :text] )
   #   => [:conference, 0, :role, 1, :text]
   # @example Remove node indices by setting include_indices to false
-  #   OM.pointers_to_flat_array( [{:conference=>0}, {:role=>1}, :text], false ) 
+  #   OM.pointers_to_flat_array( [{:conference=>0}, {:role=>1}, :text], false )
   #   => [:conference, :role, :text]
   def self.pointers_to_flat_array(pointers, include_indices=true)
     flat_array = []
     pointers.each do |pointer|
       if pointer.kind_of?(Hash)
         flat_array << pointer.keys.first
-        if include_indices 
-          flat_array << pointer.values.first
-        end
+        flat_array << pointer.values.first if include_indices
       else
         flat_array << pointer
       end
     end
-    return flat_array
+    flat_array
   end
 
   def self.version

data/lib/om/samples/mods_article.rb

@@ -1,7 +1,7 @@
 class OM::Samples::ModsArticle
-    
+
     include OM::XML::Document
-    
+
     set_terminology do |t|
       t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd", "xmlns:foo"=>"http://my.custom.namespace")
 
@@ -11,17 +11,17 @@ class OM::Samples::ModsArticle
           t.main_title_lang(:path=>{:attribute=> "xml:lang"})
         }
         t.french_title(:ref=>[:title_info,:main_title], :attributes=>{"xml:lang"=>"fre"})
-        
+
         t.language(:index_as=>[:facetable],:path=>{:attribute=>"lang"})
-      } 
+      }
       t.language{
         t.lang_code(:index_as=>[:facetable], :path=>"languageTerm", :attributes=>{:type=>"code"})
       }
-      t.abstract   
+      t.abstract
       t.subject {
         t.topic(:index_as=>[:facetable])
-      }      
-      t.topic_tag(:proxy=>[:subject, :topic])    
+      }
+      t.topic_tag(:proxy=>[:subject, :topic])
       # t.topic_tag(:index_as=>[:facetable],:path=>"subject", :default_content_path=>"topic")
       # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
       t.name_ {
@@ -40,7 +40,7 @@ class OM::Samples::ModsArticle
         t.computing_id
         t.name_content(:path=>"text()")
       }
-      # lookup :person, :first_name        
+      # lookup :person, :first_name
       t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable])
       t.department(:proxy=>[:person,:description],:index_as=>[:facetable])
       t.organization(:ref=>:name, :attributes=>{:type=>"corporate"}, :index_as=>[:facetable])
@@ -78,7 +78,7 @@ class OM::Samples::ModsArticle
       t.title(:proxy=>[:title_info, :main_title])
       t.journal_title(:proxy=>[:journal, :title_info, :main_title])
     end
-    
+
     # Changes from OM::Properties implementation
     # renamed family_name => last_name
     # start_page & end_page now accessible as [:journal, :issue, :pages, :start] (etc.)

data/lib/om/tree_node.rb

@@ -1,23 +1,23 @@
 module OM::TreeNode
-  
+
   attr_accessor :ancestors
-  
+
   #  insert the mapper into the given parent
   def set_parent(parent_mapper)
     parent_mapper.children[@name] = self
     @ancestors << parent_mapper
   end
-  
+
   #  insert the given mapper into the current mappers children
   def add_child(child_mapper)
     child_mapper.ancestors << self
-    @children[child_mapper.name.to_sym] = child_mapper    
+    @children[child_mapper.name.to_sym] = child_mapper
   end
-  
+
   def retrieve_child(child_name)
     child = @children.fetch(child_name, nil)
   end
-  
+
   def parent
     ancestors.last
   end

data/lib/om/version.rb

@@ -1,3 +1,3 @@
 module Om
-  VERSION = "1.8.0"
+  VERSION = '1.8.1'
 end

data/lib/om/xml.rb

@@ -13,46 +13,44 @@ require "om/xml/dynamic_node"
 require "om/xml/template_registry"
 
 module OM::XML
-  
+
   # Raised when the XML document or XML template can't be found during an operation
   class TemplateMissingException < StandardError; end
-  
+
   attr_accessor :ng_xml
-  
+
   # Module Methods -- These methods can be called directly on the Module itself
-  
+
   # Transforms an array of values into a string delimited by +delimiter+
   def self.delimited_list( values_array, delimiter=", ")
     values_array.join(delimiter)
   end
-  
-  # 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
-    
+
     # @pointer accessor or property info pointer
-    # 
+    #
     # ex. [[:person,1],:role] will be converted to [{:person=>1},:role]
-    def sanitize_pointer(pointer) 
-      if pointer.kind_of?(Array)        
+    def sanitize_pointer(pointer)
+      if pointer.kind_of?(Array)
         pointer.each do |x|
-          if x.kind_of?(Array)
-            pointer[pointer.index(x)] = Hash[x[0],x[1]] 
-          end
+          pointer[pointer.index(x)] = Hash[x[0],x[1]] if x.kind_of?(Array)
         end
       end
-      return pointer
+      pointer
     end
-    
+
   end
-  
+
   # Instance Methods -- These methods will be available on instances of classes that include this module
-  
+
   def self.included(klass)
     klass.extend(ClassMethods)
     klass.send(:include, OM::XML::Container)
     klass.send(:include, OM::XML::Validation)
   end
-  
-  
+
+
 end

data/lib/om/xml/container.rb

@@ -1,12 +1,12 @@
 module OM::XML::Container
   extend ActiveSupport::Concern
-  
+
   attr_accessor :ng_xml
-  
-  # 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
-    
+
     # @xml String, File or Nokogiri::XML::Node
     # @tmpl ActiveFedora::MetadataDatastream
     # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
@@ -18,25 +18,25 @@ module OM::XML::Container
       else
         tmpl.ng_xml = Nokogiri::XML::Document.parse(xml)
       end
-      return tmpl
+      tmpl
     end
-    
+
     # By default, new OM Document instances will create an empty xml document, but if you override self.xml_template to return a different object (e.g. Nokogiri::XML::Document), that will be created instead.
     # You can make this method create the documents however you want as long as it returns a Nokogiri::XML::Document.
-    # In the tutorials, we use Nokogiri::XML::Builder in this mehtod and call its .doc method at the end of xml_template in order to return the Nokogiri::XML::Document object. Instead of using Nokogiri::XML::Builder, you could put your template into an actual xml file and have xml_template use Nokogiri::XML::Document.parse to load it. That’s up to you. 
+    # In the tutorials, we use Nokogiri::XML::Builder in this mehtod and call its .doc method at the end of xml_template in order to return the Nokogiri::XML::Document object. Instead of using Nokogiri::XML::Builder, you could put your template into an actual xml file and have xml_template use Nokogiri::XML::Document.parse to load it. That’s up to you.
     # @return Nokogiri::XML::Document
     def xml_template
       Nokogiri::XML::Document.parse("")
     end
-    
+
   end
-  
+
   def ng_xml
     @ng_xml ||= self.class.xml_template
   end
 
   # Instance Methods -- These methods will be available on instances of classes that include this module
-  
+
   def to_xml(xml = ng_xml)
     if xml == ng_xml
       return xml.to_xml
@@ -52,5 +52,5 @@ module OM::XML::Container
         raise "You can only pass instances of Nokogiri::XML::Node into this method.  You passed in #{xml}"
     end
   end
-  
+
 end

data/lib/om/xml/document.rb

@@ -35,7 +35,7 @@ module OM::XML::Document
       self.terminology_builder.extend_terminology(&block)
       rebuild_terminology!
     end
-    
+
     # (Explicitly) inherit terminology from upstream classes
     def use_terminology klass
       self.terminology_builder = klass.terminology_builder.dup
@@ -69,9 +69,7 @@ module OM::XML::Document
   end
 
   def ng_xml_will_change!
-    if self.respond_to?(:dirty=)
-      self.dirty = true
-    end
+    self.dirty = true if self.respond_to?(:dirty=)
 
     # throw away older version.
     changed_attributes['ng_xml'] = nil
@@ -196,9 +194,7 @@ module OM::XML::Document
 
   private
   def manipulate_node(method, target, *args, &block)
-    if target.is_a?(Array)
-      target = self.find_by_terms(*target)
-    end
+    target = self.find_by_terms(*target) if target.is_a?(Array)
     raise "You must call define_template before calling #{method}" if template_registry.nil?
     ng_xml_will_change!
     template_registry.send(method, target, *args, &block)

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,33 +38,23 @@ module OM
         self.parent = parent
       end
 
-      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
+      # 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
       end
 
-      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
+      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)
       end
 
       def val=(args)
@@ -82,16 +72,7 @@ module OM
         end
       end
 
-
-      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 
+      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) }
@@ -101,13 +82,13 @@ module OM
       def nodeset
         query = xpath
         trim_text = !query.index("text()").nil?
-        return @document.find_by_xpath(query)
+        @document.find_by_xpath(query)
       end
 
       def delete
         nodeset.delete
       end
-      
+
       def inspect
         val.inspect
       end
@@ -126,7 +107,7 @@ module OM
         else ### A pointer
           parent.nil? ? [key] : parent.to_pointer << key
         end
-      end 
+      end
 
       def xpath
         if parent.nil?
@@ -135,10 +116,8 @@ 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)
@@ -147,15 +126,12 @@ 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 = []
-            
-         if parent
-           chain += parent.retrieve_addressed_node()
-         end
+         chain += parent.retrieve_addressed_node() if parent
          if (self.index)
            ### This is an index
            node = AddressedNode.new(key, term.xpath_relative, self)
@@ -166,17 +142,36 @@ module OM
             first = proxy.shift
             p = @document.class.terminology.retrieve_node(*first)
             chain << AddressedNode.new(p, p.xpath_relative, self)
-            while !proxy.empty?
+            until 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