dor-services 4.22.3 → 4.22.4

data/lib/dor/models/preservable.rb

@@ -17,11 +17,11 @@ module Dor
         ds.label = 'Provenance Metadata'
       end
       ds.ng_xml = workflow_provenance
-			ds.content=ds.ng_xml.to_s
+      ds.content=ds.ng_xml.to_s
       ds.save
     end
 
-    def build_technicalMetadata_datastream(ds=nil)
+    def build_technicalMetadata_datastream(ds = nil)
       TechnicalMetadataService.add_update_technical_metadata(self)
     end
 
@@ -33,9 +33,9 @@ module Dor
     # @return [Nokogiri::Document]
     def create_workflow_provenance(workflow_id, event_text)
       builder = Nokogiri::XML::Builder.new do |xml|
-        xml.provenanceMetadata(:objectId => self.pid) {
+        xml.provenanceMetadata(:objectId => pid) {
           xml.agent(:name => 'DOR') {
-            xml.what(:object => self.pid) {
+            xml.what(:object => pid) {
               xml.event(:who => "DOR-#{workflow_id}", :when => Time.new.iso8601) {
                 xml.text(event_text)
               }

data/lib/dor/models/processable.rb

@@ -42,11 +42,11 @@ module Dor
       # This is a work-around for some strange logic in ActiveFedora that
       # don't allow self.workflows.new? to work if we load the object using
       # .load_instance_from_solr.
-      return if self.respond_to? :inner_object and self.inner_object.is_a? ActiveFedora::SolrDigitalObject
+      return if self.respond_to?(:inner_object) && inner_object.is_a?(ActiveFedora::SolrDigitalObject)
 
-      if self.workflows.new?
+      if workflows.new?
         workflows.mimeType = 'application/xml'
-        workflows.dsLocation = File.join(Dor::Config.workflow.url,"dor/objects/#{self.pid}/workflows")
+        workflows.dsLocation = File.join(Dor::Config.workflow.url,"dor/objects/#{pid}/workflows")
       end
     end
 
@@ -54,7 +54,7 @@ module Dor
       if datastream.new?
         true
       elsif datastream.class.respond_to?(:xml_template)
-        datastream.content.to_s.empty? or EquivalentXml.equivalent?(datastream.content, datastream.class.xml_template)
+        datastream.content.to_s.empty? || EquivalentXml.equivalent?(datastream.content, datastream.class.xml_template)
       else
         datastream.content.to_s.empty?
       end
@@ -65,7 +65,7 @@ module Dor
     # Returns the path to it or nil.
     def find_metadata_file(datastream)
       druid = DruidTools::Druid.new(pid, Dor::Config.stacks.local_workspace_root)
-      return druid.find_metadata("#{datastream}.xml")
+      druid.find_metadata("#{datastream}.xml")
     end
 
     # Takes the name of a datastream, as a string (fooMetadata).
@@ -84,10 +84,10 @@ module Dor
         ds.content = content
         ds.ng_xml = Nokogiri::XML(content) if ds.respond_to?(:ng_xml)
         ds.save unless ds.digital_object.new?
-      elsif force or empty_datastream?(ds)
+      elsif force || empty_datastream?(ds)
         meth = "build_#{datastream}_datastream".to_sym
         if respond_to?(meth)
-          content = self.send(meth, ds)
+          content = send(meth, ds)
           ds.save unless ds.digital_object.new?
         end
       end
@@ -95,7 +95,7 @@ module Dor
       if is_required && empty_datastream?(ds)
         raise "Required datastream #{datastream} could not be populated!"
       end
-      return ds
+      ds
     end
 
     def cleanup()
@@ -103,13 +103,13 @@ module Dor
     end
 
     def milestones
-      Dor::WorkflowService.get_milestones('dor',self.pid)
+      Dor::WorkflowService.get_milestones('dor',pid)
     end
 
     def status_info()
       current_version = '1'
       begin
-        current_version = self.versionMetadata.current_version_id
+        current_version = versionMetadata.current_version_id
       rescue
       end
 
@@ -117,8 +117,8 @@ module Dor
       #only get steps that are part of accessioning and part of the current version. That can mean they were archived with the current version
       #number, or they might be active (no version number).
       milestones.each do |m|
-        if STEPS.keys.include?(m[:milestone]) and (m[:version].nil? or m[:version] == current_version)
-          current_milestones << m unless m[:milestone] == 'registered' and current_version.to_i > 1
+        if STEPS.keys.include?(m[:milestone]) && (m[:version].nil? || m[:version] == current_version)
+          current_milestones << m unless m[:milestone] == 'registered' && current_version.to_i > 1
         end
       end
 
@@ -136,25 +136,25 @@ module Dor
         end
       end
 
-      return {:current_version => current_version, :status_code => status_code, :status_time => status_time}
+      {:current_version => current_version, :status_code => status_code, :status_time => status_time}
     end
 
-    def status(include_time=false)
+    def status(include_time = false)
       status_info_hash = status_info
       current_version, status_code, status_time = status_info_hash[:current_version], status_info_hash[:status_code], status_info_hash[:status_time]
 
       #use the translation table to get the appropriate verbage for the latest step
       result = "v#{current_version} #{STATUS_CODE_DISP_TXT[status_code]}"
       result += " #{format_date(status_time)}" if include_time
-      return result
+      result
     end
 
-    def to_solr(solr_doc=Hash.new, *args)
+    def to_solr(solr_doc = Hash.new, *args)
       super(solr_doc, *args)
       sortable_milestones = {}
       current_version='1'
       begin
-        current_version = self.versionMetadata.current_version_id
+        current_version = versionMetadata.current_version_id
       rescue
       end
       current_version_num=current_version.to_i
@@ -162,12 +162,12 @@ module Dor
       if self.respond_to?('versionMetadata')
         #add an entry with version id, tag and description for each version
         while current_version_num > 0
-          add_solr_value(solr_doc, 'versions', current_version_num.to_s + ';' + self.versionMetadata.tag_for_version(current_version_num.to_s) + ';' + self.versionMetadata.description_for_version(current_version_num.to_s), :string, [:displayable])
+          add_solr_value(solr_doc, 'versions', current_version_num.to_s + ';' + versionMetadata.tag_for_version(current_version_num.to_s) + ';' + versionMetadata.description_for_version(current_version_num.to_s), :string, [:displayable])
           current_version_num -= 1
         end
       end
 
-      self.milestones.each do |milestone|
+      milestones.each do |milestone|
         timestamp = milestone[:at].utc.xmlschema
         sortable_milestones[milestone[:milestone]] ||= []
         sortable_milestones[milestone[:milestone]] << timestamp
@@ -201,7 +201,7 @@ module Dor
         add_solr_value(solr_doc, "version_opened", DateTime.parse(opened_date).beginning_of_day.utc.xmlschema.split('T').first, :string, [ :searchable, :facetable])
       end
       add_solr_value(solr_doc, "current_version", current_version.to_s, :string, [ :displayable , :facetable])
-      add_solr_value(solr_doc, "last_modified_day", self.modified_date.to_s.split('T').first, :string, [ :facetable ])
+      add_solr_value(solr_doc, "last_modified_day", modified_date.to_s.split('T').first, :string, [ :facetable ])
       add_solr_value(solr_doc, "rights", rights, :string, [:facetable]) if self.respond_to? :rights
       solr_doc
     end
@@ -212,12 +212,12 @@ module Dor
     # @param [String] name of the workflow to be initialized
     # @param [Boolean] create_ds create a 'workflows' datastream in Fedora for the object
     # @param [Integer] priority the workflow's priority level
-    def initialize_workflow(name, create_ds=true, priority=0)
+    def initialize_workflow(name, create_ds = true, priority = 0)
       priority = workflows.current_priority if priority == 0
       opts = { :create_ds => create_ds }
       opts[:priority] = priority if(priority > 0)
       opts[:lane_id] = default_workflow_lane
-      Dor::WorkflowService.create_workflow(Dor::WorkflowObject.initial_repo(name), self.pid, name, Dor::WorkflowObject.initial_workflow(name), opts)
+      Dor::WorkflowService.create_workflow(Dor::WorkflowObject.initial_repo(name), pid, name, Dor::WorkflowObject.initial_workflow(name), opts)
     end
 
 
@@ -237,4 +237,3 @@ module Dor
 
 
 end
-

data/lib/dor/models/releaseable.rb

@@ -18,7 +18,7 @@ module Dor
 
       # Add in each tag
       release_tags.each do |r_tag|
-        self.add_release_node(r_tag[:release],r_tag)
+        add_release_node(r_tag[:release],r_tag)
       end
 
       # Save item to dor so the robots work with the latest data
@@ -54,7 +54,7 @@ module Dor
       # Get the most recent self tag for all targets and save their result since most recent self always trumps any other non self tags
       latest_self_tags = get_newest_release_tag(self_release_tags)
       latest_self_tags.keys.each do |target|
-        released_hash[target] =  self.clean_release_tag_for_purl(latest_self_tags[target])
+        released_hash[target] =  clean_release_tag_for_purl(latest_self_tags[target])
       end
 
       # With Self Tags Resolved We Now need to deal with tags on all sets this object is part of
@@ -83,7 +83,7 @@ module Dor
     #
     #@return [Hash] a hash of self tags for each to value
     def get_self_release_tags(tags)
-      return get_tags_for_what_value(tags, 'self')
+      get_tags_for_what_value(tags, 'self')
     end
 
     #Take an item and get all of its release tags and all tags on collections it is a member of it
@@ -95,7 +95,7 @@ module Dor
       collections.each do |collection|
         return_tags = combine_two_release_tag_hashes(return_tags, Dor::Item.find(collection.id).get_release_tags_for_item_and_all_governing_sets) # recurvise so parents of parents are found
       end
-      return return_tags
+      return_tags
     end
 
     #Take two hashes of tags and combine them, will not overwrite but will enforce uniqueness of the tags
@@ -106,10 +106,10 @@ module Dor
     #@return [Hash] the combined hash with uniquiness enforced
     def combine_two_release_tag_hashes(hash_one, hash_two)
       hash_two.keys.each do |key|
-        hash_one[key] = hash_two[key] if hash_one[key] == nil
-        hash_one[key] = (hash_one[key] + hash_two[key]).uniq if hash_one[key] != nil
+        hash_one[key] = hash_two[key] if hash_one[key].nil?
+        hash_one[key] = (hash_one[key] + hash_two[key]).uniq unless hash_one[key].nil?
       end
-      return hash_one
+      hash_one
     end
 
     #Take a hash of tags and return all tags with the matching what target
@@ -124,7 +124,7 @@ module Dor
         self_tags = tags[key].select {|tag| tag['what'] == what_target.downcase}
         return_hash[key] = self_tags if self_tags.size > 0
       end
-      return return_hash
+      return_hash
     end
 
     #Take a hash of tags as obtained via Dor::Item.release_tags and returns the newest tag for each namespace
@@ -153,7 +153,7 @@ module Dor
       array_of_tags.each do |tag|
         latest_tag_in_array = tag if tag['when'] > latest_tag_in_array['when']
       end
-      return latest_tag_in_array
+      latest_tag_in_array
     end
 
     # Takes a tag and returns true or false if it applies to the specific item
@@ -189,17 +189,17 @@ module Dor
     #
     #@return [Nokogiri::XML::NodeSet] of all release tags and their attributes
     def release_tags
-      release_tags = self.identityMetadata.ng_xml.xpath('//release')
+      release_tags = identityMetadata.ng_xml.xpath('//release')
       return_hash = {}
       release_tags.each do |release_tag|
-        hashed_node = self.release_tag_node_to_hash(release_tag)
-        if return_hash[hashed_node[:to]] != nil
+        hashed_node = release_tag_node_to_hash(release_tag)
+        if !return_hash[hashed_node[:to]].nil?
           return_hash[hashed_node[:to]] << hashed_node[:attrs]
         else
            return_hash[hashed_node[:to]] = [hashed_node[:attrs]]
         end
       end
-      return return_hash
+      return_hash
     end
 
     #method to convert one release element into an array
@@ -239,8 +239,8 @@ module Dor
     #
     #@example
     #  item.add_tag(true,:release,{:tag=>'Fitch : Batch2',:what=>'self',:to=>'Searchworks',:who=>'petucket', :displayType='filmstrip'})
-    def add_release_node(release, attrs={})
-      identity_metadata_ds = self.identityMetadata
+    def add_release_node(release, attrs = {})
+      identity_metadata_ds = identityMetadata
       attrs[:when] = Time.now.utc.iso8601 if attrs[:when].nil? #add the timestamp
       attrs[:displayType] = 'file' if attrs[:displayType].nil? #default to file is no display type is passed
       valid_release_attributes(release, attrs)
@@ -258,8 +258,8 @@ module Dor
     #@return [Boolean] Returns true if no errors found
     #
     #@params attrs [hash] A hash of attributes for the tag, must contain :when, a ISO 8601 timestamp and :who to identify who or what added the tag, :to,
-    def valid_release_attributes(tag, attrs={})
-      raise ArgumentError, ":when is not iso8601" if attrs[:when].match('\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z') == nil
+    def valid_release_attributes(tag, attrs = {})
+      raise ArgumentError, ":when is not iso8601" if attrs[:when].match('\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z').nil?
       [:who, :to, :what].each do |check_attr|
         raise ArgumentError, "#{check_attr} not supplied as a String" if attrs[check_attr].class != String
       end
@@ -280,17 +280,17 @@ module Dor
     #
     #@return [Nokogiri::XML::NodeSet] of all release tags and their attributes
     def release_nodes
-      release_tags = self.identityMetadata.ng_xml.xpath('//release')
+      release_tags = identityMetadata.ng_xml.xpath('//release')
       return_hash = {}
       release_tags.each do |release_tag|
-        hashed_node = self.release_tag_node_to_hash(release_tag)
-        if return_hash[hashed_node[:to]] != nil
+        hashed_node = release_tag_node_to_hash(release_tag)
+        if !return_hash[hashed_node[:to]].nil?
           return_hash[hashed_node[:to]] << hashed_node[:attrs]
         else
           return_hash[hashed_node[:to]] = [hashed_node[:attrs]]
         end
       end
-      return return_hash
+      return_hash
     end
 
     #Get a list of all release nodes found in a purl document
@@ -323,8 +323,8 @@ module Dor
     #@return [String] the druid sans the druid: or if there was no druid: prefix, the entire string you passed
     def remove_druid_prefix
       druid_prefix = "druid:"
-      return self.id.split(druid_prefix)[1] if self.id.split(druid_prefix).size > 1
-      return druid
+      return id.split(druid_prefix)[1] if id.split(druid_prefix).size > 1
+      druid
     end
 
     # Take the and create the entire purl url that will usable for the open method in open-uri, returns https
@@ -348,8 +348,8 @@ module Dor
     #
     #@return [Array] An array containing all the release tags
     def get_release_tags_from_purl
-      xml = self.get_xml_from_purl
-      return self.get_release_tags_from_purl_xml(xml)
+      xml = get_xml_from_purl
+      get_release_tags_from_purl_xml(xml)
     end
 
     # This function calls purl and gets a list of all release tags currently in purl.  It then compares to the list you have generated.
@@ -362,7 +362,7 @@ module Dor
       missing_tags.each do |missing_tag|
         new_tags[missing_tag.capitalize] = {"release"=>false}
       end
-      return new_tags
+      new_tags
     end
 
     def to_solr(solr_doc = {}, *args)

data/lib/dor/models/shelvable.rb

@@ -25,7 +25,7 @@ module Dor
     # retrieve the differences between the current contentMetadata and the previously ingested version
     # (filtering to select only the files that should be shelved to stacks)
     def get_shelve_diff
-      inventory_diff_xml = self.get_content_diff(:shelve)
+      inventory_diff_xml = get_content_diff(:shelve)
       inventory_diff = Moab::FileInventoryDifference.parse(inventory_diff_xml)
       shelve_diff = inventory_diff.group_difference("content")
       shelve_diff
@@ -35,30 +35,30 @@ module Dor
     # @param [Moab::FileGroupDifference] content_diff The differences between the current contentMetadata and the previously ingested version
     # @param [DruidTools::Druid] workspace_druid the location of the object's files in the workspace area
     # @return [Pathname] The location of the object's content files in the workspace area
-    def workspace_content_dir (content_diff, workspace_druid)
+    def workspace_content_dir(content_diff, workspace_druid)
       deltas = content_diff.file_deltas
       filelist = deltas[:modified] + deltas[:added] + deltas[:copyadded].collect{|old,new| new}
       return nil if filelist.empty?
       content_pathname = Pathname(workspace_druid.find_filelist_parent('content', filelist))
       content_pathname
     end
-    
-    
-    # get the stack location based on the contentMetadata stacks attribute 
+
+
+    # get the stack location based on the contentMetadata stacks attribute
     # or using the default value from the config file if it doesn't exist
     def get_stacks_location
-      
-      contentMetadataDS = self.datastreams['contentMetadata']
-      unless contentMetadataDS.nil? or contentMetadataDS.stacks.length == 0
-        stacks_location = contentMetadataDS.stacks[0]        
+
+      contentMetadataDS = datastreams['contentMetadata']
+      unless contentMetadataDS.nil? || contentMetadataDS.stacks.length == 0
+        stacks_location = contentMetadataDS.stacks[0]
         if stacks_location.start_with?"/"  #Absolute stacks path
           return stacks_location
-        else        
-          raise "stacks attribute for item: "+self.id+ " contentMetadata should start with /. The current value is "+stacks_location
+        else
+          raise "stacks attribute for item: "+id+ " contentMetadata should start with /. The current value is "+stacks_location
         end
-      end      
-      return Config.stacks.local_stacks_root #Default stacks
-       
+      end
+      Config.stacks.local_stacks_root #Default stacks
+
     end
   end
 end

data/lib/dor/models/upgradable.rb

@@ -1,16 +1,16 @@
 module Dor
   module Upgradable
 
-    # The Upgradable mixin is responsible for making sure all DOR objects, 
-    # concerns, and datastreams know how to upgrade themselves to the latest 
+    # The Upgradable mixin is responsible for making sure all DOR objects,
+    # concerns, and datastreams know how to upgrade themselves to the latest
     # Chimera/DOR content standards.
     #
     # To add a new upgrade:
     # 1) include Dor::Upgradable within whatever model, datastream, or mixin
     #    you want to make upgradable.
     # 2) Add a block to the model, datastream, or mixin as follows:
-    # 
-    #    on_upgrade(v) do |obj| 
+    #
+    #    on_upgrade(v) do |obj|
     #      # Do whatever needs to be done to obj
     #    end
     #
@@ -20,7 +20,7 @@ module Dor
     # The block can either be defined on the model itself, or in a file
     # in the dor/migrations/[model] directory. See Dor::Identifiable and
     # dor/migrations/identifiable/* for an example.
-      
+
     Callback = Struct.new :module, :version, :description, :block
 
     mattr_accessor :__upgrade_callbacks
@@ -28,12 +28,12 @@ module Dor
     def self.add_upgrade_callback c, v, d, &b
       @@__upgrade_callbacks << Callback.new(c, Gem::Version.new(v), d, b)
     end
-    
+
     def self.run_upgrade_callbacks(obj, event_handler)
       relevant = @@__upgrade_callbacks.select { |c| obj.is_a?(c.module) }.sort_by(&:version)
-      results = relevant.collect do |c| 
+      results = relevant.collect do |c|
         result = c.block.call(obj)
-        if result and event_handler.respond_to?(:add_event)
+        if result && event_handler.respond_to?(:add_event)
           event_handler.add_event 'remediation', "#{c.module.name} #{c.version}", c.description
         end
         if result
@@ -43,29 +43,29 @@ module Dor
       end
       results.any?
     end
-    
+
     def self.included(base)
       base.instance_eval do
         def self.on_upgrade version, desc, &block
           Dor::Upgradable.add_upgrade_callback self, version, desc, &block
         end
-        
+
         Dir[File.join(Dor.root,'dor','migrations',base.name.split(/::/).last.underscore,'*.rb')].each do |migration|
           require migration
         end
       end
     end
-    
+
     def upgrade!
       results = [Dor::Upgradable.run_upgrade_callbacks(self, self)]
       if self.respond_to?(:datastreams)
-        self.datastreams.each_pair do |dsid, ds|
+        datastreams.each_pair do |dsid, ds|
           results << Dor::Upgradable.run_upgrade_callbacks(ds, self) unless ds.new?
         end
       end
 
       if results.any?
-        self.save
+        save
       else
         false
       end