hydra-pbcore 0.0.2 → 0.0.3

data/lib/hydra-pbcore/datastream/instantiation.rb

@@ -2,90 +2,140 @@ module HydraPbcore::Datastream
 class Instantiation < ActiveFedora::NokogiriDatastream
 
   include HydraPbcore::Methods
+  include HydraPbcore::Templates
 
   # Note: this is not a complete PBCore document, just an instantiation node
   set_terminology do |t|
-    t.root(:path=>"pbcoreDescriptionDocument", :xmlns => '', :namespace_prefix=>nil)
-
-    t.pbcoreInstantiation(:namespace_prefix=>nil) {
-
-      t.instantiationIdentifier(:namespace_prefix=>nil, :attributes=>{ :annotation=>"Filename", :source=>"Rock and Roll Hall of Fame and Museum" })
-      t.instantiationDate(:namespace_prefix=>nil, :attributes=>{ :dateType=>"created" })
-      t.instantiationDigital(:namespace_prefix=>nil, :attributes=>{ :source=>"EBU file formats" })
-      t.instantiationStandard(:namespace_prefix=>nil)
-      t.instantiationLocation(:namespace_prefix=>nil)
-      t.instantiationGenerations(:namespace_prefix=>nil, :attributes=>{ :source=>"PBCore instantiationGenerations" })
-      t.instantiationFileSize(:namespace_prefix=>nil) {
-        t.units(:path=>{:attribute=>"unitsOfMeasure"}, :namespace_prefix=>nil)
-      }
-      t.instantiationColors(:namespace_prefix=>nil, :attributes=>{ :source=>"PBCore instantiationColors" })
-      t.instantiationMediaType(:namespace_prefix=>nil, :attributes=>{ :source=>"PBCore instantiationMediaType" })
-      t.instantiationLanguage(:namespace_prefix=>nil, :attributes=>{ :source=>"ISO 639.2", :ref=>"http://www.loc.gov/standards/iso639-2/php/code_list.php" })
-      t.instantiationDuration(:namespace_prefix=>nil)
+    t.root(:path=>"pbcoreDescriptionDocument")
 
-      t.instantiationRights(:namespace_prefix=>nil) {
-        t.rightsSummary(:namespace_prefix=>nil)
-      }
+    t.pbcoreInstantiation do
 
-      t.instantiationEssenceTrack(:namespace_prefix=>nil) {
-        t.essenceTrackStandard(:namespace_prefix=>nil)
-        t.essenceTrackEncoding( :namespace_prefix=>nil, :attributes=>{ :source=>"PBCore essenceTrackEncoding" })
-        t.essenceTrackDataRate(:namespace_prefix=>nil) {
-          t.units(:path=>{:attribute=>"unitsOfMeasure"}, :namespace_prefix=>nil)
-        }
-        t.essenceTrackFrameRate(:namespace_prefix=>nil, :attributes=>{ :unitsOfMeasure=>"fps" })
-        t.essenceTrackFrameSize(:namespace_prefix=>nil, :attributes=>{ :source=>"PBCore essenceTrackFrameSize" })
-        t.essenceTrackBitDepth(:namespace_prefix=>nil)
-        t.essenceTrackAspectRatio(:namespace_prefix=>nil, :attributes=>{ :source=>"PBCore essenceTrackAspectRatio" })
-        t.essenceTrackSamplingRate(:namespace_prefix=>nil) {
-          t.units(:path=>{:attribute=>"unitsOfMeasure"}, :namespace_prefix=>nil)
-        }
-        t.essenceTrackAnnotation( :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Number of Audio Channels" })
-      }
+      t.instantiationIdentifier(
+        :attributes=>{
+          :annotation=>"Filename",
+          :source=>"Rock and Roll Hall of Fame and Museum"
+        },
+        :index_as => [:displayable]
+      )
+      t.instantiationDate(:attributes=>{ :dateType=>"created" },
+        :index_as => [:displayable, :searchable]
+      )
+      t.instantiationDigital(:attributes=>{ :source=>"EBU file formats" },
+        :index_as => [:searchable, :facetable]
+      )
+      t.instantiationStandard(:index_as => [:displayable])
+      t.instantiationLocation(:index_as => [:displayable])
+      t.instantiationGenerations(:attributes=>{ :source=>"PBCore instantiationGenerations" },
+        :index_as => [:displayable]  
+      )
+      t.instantiationFileSize(:index_as => [:displayable]) do
+        t.units(:path=>{:attribute=>"unitsOfMeasure"}, :index_as => [:displayable])
+      end
+      t.instantiationColors(:attributes=>{ :source=>"PBCore instantiationColors" },
+        :index_as => [:displayable]
+      )
+      t.instantiationMediaType(:attributes=>{ :source=>"PBCore instantiationMediaType" },
+        :index_as => [:facetable]
+      )
+      t.instantiationLanguage(
+        :attributes=>{
+          :source=>"ISO 639.2",
+          :ref=>"http://www.loc.gov/standards/iso639-2/php/code_list.php"
+        },
+        :index_as => [:searchable]
+      )
+      t.instantiationDuration(:index_as => [:displayable])
+
+      t.instantiationRights do
+        t.rightsSummary(:index_as => [:displayable])
+      end
+
+      t.instantiationEssenceTrack do
+        t.essenceTrackStandard(:index_as => [:displayable])
+        t.essenceTrackEncoding( :attributes=>{ :source=>"PBCore essenceTrackEncoding" },
+          :index_as => [:displayable]
+        )
+        t.essenceTrackDataRate(:index_as => [:displayable]) do
+          t.units(:path=>{:attribute=>"unitsOfMeasure"}, :index_as => [:displayable])
+        end
+        t.essenceTrackFrameRate(:attributes=>{ :unitsOfMeasure=>"fps" }, :index_as => [:displayable])
+        t.essenceTrackFrameSize(:attributes=>{ :source=>"PBCore essenceTrackFrameSize" }, :index_as => [:displayable])
+        t.essenceTrackBitDepth(:index_as => [:displayable])
+        t.essenceTrackAspectRatio(:attributes=>{ :source=>"PBCore essenceTrackAspectRatio" },
+          :index_as => [:displayable]
+        )
+        t.essenceTrackSamplingRate(:index_as => [:displayable]) do
+          t.units(:path=>{:attribute=>"unitsOfMeasure"}, :index_as => [:displayable])
+        end
+        t.essenceTrackAnnotation( :attributes=>{ :annotationType=>"Number of Audio Channels" },
+          :index_as => [:displayable]
+        )
+      end
       t.video_essence(:ref => [:pbcoreInstantiation, :instantiationEssenceTrack],
-        :path=>'instantiationEssenceTrack[essenceTrackType="Video"]',
-        :namespace_prefix=>nil
+        :path=>'instantiationEssenceTrack[essenceTrackType="Video"]'
       )
       t.audio_essence(:ref => [:pbcoreInstantiation, :instantiationEssenceTrack],
-        :path=>'instantiationEssenceTrack[essenceTrackType="Audio"]',
-        :namespace_prefix=>nil
+        :path=>'instantiationEssenceTrack[essenceTrackType="Audio"]'
       )
 
-      t.instantiationRelation(:namespace_prefix=>nil) {
-        t.instantiationRelationIdentifier(:namespace_prefix=>nil, :attributes=>{ :source=>"Rock and Roll Hall of Fame and Museum" })
-      }
+      t.instantiationRelation do
+        t.instantiationRelationIdentifier(:attributes=>{ :source=>"Rock and Roll Hall of Fame and Museum" })
+      end
       # The file we're describing at the root of this document preceeds the file marked "next"
       t.next_inst(:ref => [:pbcoreInstantiation, :instantiationRelation],
-      :path=>'instantiationRelation[instantiationRelationType="Precedes in Sequence"]',
-      :namespace_prefix=>nil
+        :path=>'instantiationRelation[instantiationRelationType="Precedes in Sequence"]'
       )
       # The file we're describing at the root of this document comes after the file marked "previous"
       t.previous_inst(:ref => [:pbcoreInstantiation, :instantiationRelation],
-      :path=>'instantiationRelation[instantiationRelationType="Follows in Sequence"]',
-      :namespace_prefix=>nil
+        :path=>'instantiationRelation[instantiationRelationType="Follows in Sequence"]'
       )
 
       # Instantitation annotiations
-      t.inst_chksum_type(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Checksum Type" })
-      t.inst_chksum_value(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Checksum Value" })
-      t.inst_device(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Playback Device" })
-      t.inst_capture_soft(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Capture Software" })
-      t.inst_trans_soft(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Transcoding Software" })
-      t.inst_operator(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Operator" })
-      t.inst_trans_note(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Transfer Notes" })
-      t.inst_vendor(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Vendor Name" })
-      t.inst_cond_note(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Condition Notes" })
-      t.inst_clean_note(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Cleaning Notes" })
-      t.inst_note(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Notes" })
-      t.inst_color_space(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Color Space" })
-      t.inst_chroma(:path=>"instantiationAnnotation", :namespace_prefix=>nil, :attributes=>{ :annotationType=>"Chroma" })
-
-    }
+      t.inst_chksum_type(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Checksum Type" },
+        :index_as => [:displayable]
+      )
+      t.inst_chksum_value(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Checksum Value" },
+        :index_as => [:displayable]
+      )
+      t.inst_device(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Playback Device" },
+        :index_as => [:displayable]
+      )
+      t.inst_capture_soft(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Capture Software" },
+        :index_as => [:displayable]
+      )
+      t.inst_trans_soft(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Transcoding Software" },
+        :index_as => [:displayable]
+      )
+      t.inst_operator(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Operator" },
+        :index_as => [:displayable]
+      )
+      t.inst_trans_note(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Transfer Notes" },
+        :index_as => [:displayable]
+      )
+      t.inst_vendor(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Vendor Name" },
+        :index_as => [:displayable]
+      )
+      t.inst_cond_note(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Condition Notes" },
+        :index_as => [:displayable]
+      )
+      t.inst_clean_note(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Cleaning Notes" },
+        :index_as => [:displayable]
+      )
+      t.inst_note(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Notes" },
+        :index_as => [:displayable]
+      )
+      t.inst_color_space(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Color Space" },
+        :index_as => [:displayable]
+      )
+      t.inst_chroma(:path=>"instantiationAnnotation", :attributes=>{ :annotationType=>"Chroma" },
+        :index_as => [:displayable]
+      )
+
+    end
 
     #
     # Here are the actual references to the fields
     #
-
     t.name(:proxy=>[:pbcoreInstantiation, :instantiationIdentifier])
     t.location(:proxy=>[:pbcoreInstantiation, :instantiationLocation])
     t.date(:proxy=>[:pbcoreInstantiation, :instantiationDate])

data/lib/hydra-pbcore/methods.rb

@@ -1,94 +1,8 @@
 module HydraPbcore::Methods
 
-  # Module for inserting different types of PBcore xml nodes into
-  # an existing PBcore document
-
-  module ClassMethods
-
-    def publisher_template(opts={})
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.pbcorePublisher {
-          xml.publisher
-          xml.publisherRole(:source=>"PBCore publisherRole")
-        }
-      end
-      return builder.doc.root
-    end
-
-    def contributor_template(opts={})
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.pbcoreContributor {
-          xml.contributor
-          xml.contributorRole(:source=>"MARC relator terms")
-        }
-      end
-      return builder.doc.root
-    end
-
-    def previous_template(opts={})
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.instantiationRelation {
-          xml.instantiationRelationType(:annotation=>"One of a multi-part instantiation") {
-            xml.text "Follows in Sequence"
-          }
-          xml.instantiationRelationIdentifier(:source=>"Rock and Roll Hall of Fame and Museum")
-        }
-      end
-      return builder.doc.root
-    end
-
-    def next_template(opts={})
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.instantiationRelation {
-          xml.instantiationRelationType(:annotation=>"One of a multi-part instantiation") {
-            xml.text "Precedes in Sequence"
-          }
-          xml.instantiationRelationIdentifier(:source=>"Rock and Roll Hall of Fame and Museum")
-        }
-      end
-      return builder.doc.root
-    end
-
- end
-
-  def self.included(klass)
-    klass.extend(ClassMethods)
-  end
-
-  def insert_node(type, opts={})
-
-    unless self.class.respond_to?("#{type}_template".to_sym)
-      raise "No XML template is defined for a PBcore node of type #{type}."
-    end
-
-    node = self.class.send("#{type}_template".to_sym)
-    nodeset = self.find_by_terms(type.to_sym)
-
-    unless nodeset.nil?
-      if nodeset.empty?
-        if opts[:root]
-          self.find_by_terms(opts[:root].to_sym).first.add_child(node)
-        else
-          self.ng_xml.root.add_child(node)
-        end
-        index = 0
-      else
-        nodeset.after(node)
-        index = nodeset.length
-      end
-      self.dirty = true
-    end
-
-    return node, index
-
-  end
 
   def remove_node(type, index)
-    if type == "education" or type == "television"
-      self.find_by_terms(type.to_sym).slice(index.to_i).parent.remove
-    else
-      self.find_by_terms(type.to_sym).slice(index.to_i).remove
-    end
+    self.find_by_terms(type.to_sym).slice(index.to_i).remove
     self.dirty = true
   end
 

data/lib/hydra-pbcore/templates.rb

@@ -0,0 +1,58 @@
+module HydraPbcore::Templates
+  extend ActiveSupport::Concern
+
+  included do
+    class_eval do
+
+      define_template :publisher do |xml, publisher, role|
+        xml.pbcorePublisher {
+          xml.publisher(publisher)
+          xml.publisherRole(role, :source=>"PBCore publisherRole")
+        }
+      end
+
+      define_template :contributor do |xml, author, role|
+        xml.pbcoreContributor {
+          xml.contributor(author)
+          xml.contributorRole(role, :source=>"MARC relator terms") 
+        }
+      end
+
+      define_template :previous do |xml, pid|
+        xml.instantiationRelation {
+          xml.instantiationRelationType(:annotation=>"One of a multi-part instantiation") {
+            xml.text "Follows in Sequence"
+          }
+          xml.instantiationRelationIdentifier(pid, :source=>"Rock and Roll Hall of Fame and Museum")
+        }
+      end
+
+      define_template :next do |xml, pid|
+        xml.instantiationRelation {
+          xml.instantiationRelationType(:annotation=>"One of a multi-part instantiation") {
+            xml.text "Precedes in Sequence"
+          }
+          xml.instantiationRelationIdentifier(pid, :source=>"Rock and Roll Hall of Fame and Museum")
+        }
+      end
+
+    end
+  end
+
+  def insert_contributor(author=nil, role=nil)
+    add_child_node(ng_xml.root, :contributor, author, role)
+  end
+
+  def insert_publisher(publisher=nil, role=nil)
+    add_child_node(ng_xml.root, :publisher, publisher, role)
+  end
+
+  def insert_next(pid)
+    add_child_node(find_by_terms(:pbcoreInstantiation).first, :next, pid)
+  end
+
+  def insert_previous(pid)
+    add_child_node(find_by_terms(:pbcoreInstantiation).first, :previous, pid)
+  end
+
+end

data/lib/hydra-pbcore/version.rb

@@ -0,0 +1,3 @@
+module HydraPbcore
+  VERSION = "0.0.3"
+end

data/spec/custom_mapper_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Solrizer::FieldMapper::Default do
+
+  describe "#pbcore_date" do
+
+    it "should return valid dates from only partial ones" do
+      Solrizer::FieldMapper::Default.pbcore_date('2003').should    == "2003-01-01"
+      Solrizer::FieldMapper::Default.pbcore_date('2009-07').should == "2009-07-01"
+    end
+
+  end
+
+end

data/spec/digital_document_spec.rb

@@ -29,7 +29,6 @@ describe HydraPbcore::Datastream::DigitalDocument do
         [:lc_subject_genre],
         [:event_series],
         [:event_place],
-        [:event_date],
         [:contributor_name],
         [:contributor_role],
         [:publisher_name],
@@ -49,8 +48,8 @@ describe HydraPbcore::Datastream::DigitalDocument do
     end
 
     it "should work for fields that require added xml nodes" do
-      @object_ds.insert_node("publisher")
-      @object_ds.insert_node("contributor")
+      @object_ds.insert_publisher
+      @object_ds.insert_contributor
       [
         [:publisher_name],
         [:publisher_role],
@@ -65,8 +64,8 @@ describe HydraPbcore::Datastream::DigitalDocument do
     end
 
     it "should differentiate between multiple added nodes" do
-      @object_ds.insert_node(:contributor)
-      @object_ds.insert_node(:contributor)
+      @object_ds.insert_contributor
+      @object_ds.insert_contributor
       @object_ds.update_indexed_attributes( {[:contributor_name] => { 0 => "first contributor" }} )
       @object_ds.update_indexed_attributes( {[:contributor_name] => { 1 => "second contributor" }} )
       @object_ds.update_indexed_attributes( {[:contributor_role] => { 0 => "first contributor role" }} )
@@ -83,10 +82,10 @@ describe HydraPbcore::Datastream::DigitalDocument do
   describe "#xml_template" do
     it "should return an empty xml document matching a valid exmplar" do
       # insert additional nodes
-      @object_ds.insert_node("publisher")
-      @object_ds.insert_node("contributor")
-      @object_ds.insert_node("publisher")
-      @object_ds.insert_node("contributor")
+      @object_ds.insert_publisher
+      @object_ds.insert_contributor
+      @object_ds.insert_publisher
+      @object_ds.insert_contributor
 
       # update additional nodes that OM will insert automatically
       @object_ds.update_indexed_attributes({ [:alternative_title] => { 0 => "inserted" }} )
@@ -128,6 +127,7 @@ describe HydraPbcore::Datastream::DigitalDocument do
 
   describe ".insert_node" do
     it "should return a node and index for a given template type" do
+      pending "Don't need this?"
       ["publisher", "contributor"].each do |type|
         node, index = @object_ds.insert_node(type.to_s)
         index.should == 0
@@ -145,8 +145,8 @@ describe HydraPbcore::Datastream::DigitalDocument do
   describe ".remove_node" do
     it "should remove a node a given type and index" do
       ["publisher", "contributor"].each do |type|
-        @object_ds.insert_node(type.to_sym)
-        @object_ds.insert_node(type.to_sym)
+        @object_ds.send("insert_"+type)
+        @object_ds.send("insert_"+type)
         @object_ds.find_by_terms(type.to_sym).count.should == 2
         @object_ds.remove_node(type.to_sym, "1")
         @object_ds.find_by_terms(type.to_sym).count.should == 1
@@ -166,4 +166,86 @@ describe HydraPbcore::Datastream::DigitalDocument do
 
   end
 
+  describe ".to_solr" do
+
+    before(:each) do
+      # insert additional nodes
+      @object_ds.insert_publisher
+      @object_ds.insert_contributor
+      [
+        "pbc_id",
+        "main_title",
+        "alternative_title",
+        "chapter",
+        "episode",
+        "label",
+        "segment",
+        "subtitle",
+        "track",
+        "translation",
+        "summary",
+        "parts_list",
+        "lc_subject",
+        "lc_name",
+        "rh_subject",
+        "getty_genre",
+        "lc_genre",
+        "lc_subject_genre",
+        "event_series",
+        "event_place",
+        "contributor_name",
+        "contributor_role",
+        "publisher_name",
+        "publisher_role",
+        "note",
+        "archival_collection",
+        "archival_series",
+        "collection_number",
+        "accession_number",
+        "usage"
+      ].each do |field|
+        @object_ds.send("#{field}=".to_sym, field)
+      end
+      # update additional nodes that OM will insert automatically
+      @object_ds.update_indexed_attributes({ [:alternative_title] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:chapter] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:episode] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:label] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:segment] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:subtitle] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:track] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:translation] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:lc_subject] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:lc_name] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:rh_subject] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:getty_genre] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:lc_genre] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:lc_subject_genre] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:subject] => { 0 => "inserted" }} )
+      @object_ds.update_indexed_attributes({ [:genre] => { 0 => "inserted" }} )
+
+      # Use ISO 8601 dates
+      @object_ds.event_date = "2012-11-11"
+    end
+
+    it "should match an exmplar" do
+      # Load example fixture
+      f = fixture "pbcore_solr_digital_document_template.xml"
+      ref_node = Nokogiri::XML(f)
+      f.close
+
+      # Nokogiri-fy our sample document
+      sample_node = Nokogiri::XML(@object_ds.to_solr.to_xml)
+
+      # Save this for later...
+      out = File.new("tmp/pbcore_solr_digital_document_sample.xml", "w")
+      out.write(sample_node.to_s)
+      out.close
+
+      EquivalentXml.equivalent?(ref_node, sample_node, opts = { :element_order => false, :normalize_whitespace => true }).should be_true
+    end
+
+
+  end
+
 end