om 1.8.1 → 1.9.0.pre1

data/lib/om/xml/terminology.rb

@@ -47,7 +47,9 @@ class OM::XML::Terminology
       @schema = opts.fetch(:schema,nil)
       opts.select {|k,v| k.to_s.include?("xmlns")}.each do |ns_pair|
         @namespaces[ns_pair.first.to_s] = ns_pair.last
-        @namespaces["oxns"] = ns_pair.last if ns_pair.first.to_s == "xmlns"
+        if ns_pair.first.to_s == "xmlns"
+          @namespaces["oxns"] = ns_pair.last
+        end
       end
       root_term_builder = OM::XML::Term::Builder.new(opts.fetch(:path,:root).to_s.sub(/[_!]$/, '')).is_root_term(true)
       term_opts = opts.dup
@@ -55,7 +57,7 @@ class OM::XML::Terminology
       root_term_builder.settings.merge!(term_opts)
       @term_builders[root_term_builder.name] = root_term_builder
 
-      root_term_builder
+      return root_term_builder
     end
 
     # Returns an array of Terms that have been marked as "root" terms
@@ -97,7 +99,7 @@ class OM::XML::Terminology
           raise OM::XML::Terminology::BadPointerError, "You attempted to retrieve a TermBuilder using this pointer: #{args.inspect} but no TermBuilder exists at that location. Everything is fine until \"#{arg.inspect}\", which doesn't exist."
         end
       end
-      current_term
+      return current_term
     end
 
     # Add additional terms into this terminology
@@ -135,12 +137,12 @@ class OM::XML::Terminology
 
   # Returns true if the current terminology has a term defined at the location indicated by +pointers+ array
   def has_term?(*pointers)
-
+    begin
       retrieve_term(*OM.pointers_to_flat_array(pointers, false))
       return true
     rescue
       return false
-
+    end
   end
 
   # Returns the Term corresponding to the given _pointer_.
@@ -158,7 +160,7 @@ class OM::XML::Terminology
         end
       end
     end
-    current_term
+    return current_term
   end
 
   def retrieve_node_subsequent(args, context)
@@ -238,7 +240,7 @@ class OM::XML::Terminology
     end
 
     term = retrieve_term(*term_pointers)
-    term.xml_builder_template(extra_opts)
+    return term.xml_builder_template(extra_opts)
   end
 
   # Returns an array of Terms that have been marked as "root" terms
@@ -272,7 +274,7 @@ class OM::XML::Terminology
     end
     document = builder.doc
     terms.values.each {|term| term.to_xml(options,document.xpath("//terms").first)}
-    document
+    return document
   end
 
   def self.term_generic_name(*pointers)

data/lib/om/xml/terminology_based_solrizer.rb

@@ -0,0 +1,90 @@
+require 'solrizer'
+# This module is only suitable to mix into Classes that use the OM::XML::Document Module
+module OM::XML::TerminologyBasedSolrizer
+  def self.included(klass)
+    klass.send(:include, ::Solrizer::Common)
+    klass.send(:extend, ClassMethods)
+  end
+  
+  # Module Methods
+  module ClassMethods
+  
+    # Build a solr document from +doc+ based on its terminology
+    # @param [OM::XML::Document] doc  
+    # @param [Hash] (optional) solr_doc (values hash) to populate
+    def solrize(doc, solr_doc=Hash.new, field_mapper = nil)
+      unless doc.class.terminology.nil?
+        doc.class.terminology.terms.each_pair do |term_name,term|
+          doc.solrize_term(term, solr_doc, field_mapper)
+        end
+      end
+
+      return solr_doc
+    end
+    
+    # Populate a solr document with fields based on nodes in +xml+ 
+    # Values for a term are gathered by to +term_pointer+ using OM::XML::TermValueOperators.term_values 
+    # and are deserialized by OM according to :type, as determined in its terminology.
+    # The content of the actual field in solr is each +node+ of the +nodeset+ returned by OM,
+    # rendered to a string.
+    # @param [OM::XML::Document] doc xml document to extract values from
+    # @param [OM::XML::Term] term corresponding to desired xml values
+    # @param [Hash] (optional) solr_doc (values hash) to populate
+    def solrize_term(doc, term, solr_doc = Hash.new, field_mapper = nil, opts={})
+      parents = opts.fetch(:parents, [])
+      term_pointer = parents+[term.name]
+      nodeset = doc.term_values(*term_pointer)
+      
+      nodeset.each do |n|
+        doc.solrize_node(n, term_pointer, term, solr_doc, field_mapper)
+        unless term.kind_of? OM::XML::NamedTermProxy
+          term.children.each_pair do |child_term_name, child_term|
+            doc.solrize_term(child_term, solr_doc, field_mapper, opts={:parents=>parents+[{term.name=>nodeset.index(n)}]})
+          end
+        end
+      end
+      solr_doc
+    end
+
+    # Populate a solr document with solr fields corresponding to the given xml node
+    # Field names are generated using settings from the term in the +doc+'s terminology corresponding to +term_pointer+
+    # If the supplied term does not have an index_as attribute, no indexing will be performed.
+    # @param [Nokogiri::XML::Node] node to solrize
+    # @param [OM::XML::Document] doc document the node came from
+    # @param [Array] term_pointer Array pointing to the term that should be used for solrization settings
+    # @param [Term] term the term to be solrized
+    # @param [Hash] (optional) solr_doc (values hash) to populate
+    # @return [Hash] the solr doc
+    def solrize_node(node_value, doc, term_pointer, term, solr_doc = Hash.new, field_mapper = nil, opts = {})
+      return solr_doc unless term.index_as && !term.index_as.empty?
+      
+      generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
+      create_and_insert_terms(generic_field_name_base, node_value, term.index_as, solr_doc)
+      
+      if term_pointer.length > 1
+        hierarchical_field_name_base = OM::XML::Terminology.term_hierarchical_name(*term_pointer)
+        create_and_insert_terms(hierarchical_field_name_base, node_value, term.index_as, solr_doc)
+      end
+      solr_doc
+    end
+
+  end
+
+  
+  # Instance Methods
+  
+  attr_accessor :field_mapper
+  
+  def to_solr(solr_doc = Hash.new, field_mapper = self.field_mapper) # :nodoc:
+    self.class.solrize(self, solr_doc, field_mapper)
+  end
+  
+  def solrize_term(term, solr_doc = Hash.new, field_mapper = self.field_mapper, opts={})
+    self.class.solrize_term(self, term, solr_doc, field_mapper, opts)    
+  end
+  
+  def solrize_node(node, term_pointer, term, solr_doc = Hash.new, field_mapper = self.field_mapper, opts={})
+    self.class.solrize_node(node, self, term_pointer, term, solr_doc, field_mapper, opts)
+  end
+  
+end

data/lib/om/xml/validation.rb

@@ -1,60 +1,60 @@
 module OM::XML::Validation
   extend ActiveSupport::Concern
-
-  # 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 :schema_url
     attr_writer :schema_file
-
+    
     ##
     # Validation Support
     ##
-
+    
     # Validate the given document against the Schema provided by the root_property for this class
     def validate(doc)
       schema.validate(doc).each do |error|
           puts error.message
       end
     end
-
+    
     # Retrieve the Nokogiri Schema for this class
     def schema
       @schema ||= Nokogiri::XML::Schema(schema_file.read)
     end
-
+    
     # Retrieve the schema file for this class
     # If the schema file is not already set, it will be loaded from the schema url provided in the root_property configuration for the class
     def schema_file
       @schema_file ||= file_from_url(schema_url)
     end
-
+    
     # Retrieve file from a url (used by schema_file method to retrieve schema file from the schema url)
     def file_from_url( url )
       # parsed_url = URI.parse( url )
-      #
-      # if parsed_url.class != URI::HTTP
+      # 
+      # if parsed_url.class != URI::HTTP 
       #   raise "Invalid URL.  Could not parse #{url} as a HTTP url."
       # end
-
-
+      
+      begin
         file = open( url )
         return file
       rescue OpenURI::HTTPError => e
         raise "Could not retrieve file from #{url}. Error: #{e}"
-      rescue Exception => e
+      rescue Exception => e  
         raise "Could not retrieve file from #{url}. Error: #{e}"
-
+      end
     end
-
+    
     private :file_from_url
-
+    
   end
-
+  
   # Instance Methods -- These methods will be available on instances of classes that include this module
-
+  
   def validate
     self.class.validate(self)
   end
-
+    
 end

data/lib/om/xml/vocabulary.rb

@@ -1,15 +1,15 @@
 class OM::XML::Vocabulary
-
+  
   attr_accessor :builder
-  # Vocabularies are not editable once they've been created because inserting/removing/rearranging mappers in a vocabulary
+  # Vocabularies are not editable once they've been created because inserting/removing/rearranging mappers in a vocabulary 
   # will invalidate the xpath queries for an entire branch of the Vocabulary's tree of mappers.
   # If you want to change a vocabulary's structure, retrieve it's +builder+, make your changes, and re-generate the vocabulary.
-  #
+  # 
   # Ex:
   #   builder = vocabulary.builder
   #   builder.insert_mapper(:name_, :namePart)
   #   vocabulary = builder.build
-
+  
   # Mappers can be retrieved by their mapper name
   # Ex.
   # vocabulary.retrieve_mapper(:name_, :namePart)

data/lib/tasks/om.rake

@@ -6,18 +6,20 @@ end
 
 
 desc "Execute specs with coverage"
-task :coverage do
+task :coverage do 
   # Put spec opts in a file named .rspec in root
   ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
   ENV['COVERAGE'] = 'true' unless ruby_engine == 'jruby'
+
+
   Rake::Task['om:rspec'].invoke
 end
 
-namespace :om do
+namespace :om do    
 
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:rspec) do |spec|
-    if ENV['COVERAGE'] && RUBY_VERSION =~ /^1.8/
+    if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.8/
       spec.rcov = true
       spec.rcov_opts = %w{-I../../app -I../../lib --exclude spec\/*,gems\/*,ruby\/* --aggregate coverage.data}
     end
@@ -33,7 +35,7 @@ namespace :om do
     YARD::Rake::YardocTask.new(:doc) do |yt|
       readme_filename = 'README.textile'
       textile_docs = []
-      Dir[File.join(project_root, "*.textile")].each_with_index do |f, index|
+      Dir[File.join(project_root, "*.textile")].each_with_index do |f, index| 
         unless f.include?("/#{readme_filename}") # Skip readme, which is already built by the --readme option
           textile_docs << '-'
           textile_docs << f

data/om.gemspec

@@ -14,10 +14,11 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport'
   s.add_dependency 'activemodel'
+  s.add_dependency 'solrizer', '~> 3.0.0.pre8'
   s.add_dependency('nokogiri', ">= 1.4.2")
   s.add_dependency('mediashelf-loggable')
   s.add_dependency('deprecation')
-  s.add_development_dependency "rspec", "~> 2.99"
+  s.add_development_dependency "rspec", "~> 2.0"
   s.add_development_dependency "rake"
   s.add_development_dependency "rdoc"
   s.add_development_dependency "awesome_print"

data/spec/fixtures/mods_article.rb

@@ -0,0 +1,90 @@
+module Samples
+  class 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")
+
+
+      t.title_info(:path=>"titleInfo") {
+        t.main_title(:index_as=>[:facetable],:path=>"title", :label=>"title") {
+          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, :stored_searchable],:path=>{:attribute=>"lang"})
+      } 
+      t.language{
+        t.lang_code(:index_as=>[:facetable], :path=>"languageTerm", :attributes=>{:type=>"code"})
+      }
+      t.abstract(:index_as=>[:stored_searchable])
+      t.subject {
+        t.topic(:index_as=>[:facetable])
+      }      
+      t.topic_tag(:proxy=>[:subject, :topic], :index_as=>[:stored_searchable])    
+      # 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_ {
+        # this is a namepart
+        t.namePart(:type=>:string, :label=>"generic name")
+        # affiliations are great
+        t.affiliation
+        t.institution(:path=>"affiliation", :index_as=>[:facetable], :label=>"organization")
+        t.displayForm
+        t.role(:ref=>[:role])
+        t.description(:index_as=>[:facetable])
+        t.date(:path=>"namePart", :attributes=>{:type=>"date"})
+        t.last_name(:path=>"namePart", :attributes=>{:type=>"family"}, :index_as=>[:stored_searchable])
+        t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+        t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        t.computing_id
+        t.name_content(:path=>"text()")
+      }
+      # 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])
+      t.conference(:ref=>:name, :attributes=>{:type=>"conference"}, :index_as=>[:facetable])
+      t.role {
+        t.text(:path=>"roleTerm",:attributes=>{:type=>"text"}, :index_as=>[:stored_searchable])
+        t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
+      }
+      t.journal(:path=>'relatedItem', :attributes=>{:type=>"host"}) {
+        t.title_info(:index_as=>[:facetable],:ref=>[:title_info])
+        t.origin_info(:path=>"originInfo") {
+          t.publisher
+          t.date_issued(:path=>"dateIssued", :type => :date, :index_as => [:stored_searchable])
+          t.issuance(:index_as=>[:facetable])
+        }
+        t.issn(:path=>"identifier", :attributes=>{:type=>"issn"})
+        t.issue(:path=>"part") {
+          t.volume(:path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+          t.level(:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number")
+          t.extent
+          t.pages(:path=>"extent", :attributes=>{:unit=>"pages"}) {
+            t.start
+            t.end
+          }
+          t.start_page(:proxy=>[:pages, :start])
+          t.end_page(:proxy=>[:pages, :end])
+          t.publication_date(:path=>"date", :type => :date, :index_as => [:stored_searchable])
+        }
+      }
+      t.note
+      t.location(:path=>"location") {
+        t.url(:path=>"url")
+      }
+      t.publication_url(:proxy=>[:location,:url])
+      t.title(:proxy=>[:title_info, :main_title])
+      t.journal_title(:proxy=>[:journal, :title_info, :main_title])
+      t.pub_date(:proxy=>[:journal, :issue, :publication_date])
+      t.issue_date(:ref=>[:journal, :origin_info, :date_issued], :type=> :date)
+    end
+    
+    # Changes from OM::Properties implementation
+    # renamed family_name => last_name
+    # start_page & end_page now accessible as [:journal, :issue, :pages, :start] (etc.)
+
+  end
+end

data/spec/fixtures/mods_articles/hydrangea_article1.xml

@@ -71,7 +71,7 @@
         </titleInfo>
         <originInfo>
             <publisher>PUBLISHER</publisher>
-            <dateIssued>DATE</dateIssued>
+            <dateIssued>2007-02-15</dateIssued>
         </originInfo>
         <identifier type="issn">0013-8908</identifier>    
         <part>
@@ -84,7 +84,7 @@
             <extent unit="pages">
                 <start>195</start>
             </extent>
-            <date>FEB. 2007</date>
+            <date>2007-02-01</date>
         </part>            
     </relatedItem>
 

data/spec/integration/differentiated_elements_spec.rb

@@ -30,10 +30,10 @@ describe "use the root element as a member of the proxy address" do
   end
 
   it "should pull out all occurences of the_thing_we_want in the relevant_container" do
-    expect(subject.relevant_container.the_thing_we_want).to eq(["1", "2"])
+    subject.relevant_container.the_thing_we_want.should == ["1", "2"]
   end
 
   it "should only pull out the_thing_we_want at the root level" do
-    expect(subject.the_thing_we_want).to eq(["2"])
+    subject.the_thing_we_want.should == ["2"]
   end
 end

data/spec/integration/element_value_spec.rb

@@ -53,39 +53,39 @@ EOF
 end
 
   it "should handle single-element terms correctly" do
-    expect(subject.elementA).to eq(["valA"])
+    subject.elementA.should == ["valA"]
   end
 
   it "should handle term paths" do
-    expect(subject.elC).to eq(["valC"])
+    subject.elC.should == ["valC"]
   end
 
   it "should handle multiple-element, terms with paths correctly" do
-    expect(subject.elB).to eq(["valB1", "valB2"])
+    subject.elB.should == ["valB1", "valB2"]
   end
 
   it "should handle terms that require specific attributes" do
-    expect(subject.elementC).to eq(["valC"])
+    subject.elementC.should == ["valC"]
   end
 
   it "should handle" do
-    expect(subject.here.length).to eq(1)
-    expect(subject.here.first.split(/\W/)).to include('123', '456')
+    subject.here.length.should == 1
+    subject.here.first.split(/\W/).should include('123', '456')
   end
 
   it "should handle missing terms" do
-    expect(subject.there).to be_empty
+    subject.there.should be_empty
   end
 
   it "should handle element  value given the absence of a specific attribute" do
-    expect(subject.elementD).to eq(["valD1"])
-    expect(subject.no_attrib).to eq(["valB1"])
+    subject.elementD.should == ["valD1"]
+    subject.no_attrib.should == ["valB1"]
   end
 
   it "should handle OM terms for an attribute value" do
-    expect(subject.elementB.my_attr).to eq(["vole"])
-    expect(subject.alternate).to eq(["vole"])
-    expect(subject.another).to eq(["vole"])
-    expect(subject.animal_attrib).to include("vole", "seagull")
+    subject.elementB.my_attr.should == ["vole"]
+    subject.alternate.should == ["vole"]
+    subject.another.should == ["vole"]
+    subject.animal_attrib.should include("vole", "seagull")
   end
 end