om 1.8.1 → 1.9.0.pre1

data/Rakefile

@@ -13,7 +13,7 @@ task :default => :spec
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = Om::VERSION
+  version = Om::VERSION 
 
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "om #{version}"

data/container_spec.rb

@@ -3,34 +3,34 @@ require "nokogiri"
 require "om"
 
 describe "OM::XML::Container" do
-
+  
   before(:all) do
     class ContainerTest
       include OM::XML::Container
     end
   end
-
+  
   before(:each) do
     @container = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
   end
-
+  
   it "should add .ng_xml accessor" do
     @container.should respond_to(:ng_xml)
-    @container.should respond_to(:ng_xml=)
+    @container.should respond_to(:ng_xml=)    
   end
-
+  
   describe "new" do
     it "should populate ng_xml with an instance of Nokogiri::XML::Document" do
       @container.ng_xml.class.should == Nokogiri::XML::Document
     end
   end
-
+  
   describe '#xml_template' do
     it "should return an empty xml document" do
       ContainerTest.xml_template.to_xml.should == "<?xml version=\"1.0\"?>\n"
     end
   end
-
+  
   describe "#from_xml" do
     it "should accept a String, parse it and store it in .ng_xml" do
       Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
@@ -53,36 +53,36 @@ describe "OM::XML::Container" do
       ContainerTest.from_xml.ng_xml.should == "fake template"
     end
   end
-
+  
   describe ".to_xml" do
     it  "should call .ng_xml.to_xml" do
       @container.ng_xml.expects(:to_xml).returns("ng xml")
       @container.to_xml.should == "ng xml"
     end
-
+    
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
       mock_new_node = mock("new node")
       doc.root.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
       result = @container.to_xml(doc)
     end
-
+    
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
       @container.to_xml(doc).should == "<?xml version=\"1.0\"?>\n<test_xml>\n  <foo>\n    <bar>1</bar>\n  </foo>\n</test_xml>\n"
     end
-
+    
     it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
       mock_new_node = mock("new node")
       mock_new_node.stubs(:to_xml).returns("foo")
-
+      
       doc = Nokogiri::XML::Document.parse("<test_document/>")
       el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
       doc.root.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
       el.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
-      @container.to_xml(doc).should
+      @container.to_xml(doc).should 
       @container.to_xml(el)
     end
   end
-
+  
 end

data/lib/om.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
-require 'active_model'
+require 'active_support/concern'
+require 'active_model/dirty'
 require 'deprecation'
 require 'nokogiri'
 
@@ -9,7 +10,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] == ":"
@@ -18,13 +19,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)
@@ -34,29 +35,31 @@ 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
-        flat_array << pointer.values.first if include_indices
+        if include_indices 
+          flat_array << pointer.values.first
+        end
       else
         flat_array << pointer
       end
     end
-    flat_array
+    return 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.1'
+  VERSION = "1.9.0.pre1"
 end

data/lib/om/xml.rb

@@ -1,56 +1,58 @@
-require "om/xml/container"
-require "om/xml/validation"
-
-require "om/xml/terminology"
-require "om/xml/term"
-require "om/xml/term_xpath_generator"
-require "om/xml/node_generator"
-require "om/xml/term_value_operators"
-require "om/xml/named_term_proxy"
-require "om/xml/document"
-require "om/xml/dynamic_node"
-
-require "om/xml/template_registry"
-
+require 'active_support'
 module OM::XML
+  extend ActiveSupport::Autoload 
+  autoload :Container
+  autoload :Validation
+  autoload :Terminology
+  autoload :Term
+  autoload :TerminologyBasedSolrizer
+  autoload :TermXpathGenerator
+  autoload :NodeGenerator
+  autoload :TermValueOperators
+  autoload :NamedTermProxy
+  autoload :Document
+  autoload :DynamicNode
+  autoload :TemplateRegistry
 
   # 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|
-          pointer[pointer.index(x)] = Hash[x[0],x[1]] if x.kind_of?(Array)
+          if x.kind_of?(Array)
+            pointer[pointer.index(x)] = Hash[x[0],x[1]] 
+          end
         end
       end
-      pointer
+      return 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
-      tmpl
+      return 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,8 +69,6 @@ module OM::XML::Document
   end
 
   def ng_xml_will_change!
-    self.dirty = true if self.respond_to?(:dirty=)
-
     # throw away older version.
     changed_attributes['ng_xml'] = nil
   end
@@ -79,23 +77,24 @@ module OM::XML::Document
     changed.include?('ng_xml')
   end
 
-  def method_missing(name, *args)
-    if matches = /([^=]*)=$/.match(name.to_s)
-      modified_name = matches[1].to_sym
-      term = self.class.terminology.retrieve_term(modified_name)
-      if (term)
-        node = OM::XML::DynamicNode.new(modified_name, nil, self, term)
-        node.val=args
-      else
-        super
-      end
-    else
+  def method_missing(method_name, *args)
+    if matches = /([^=]+)=$/.match(method_name.to_s)
+      name = matches[1].to_sym
+    end
+    
+    name ||= method_name
+    
+    begin
       term = self.class.terminology.retrieve_term(name)
-      if (term)
-        OM::XML::DynamicNode.new(name, args.first, self, term)
+      
+      if /=$/.match(method_name.to_s)
+        node = OM::XML::DynamicNode.new(name, nil, self, term)
+        return node.val=args
       else
-        super
+        return OM::XML::DynamicNode.new(name, args.first, self, term)
       end
+    rescue OM::XML::Terminology::BadPointerError
+      super
     end
   end
 
@@ -194,7 +193,9 @@ module OM::XML::Document
 
   private
   def manipulate_node(method, target, *args, &block)
-    target = self.find_by_terms(*target) if target.is_a?(Array)
+    if target.is_a?(Array)
+      target = self.find_by_terms(*target)
+    end
     raise "You must call define_template before calling #{method}" if template_registry.nil?
     ng_xml_will_change!
     template_registry.send(method, target, *args, &block)