dor-services 5.2.0 → 5.3.0

data/lib/dor/models/eventable.rb

@@ -5,8 +5,8 @@ module Dor
       has_metadata :name => 'events', :type => Dor::EventsDS, :label => 'Events'
     end
 
-    def add_event *args
-      self.datastreams['events'].add_event *args
+    def add_event(*args)
+      datastreams['events'].add_event *args
     end
   end
 end

data/lib/dor/models/geoable.rb

@@ -13,16 +13,16 @@ module Dor
 
     # @return [String, nil] XML
     def fetch_geoMetadata_datastream
-      candidates = self.datastreams['identityMetadata'].otherId.collect { |oid| oid.to_s }
+      candidates = datastreams['identityMetadata'].otherId.collect { |oid| oid.to_s }
       metadata_id = Dor::MetadataService.resolvable(candidates).first
       return nil if metadata_id.nil?
-      return Dor::MetadataService.fetch(metadata_id.to_s)
+      Dor::MetadataService.fetch(metadata_id.to_s)
     end
 
     def build_geoMetadata_datastream(ds)
       content = fetch_geoMetadata_datastream
       return nil if content.nil?
-      ds.dsLabel = self.label
+      ds.dsLabel = label
       ds.ng_xml = Nokogiri::XML(content)
       ds.ng_xml.normalize_text!
       ds.content = ds.ng_xml.to_xml

data/lib/dor/models/governable.rb

@@ -4,20 +4,20 @@ module Dor
     include Rightsable
 
     included do
-      belongs_to :admin_policy_object, :property => :is_governed_by, :class_name => "Dor::AdminPolicyObject"
-      has_and_belongs_to_many :collections, :property => :is_member_of_collection, :class_name => "Dor::Collection"
-      has_and_belongs_to_many :sets, :property => :is_member_of, :class_name => "Dor::Collection"
+      belongs_to :admin_policy_object, :property => :is_governed_by, :class_name => 'Dor::AdminPolicyObject'
+      has_and_belongs_to_many :collections, :property => :is_member_of_collection, :class_name => 'Dor::Collection'
+      has_and_belongs_to_many :sets, :property => :is_member_of, :class_name => 'Dor::Collection'
     end
 
     def initiate_apo_workflow(name)
-      self.initialize_workflow(name, !self.new_object?)
+      initialize_workflow(name, !self.new_object?)
     end
 
     # Returns the default lane_id from the item's APO.  Will return 'default' if the item does not have
     #   and APO, or if the APO does not have a default_lane
     # @return [String] the lane id
     def default_workflow_lane
-      return 'default' if self.admin_policy_object.nil?  # TODO log warning?
+      return 'default' if admin_policy_object.nil?  # TODO: log warning?
 
       admin_md = admin_policy_object.datastreams['administrativeMetadata']
       return 'default' unless admin_md.respond_to? :default_workflow_lane
@@ -27,11 +27,11 @@ module Dor
     end
 
     def reset_to_apo_default
-      self.rightsMetadata.content = admin_policy_object.rightsMetadata.ng_xml
+      rightsMetadata.content = admin_policy_object.rightsMetadata.ng_xml
     end
 
     def set_read_rights(rights)
-      self.rightsMetadata.set_read_rights(rights)
+      rightsMetadata.set_read_rights(rights)
     end
 
     def add_collection(collection_or_druid)
@@ -41,12 +41,11 @@ module Dor
         when Dor::Collection
           collection_or_druid
       end
-      self.collections << collection
-      self.sets << collection
+      collections << collection
+      sets << collection
     end
 
     def remove_collection(collection_or_druid)
-
       collection = case collection_or_druid
         when String
           Dor::Collection.find(collection_or_druid)
@@ -54,17 +53,17 @@ module Dor
           collection_or_druid
       end
 
-      self.collections.delete(collection)
-      self.sets.delete(collection)
+      collections.delete(collection)
+      sets.delete(collection)
     end
-    #set the rights metadata datastream to the content of the APO's default object rights
+    # set the rights metadata datastream to the content of the APO's default object rights
     def reapplyAdminPolicyObjectDefaults
-      rightsMetadata.content=admin_policy_object.datastreams['defaultObjectRights'].content
+      rightsMetadata.content = admin_policy_object.datastreams['defaultObjectRights'].content
     end
     def rights
       return nil unless self.respond_to? :rightsMetadata
-      return nil if self.rightsMetadata.nil?
-      xml = self.rightsMetadata.ng_xml
+      return nil if rightsMetadata.nil?
+      xml = rightsMetadata.ng_xml
       return nil if xml.search('//rightsMetadata').length != 1      # ORLY?
       if xml.search('//rightsMetadata/access[@type=\'read\']/machine/group').length == 1
         'Stanford'
@@ -100,31 +99,31 @@ module Dor
     def groups_which_view_metadata
       ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor', 'dor-viewer', 'sdr-viewer']
     end
-    def intersect arr1, arr2
-      return (arr1 & arr2).length > 0
+    def intersect(arr1, arr2)
+      (arr1 & arr2).length > 0
     end
-    def can_manage_item? roles
+    def can_manage_item?(roles)
       intersect roles, groups_which_manage_item
     end
-    def can_manage_desc_metadata? roles
+    def can_manage_desc_metadata?(roles)
       intersect roles, groups_which_manage_desc_metadata
     end
-    def can_manage_system_metadata? roles
+    def can_manage_system_metadata?(roles)
       intersect roles, groups_which_manage_system_metadata
     end
-    def can_manage_content? roles
+    def can_manage_content?(roles)
       intersect roles, groups_which_manage_content
     end
-    def can_manage_rights? roles
+    def can_manage_rights?(roles)
       intersect roles, groups_which_manage_rights
     end
-    def can_manage_embargo? roles
+    def can_manage_embargo?(roles)
       intersect roles, groups_which_manage_embargo
     end
-    def can_view_content? roles
+    def can_view_content?(roles)
       intersect roles, groups_which_view_content
     end
-    def can_view_metadata? roles
+    def can_view_metadata?(roles)
       intersect roles, groups_which_view_metadata
     end
   end

data/lib/dor/models/identifiable.rb

@@ -6,39 +6,39 @@ module Dor
     include Upgradable
 
     included do
-      has_metadata :name => "DC", :type => SimpleDublinCoreDs, :label => 'Dublin Core Record for self object'
-      has_metadata :name => "identityMetadata", :type => Dor::IdentityMetadataDS, :label => 'Identity Metadata'
+      has_metadata :name => 'DC', :type => SimpleDublinCoreDs, :label => 'Dublin Core Record for self object'
+      has_metadata :name => 'identityMetadata', :type => Dor::IdentityMetadataDS, :label => 'Identity Metadata'
     end
 
     module ClassMethods
       attr_reader :object_type
-      def has_object_type str
+      def has_object_type(str)
         @object_type = str
         Dor.registered_classes[str] = self
       end
     end
 
-    def initialize attrs={}
+    def initialize(attrs = {})
       if Dor::Config.suri.mint_ids && !attrs[:pid]
-        attrs = attrs.merge!({:pid=>Dor::SuriService.mint_id, :new_object => true})
+        attrs = attrs.merge!({:pid => Dor::SuriService.mint_id, :new_object => true})
       end
       super
     end
 
     # helper method to get the tags as an array
     def tags
-      self.identityMetadata.tag
+      identityMetadata.tag
     end
 
     # helper method to get just the content type tag
     def content_type_tag
-      content_tag=tags.select {|tag| tag.include?('Process : Content Type')}
-      content_tag.size == 1 ? content_tag[0].split(':').last.strip : ""
+      content_tag = tags.select {|tag| tag.include?('Process : Content Type')}
+      content_tag.size == 1 ? content_tag[0].split(':').last.strip : ''
     end
 
     # Syntactic sugar for identifying applied DOR Concerns
     # e.g., obj.is_identifiable? is the same as obj.is_a?(Dor::Identifiable)
-    def method_missing sym, *args
+    def method_missing(sym, *args)
       if sym.to_s =~ /^is_(.+)\?$/
         begin
           klass = Dor.const_get $1.capitalize.to_sym
@@ -53,11 +53,11 @@ module Dor
 
     ## Module-level variables, shared between ALL mixin includers (and ALL *their* includers/extenders)!
     ## used for caching found values
-    @@collection_hash={}
-    @@apo_hash={}
+    @@collection_hash = {}
+    @@apo_hash = {}
 
-    def to_solr(solr_doc=Hash.new, *args)
-      self.assert_content_model
+    def to_solr(solr_doc = {}, *args)
+      assert_content_model
       super(solr_doc, *args)
 
       solr_doc[Dor::INDEX_VERSION_FIELD] = Dor::VERSION
@@ -66,24 +66,24 @@ module Dor
         add_solr_value(solr_doc, 'ds_specs', ds.datastream_spec_string, :string, [:symbol]) unless ds.new?
       end
 
-      add_solr_value(solr_doc, 'title_sort', self.label, :string, [:stored_sortable])
+      add_solr_value(solr_doc, 'title_sort', label, :string, [:stored_sortable])
 
-      rels_doc = Nokogiri::XML(self.datastreams['RELS-EXT'].content)
+      rels_doc = Nokogiri::XML(datastreams['RELS-EXT'].content)
       apos = rels_doc.search('//rdf:RDF/rdf:Description/hydra:isGovernedBy', 'hydra' => 'http://projecthydra.org/ns/relations#', 'fedora' => 'info:fedora/fedora-system:def/relations-external#', 'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
       collections = rels_doc.search('//rdf:RDF/rdf:Description/fedora:isMemberOfCollection', 'fedora' => 'info:fedora/fedora-system:def/relations-external#', 'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
-      solrize_related_obj_titles(solr_doc, apos, @@apo_hash, "apo_title")
-      solrize_related_obj_titles(solr_doc, collections, @@collection_hash, "collection_title")
+      solrize_related_obj_titles(solr_doc, apos, @@apo_hash, 'apo_title', 'nonhydrus_apo_title', 'hydrus_apo_title')
+      solrize_related_obj_titles(solr_doc, collections, @@collection_hash, 'collection_title', 'nonhydrus_collection_title', 'hydrus_collection_title')
 
-      solr_doc["metadata_source_ssi"] = self.identity_metadata_source
-      return solr_doc
+      solr_doc['metadata_source_ssi'] = identity_metadata_source
+      solr_doc
     end
 
     # @return [String] calculated value for Solr index
     def identity_metadata_source
-      if self.identityMetadata.otherId('catkey').first ||
-         self.identityMetadata.otherId('barcode').first
+      if identityMetadata.otherId('catkey').first ||
+         identityMetadata.otherId('barcode').first
         'Symphony'
-      elsif self.identityMetadata.otherId('mdtoolkit').first
+      elsif identityMetadata.otherId('mdtoolkit').first
         'Metadata Toolkit'
       else
         'DOR'
@@ -91,26 +91,26 @@ module Dor
     end
 
     def set_source_id(source_id)
-      self.identityMetadata.sourceId = source_id
+      identityMetadata.sourceId = source_id
     end
 
-    def add_other_Id(type,val)
-      if self.identityMetadata.otherId(type).length>0
-        raise 'There is an existing entry for '+type+', consider using update_other_Id().'
+    def add_other_Id(type, val)
+      if identityMetadata.otherId(type).length > 0
+        raise 'There is an existing entry for ' + type + ', consider using update_other_Id().'
       end
-      self.identityMetadata.add_otherId(type+':'+val)
+      identityMetadata.add_otherId(type + ':' + val)
     end
 
-    def update_other_Id(type, new_val, val=nil)
-      self.identityMetadata.ng_xml.search('//otherId[@name=\''+type+'\']')
-        .select{ |node| val.nil? || node.content == val }
+    def update_other_Id(type, new_val, val = nil)
+      identityMetadata.ng_xml.search('//otherId[@name=\'' + type + '\']')
+        .select { |node| val.nil? || node.content == val }
         .each  { |node| node.content = new_val }
         .any?
     end
 
-    def remove_other_Id(type, val=nil)
-      self.identityMetadata.ng_xml.search('//otherId[@name=\''+type+'\']')
-        .select{ |node| val.nil? || node.content == val }
+    def remove_other_Id(type, val = nil)
+      identityMetadata.ng_xml.search('//otherId[@name=\'' + type + '\']')
+        .select { |node| val.nil? || node.content == val }
         .each(&:remove)
         .any?
     end
@@ -118,17 +118,17 @@ module Dor
     # turns a tag string into an array with one element per tag part.
     # split on ":", disregard leading and trailing whitespace on tokens.
     def split_tag_to_arr(tag_str)
-      return tag_str.split(":").map {|str| str.strip}
+      tag_str.split(':').map {|str| str.strip}
     end
 
     # turn a tag array back into a tag string with a standard format
     def normalize_tag_arr(tag_arr)
-      return tag_arr.join(' : ')
+      tag_arr.join(' : ')
     end
 
     # take a tag string and return a normalized tag string
     def normalize_tag(tag_str)
-      return normalize_tag_arr(split_tag_to_arr(tag_str))
+      normalize_tag_arr(split_tag_to_arr(tag_str))
     end
 
     # take a proposed tag string and a list of the existing tags for the object being edited.  if
@@ -145,7 +145,7 @@ module Dor
         raise "An existing tag (#{dupe_existing_tag}) is the same, consider using update_tag?"
       end
 
-      return normalized_tag
+      normalized_tag
     end
 
     # Ensure that an administrative tag meets the proper mininum format
@@ -161,21 +161,21 @@ module Dor
       if tag_arr.detect {|str| str.empty?}
         raise ArgumentError, "Invalid tag structure: tag '#{tag_str}' contains empty elements"
       end
-      return tag_arr
+      tag_arr
     end
 
     # Add an administrative tag to an item, you will need to seperately save the item to write it to fedora
     # @param tag [string] The tag you wish to add
     def add_tag(tag)
-        identity_metadata_ds = self.identityMetadata
-        normalized_tag = validate_and_normalize_tag(tag, identity_metadata_ds.tags)
-        identity_metadata_ds.add_value(:tag, normalized_tag)
+      identity_metadata_ds = identityMetadata
+      normalized_tag = validate_and_normalize_tag(tag, identity_metadata_ds.tags)
+      identity_metadata_ds.add_value(:tag, normalized_tag)
     end
 
     def remove_tag(tag)
       normtag = normalize_tag(tag)
-      self.identityMetadata.ng_xml.search('//tag')
-        .select{ |node| normalize_tag(node.content) == normtag }
+      identityMetadata.ng_xml.search('//tag')
+        .select { |node| normalize_tag(node.content) == normtag }
         .each(&:remove)
         .any?
     end
@@ -183,7 +183,7 @@ module Dor
     # Removes all displayTypes from an item in preparation of adding a new display type
     # @return Boolean True if displayTypes were removed, False if no displayTypes were removed
     def remove_displayTypes
-      nodes = self.identityMetadata.ng_xml.search('//displayType')
+      nodes = identityMetadata.ng_xml.search('//displayType')
       # NOTE: .each after search is different than normal ruby enumerator:
       # ~ ng_xml.search('//nonexistant_tag').each(&:foo) == 0
       # ~ [].each(&:foo) == []
@@ -193,40 +193,51 @@ module Dor
 
     def update_tag(old_tag, new_tag)
       normtag = normalize_tag(old_tag)
-      self.identityMetadata.ng_xml.search('//tag')
-        .select{ |node| normalize_tag(node.content) == normtag }
+      identityMetadata.ng_xml.search('//tag')
+        .select { |node| normalize_tag(node.content) == normtag }
         .each  { |node| node.content = normalize_tag(new_tag)  }
         .any?
     end
 
     def get_related_obj_display_title(related_obj, default_title)
       if related_obj
-        if related_obj.datastreams["DC"] && related_obj.datastreams["DC"].title
-          return related_obj.datastreams["DC"].title
+        if related_obj.datastreams['DC'] && related_obj.datastreams['DC'].title
+          return related_obj.datastreams['DC'].title
         else
           return related_obj.label
         end
       end
 
-      return default_title
+      default_title
     end
 
     private
-    def solrize_related_obj_titles(solr_doc, relationships, title_hash, field_name)
+
+    def solrize_related_obj_titles(solr_doc, relationships, title_hash, union_field_name, nonhydrus_field_name, hydrus_field_name)
+      # TODO: if you wanted to get a little fancier, you could also solrize a 2 level hierarchy and display using hierarchial facets, like
+      # ["SOURCE", "SOURCE : TITLE"] (e.g. ["Hydrus", "Hydrus : Special Collections"], see (exploded) tags in IdentityMetadataDS#to_solr).
       title_type = :symbol  # we'll get an _ssim because of the type
       title_attrs = [:stored_searchable]  # we'll also get a _tesim from this attr
       relationships.each do |rel_node|
         rel_druid = rel_node['rdf:resource']
         next unless rel_druid   # TODO: warning here would also be useful
         rel_druid = rel_druid.gsub('info:fedora/', '')
-        if title_hash.key?(rel_druid)
-          add_solr_value(solr_doc, field_name, title_hash[rel_druid], title_type, title_attrs)
-        else
+
+        # populate cache if necessary
+        unless title_hash.key?(rel_druid)
           related_obj = Dor.find(rel_druid)
           related_obj_title = get_related_obj_display_title(related_obj, rel_druid)
-          add_solr_value(solr_doc, field_name, related_obj_title, title_type, title_attrs)
-          title_hash[rel_druid] = related_obj_title
+          is_from_hydrus = (related_obj && related_obj.tags.include?('Project : Hydrus'))
+          title_hash[rel_druid] = {'related_obj_title' => related_obj_title, 'is_from_hydrus' => is_from_hydrus}
+        end
+
+        # cache should definitely be populated, so just use that to write solr field
+        if title_hash[rel_druid]['is_from_hydrus']
+          add_solr_value(solr_doc, hydrus_field_name, title_hash[rel_druid]['related_obj_title'], title_type, title_attrs)
+        else
+          add_solr_value(solr_doc, nonhydrus_field_name, title_hash[rel_druid]['related_obj_title'], title_type, title_attrs)
         end
+        add_solr_value(solr_doc, union_field_name, title_hash[rel_druid]['related_obj_title'], title_type, title_attrs)
       end
     end
   end

data/lib/dor/models/item.rb

@@ -11,7 +11,6 @@ module Dor
     include Contentable
     include Geoable
     include Releaseable
-
   end
 
   class Abstract < ::ActiveFedora::Base

data/lib/dor/models/itemizable.rb

@@ -6,18 +6,18 @@ module Dor
     extend ActiveSupport::Concern
 
     included do
-      has_metadata :name => "contentMetadata", :type => Dor::ContentMetadataDS, :label => 'Content Metadata', :control_group => 'M'
+      has_metadata :name => 'contentMetadata', :type => Dor::ContentMetadataDS, :label => 'Content Metadata', :control_group => 'M'
     end
 
     DIFF_FILENAME = 'cm_inv_diff'
-    DIFF_QUERY = DIFF_FILENAME.gsub('_', '-')
+    DIFF_QUERY = DIFF_FILENAME.tr('_', '-')
 
     # Deletes all cm_inv_diff files in the workspace for the Item
     def clear_diff_cache
       if Dor::Config.stacks.local_workspace_root.nil?
         raise ArgumentError, 'Missing Dor::Config.stacks.local_workspace_root'
       end
-      druid = DruidTools::Druid.new(self.pid, Dor::Config.stacks.local_workspace_root)
+      druid = DruidTools::Druid.new(pid, Dor::Config.stacks.local_workspace_root)
       diff_pattern = File.join(druid.temp_dir, DIFF_FILENAME + '.*')
       FileUtils.rm_f Dir.glob(diff_pattern)
     end
@@ -31,7 +31,7 @@ module Dor
       if Dor::Config.stacks.local_workspace_root.nil?
         raise Dor::ParameterError, 'Missing Dor::Config.stacks.local_workspace_root'
       end
-      unless %w{all shelve preserve publish}.include?(subset.to_s)
+      unless %w(all shelve preserve publish).include?(subset.to_s)
         raise Dor::ParameterError, "Invalid subset value: #{subset}"
       end
 
@@ -40,17 +40,16 @@ module Dor
         raise Dor::ParameterError, 'Missing Dor::Config.sdr.rest_client'
       end
       sdr_client = Dor::Config.sdr.rest_client
-      current_content = self.datastreams['contentMetadata'].content
+      current_content = datastreams['contentMetadata'].content
       if current_content.nil?
-        raise Dor::Exception, "Missing contentMetadata datastream"
+        raise Dor::Exception, 'Missing contentMetadata datastream'
       end
       query_string = { :subset => subset.to_s }
       query_string[:version] = version.to_s unless version.nil?
       query_string = URI.encode_www_form(query_string)
-      sdr_query = "objects/#{self.pid}/#{DIFF_QUERY}?#{query_string}"
+      sdr_query = "objects/#{pid}/#{DIFF_QUERY}?#{query_string}"
       response = sdr_client[sdr_query].post(current_content, :content_type => 'application/xml')
       response
     end
-
   end
 end