moab-versioning 4.2.0 → 4.2.1

data/lib/moab/signature_catalog_entry.rb

@@ -1,7 +1,6 @@
 require 'moab'
 
 module Moab
-
   # A file-level entry in a digital object's {SignatureCatalog}.
   # It has a child {FileSignature} element that identifies the file's contents (the bytestream)
   # along with data that specfies the SDR storage location that was used to preserve a single file instance.
@@ -14,20 +13,19 @@ module Moab
   # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
   #   All rights reserved.  See {file:LICENSE.rdoc} for details.
   class SignatureCatalogEntry < Serializer::Serializable
-
     include HappyMapper
 
     # The name of the XML element used to serialize this objects data
     tag 'entry'
 
     # (see Serializable#initialize)
-    def initialize(opts={})
+    def initialize(opts = {})
       super(opts)
     end
 
     # @attribute
     # @return [Integer] The ordinal version number
-    attribute :version_id, Integer, :tag => 'originalVersion', :key => true, :on_save => Proc.new {|n| n.to_s}
+    attribute :version_id, Integer, :tag => 'originalVersion', :key => true, :on_save => Proc.new { |n| n.to_s }
 
     # @attribute
     # @return [String] The name of the file group
@@ -53,9 +51,7 @@ module Moab
     # @api internal
     # @return [String] Returns the storage path to a file, relative to the object storage home directory
     def storage_path
-      File.join(StorageObject.version_dirname(version_id),'data', group_id, path)
+      File.join(StorageObject.version_dirname(version_id), 'data', group_id, path)
     end
-
   end
-
 end

data/lib/moab/storage_object.rb

@@ -1,7 +1,6 @@
 require 'moab'
 
 module Moab
-
   # A class to represent a digital object's repository storage location
   # and methods for
   # * packaging a bag for ingest of a new object version to the repository
@@ -18,7 +17,6 @@ module Moab
   # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
   #   All rights reserved.  See {file:LICENSE.rdoc} for details.
   class StorageObject
-
     # @return [String] The digital object ID (druid)
     attr_accessor :digital_object_id
 
@@ -30,7 +28,7 @@ module Moab
 
     # @param object_id [String] The digital object identifier
     # @param object_dir [Pathname,String] The location of the object's storage home directory
-    def initialize(object_id, object_dir, mkpath=false)
+    def initialize(object_id, object_dir, mkpath = false)
       @digital_object_id = object_id
       @object_pathname = Pathname.new(object_dir)
       initialize_storage if mkpath
@@ -44,7 +42,7 @@ module Moab
     # @api external
     # @return [void] Create the directory for the digital object home unless it already exists
     def initialize_storage
-        @object_pathname.mkpath
+      @object_pathname.mkpath
     end
 
     # @return [Pathname] The absolute location of the area in which bags are deposited
@@ -61,20 +59,20 @@ module Moab
     # @param bag_dir [Pathname,String] The location of the bag to be ingested
     # @return [void] Ingest a new object version contained in a bag into this objects storage area
     # @example {include:file:spec/features/storage/ingest_spec.rb}
-    def ingest_bag(bag_dir=deposit_bag_pathname)
+    def ingest_bag(bag_dir = deposit_bag_pathname)
       bag_dir = Pathname(bag_dir)
-      current_version = StorageObjectVersion.new(self,current_version_id)
+      current_version = StorageObjectVersion.new(self, current_version_id)
       current_inventory = current_version.file_inventory('version')
-      new_version = StorageObjectVersion.new(self,current_version_id + 1)
-      if FileInventory.xml_pathname_exist?(bag_dir,'version')
-        new_inventory = FileInventory.read_xml_file(bag_dir,'version')
+      new_version = StorageObjectVersion.new(self, current_version_id + 1)
+      if FileInventory.xml_pathname_exist?(bag_dir, 'version')
+        new_inventory = FileInventory.read_xml_file(bag_dir, 'version')
       elsif current_version.version_id == 0
-        new_inventory = versionize_bag(bag_dir,current_version,new_version)
+        new_inventory = versionize_bag(bag_dir, current_version, new_version)
       end
       validate_new_inventory(new_inventory)
       new_version.ingest_bag_data(bag_dir)
-      new_version.update_catalog(current_version.signature_catalog,new_inventory)
-      new_version.generate_differences_report(current_inventory,new_inventory)
+      new_version.update_catalog(current_version.signature_catalog, new_inventory)
+      new_version.generate_differences_report(current_inventory, new_inventory)
       new_version.generate_manifest_inventory
       new_version
     end
@@ -84,12 +82,12 @@ module Moab
     # @param current_version[StorageObjectVersion] The current latest version of the object
     # @param new_version [StorageObjectVersion] The version to be added
     # @return [FileInventory] The file inventory of the specified type for this version
-    def versionize_bag(bag_dir,current_version,new_version)
+    def versionize_bag(bag_dir, current_version, new_version)
       new_inventory = FileInventory.new(
-          :type=>'version',
-          :digital_object_id=>@digital_object_id,
-          :version_id=>new_version.version_id,
-          :inventory_datetime => Time.now
+        :type => 'version',
+        :digital_object_id => @digital_object_id,
+        :version_id => new_version.version_id,
+        :inventory_datetime => Time.now
       )
       new_inventory.inventory_from_bagit_bag(bag_dir)
       new_inventory.write_xml_file(bag_dir)
@@ -104,11 +102,11 @@ module Moab
     # @return [void] Reconstruct an object version and package it in a bag for dissemination
     # @example {include:file:spec/features/storage/reconstruct_spec.rb}
     def reconstruct_version(version_id, bag_dir)
-      storage_version = StorageObjectVersion.new(self,version_id)
+      storage_version = StorageObjectVersion.new(self, version_id)
       version_inventory = storage_version.file_inventory('version')
       signature_catalog = storage_version.signature_catalog
       bagger = Bagger.new(version_inventory, signature_catalog, bag_dir)
-      bagger.fill_bag(:reconstructor,@object_pathname)
+      bagger.fill_bag(:reconstructor, @object_pathname)
     end
 
     # @param [String] catalog_filepath The object-relative path of the file
@@ -142,7 +140,7 @@ module Moab
 
     # @return [Array<StorageObjectVersion>] The list of all versions in this storage object
     def version_list
-      version_id_list.collect{|id| self.storage_object_version(id)}
+      version_id_list.collect { |id| self.storage_object_version(id) }
     end
     alias :versions :version_list
 
@@ -175,15 +173,15 @@ module Moab
     # @api external
     # @param version_id [Integer] The existing version to return.  If nil, return latest version
     # @return [StorageObjectVersion] The representation of an existing version's storage area
-    def find_object_version(version_id=nil)
+    def find_object_version(version_id = nil)
       current = current_version_id
       case version_id
-        when nil
-          StorageObjectVersion.new(self,current)
-        when 1..current
-          StorageObjectVersion.new(self,version_id)
-        else
-          raise "Version ID #{version_id} does not exist"
+      when nil
+        StorageObjectVersion.new(self, current)
+      when 1..current
+        StorageObjectVersion.new(self, version_id)
+      else
+        raise "Version ID #{version_id} does not exist"
       end
     end
 
@@ -194,7 +192,7 @@ module Moab
     # * Current version + 1 is used for creation of a new version
     def storage_object_version(version_id)
       if version_id
-        StorageObjectVersion.new(self,version_id)
+        StorageObjectVersion.new(self, version_id)
       else
         raise "Version ID not specified"
       end
@@ -207,7 +205,7 @@ module Moab
         result.subentities << version.verify_version_storage
       end
       result.subentities << current_version.verify_signature_catalog
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
@@ -222,7 +220,7 @@ module Moab
         # rename/save the original
         storage_version.deactivate(timestamp)
         # copy the recovered version into place
-        FileUtils.cp_r(recovery_version.version_pathname.to_s,storage_version.version_pathname.to_s)
+        FileUtils.cp_r(recovery_version.version_pathname.to_s, storage_version.version_pathname.to_s)
       end
       self
     end
@@ -236,5 +234,4 @@ module Moab
       size
     end
   end
-
 end

data/lib/moab/storage_object_validator.rb

@@ -5,7 +5,6 @@ module Moab
   # Given a druid path, are the contents actually a well-formed Moab?
   # Shameless green: repetitious code included.
   class StorageObjectValidator
-
     METADATA_DIR = "metadata".freeze
     CONTENT_DIR = "content".freeze
     EXPECTED_DATA_SUB_DIRS = [CONTENT_DIR, METADATA_DIR].freeze
@@ -25,7 +24,7 @@ module Moab
     VERSION_DIR_BAD_FORMAT = 3
     NO_SIGNATURE_CATALOG = 4
     NO_MANIFEST_INVENTORY = 5
-    NO_FILES_IN_MANIFEST_DIR= 6
+    NO_FILES_IN_MANIFEST_DIR = 6
     VERSIONS_NOT_IN_ORDER = 7
     METADATA_SUB_DIRS_DETECTED = 8
     FILES_IN_VERSION_DIR = 9
@@ -41,7 +40,7 @@ module Moab
       @directory_entries_hash = {}
     end
 
-    def validation_errors(allow_content_subdirs=true)
+    def validation_errors(allow_content_subdirs = true)
       errors = []
       errors.concat check_correctly_named_version_dirs
       errors.concat check_sequential_version_dirs if errors.empty?
@@ -90,18 +89,14 @@ module Moab
 
     # call only if the version directories are "correctly named" vdddd
     def check_sequential_version_dirs
-      errors = []
       version_directories.each_with_index do |dir_name, index|
-        expected_vers_num = index + 1 # version numbering starts at 1, array indexing starts at 0
-        if dir_name[1..-1].to_i != expected_vers_num
-          errors << result_hash(VERSIONS_NOT_IN_ORDER, version_directories)
-          break
-        end
+        next if dir_name[1..-1].to_i == index + 1 # version numbering starts at 1, array indexing at 0
+        return [result_hash(VERSIONS_NOT_IN_ORDER, version_directories)]
       end
-      errors
+      []
     end
 
-    def check_correctly_formed_moab(allow_content_subdirs=true)
+    def check_correctly_formed_moab(allow_content_subdirs = true)
       errors = []
       version_directories.each do |version_dir|
         version_path = File.join(storage_obj_path, version_dir)
@@ -114,20 +109,15 @@ module Moab
     end
 
     def check_version_sub_dirs(version_path, version)
-      errors = []
       version_sub_dirs = directory_entries(version_path)
-      version_sub_dir_count = version_sub_dirs.size
-      if version_sub_dir_count == EXPECTED_VERSION_SUB_DIRS.size
-        errors.concat expected_version_sub_dirs(version_path, version)
-      elsif version_sub_dir_count > EXPECTED_VERSION_SUB_DIRS.size
-        errors.concat found_unexpected(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS)
-      elsif version_sub_dir_count < EXPECTED_VERSION_SUB_DIRS.size
-        errors.concat missing_dir(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS)
-      end
-      errors
+      count = version_sub_dirs.size
+      return expected_version_sub_dirs(version_path, version) if count == EXPECTED_VERSION_SUB_DIRS.size
+      return found_unexpected(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS) if count > EXPECTED_VERSION_SUB_DIRS.size
+      return missing_dir(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS) if count < EXPECTED_VERSION_SUB_DIRS.size
+      []
     end
 
-    def check_data_directory(version_path, version, allow_content_subdirs=true)
+    def check_data_directory(version_path, version, allow_content_subdirs = true)
       errors = []
       data_dir_path = File.join(version_path, DATA_DIR)
       data_sub_dirs = directory_entries(data_dir_path)
@@ -138,18 +128,14 @@ module Moab
     end
 
     def check_data_sub_dirs(version, data_sub_dirs)
+      return found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS) if data_sub_dirs.size > EXPECTED_DATA_SUB_DIRS.size
       errors = []
-      if data_sub_dirs.size > EXPECTED_DATA_SUB_DIRS.size
-        errors.concat found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS)
-      else
-        errors.concat missing_dir(data_sub_dirs, version, [METADATA_DIR]) unless data_sub_dirs.include?(METADATA_DIR)
-        errors.concat found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS) unless subset?(data_sub_dirs,
-                                                                                                      EXPECTED_DATA_SUB_DIRS)
-      end
+      errors.concat missing_dir(data_sub_dirs, version, [METADATA_DIR]) unless data_sub_dirs.include?(METADATA_DIR)
+      errors.concat found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS) unless data_sub_dirs.to_set.subset?(EXPECTED_DATA_SUB_DIRS.to_set)
       errors
     end
 
-    def check_optional_content_dir(version_path, allow_content_subdirs=true)
+    def check_optional_content_dir(version_path, allow_content_subdirs = true)
       errors = []
       content_dir_path = File.join(version_path, DATA_DIR, CONTENT_DIR)
       errors << result_hash(NO_FILES_IN_CONTENT_DIR, basename(version_path)) if directory_entries(content_dir_path).empty?
@@ -168,10 +154,6 @@ module Moab
       FORBIDDEN_CONTENT_SUB_DIRS.include?(dirname) || version_dir_format?(dirname)
     end
 
-    def subset?(first_array, second_array)
-      first_array.to_set.subset?(second_array.to_set)
-    end
-
     def check_metadata_dir_files_only(version_path)
       errors = []
       metadata_dir_path = File.join(version_path, DATA_DIR, METADATA_DIR)
@@ -183,39 +165,26 @@ module Moab
     # This method removes the implicit '.' and '..' directories.
     # Returns an array of strings.
     def directory_entries(path)
-      @directory_entries_hash[path] ||=
-        begin
-          dirs = []
-          (Dir.entries(path).sort - IMPLICIT_DIRS).each do |child|
-            dirs << child
-          end
-          dirs
-        end
+      @directory_entries_hash[path] ||= Dir.entries(path).sort - IMPLICIT_DIRS
     end
 
+    # @return [Array<Hash<Integer => String>>]
     def found_unexpected(array, version, required_sub_dirs)
-      errors = []
       unexpected = (array - required_sub_dirs)
-      unexpected = "#{unexpected} Version: #{version}"
-      errors << result_hash(EXTRA_CHILD_DETECTED, unexpected)
-      errors
+      [result_hash(EXTRA_CHILD_DETECTED, "#{unexpected} Version: #{version}")]
     end
 
+    # @return [Array<Hash<Integer => String>>]
     def missing_dir(array, version, required_sub_dirs)
-      errors = []
       missing = (required_sub_dirs - array)
-      missing ="#{missing} Version: #{version}"
-      errors << result_hash(MISSING_DIR, missing)
-      errors
+      [result_hash(MISSING_DIR, "#{missing} Version: #{version}")]
     end
 
     def expected_version_sub_dirs(version_path, version)
       errors = []
       version_sub_dirs = directory_entries(version_path)
       errors << result_hash(INCORRECT_DIR_CONTENTS, version) unless version_sub_dirs == EXPECTED_VERSION_SUB_DIRS
-      if contains_file?(version_path)
-        errors << result_hash(FILES_IN_VERSION_DIR, version)
-      end
+      errors << result_hash(FILES_IN_VERSION_DIR, version) if contains_file?(version_path)
       errors
     end
 
@@ -235,35 +204,24 @@ module Moab
       path.split(File::SEPARATOR)[-1]
     end
 
-    def result_hash(response_code, addl=nil)
+    def result_hash(response_code, addl = nil)
       { response_code => error_code_msg(response_code, addl) }
     end
 
-    def error_code_msg(response_code, addl=nil)
+    def error_code_msg(response_code, addl = nil)
       format(self.class.error_code_to_messages[response_code], addl: addl)
     end
 
     def check_required_manifest_files(dir, version)
+      return [result_hash(NO_FILES_IN_MANIFEST_DIR, version)] unless contains_file?(File.join(dir, MANIFESTS_DIR))
       errors = []
-      unless contains_file?(File.join(dir, MANIFESTS_DIR))
-        errors << result_hash(NO_FILES_IN_MANIFEST_DIR, version)
-        return errors
-      end
-
-      unless File.exist?(File.join(dir, MANIFEST_INVENTORY_PATH))
-        errors << result_hash(NO_MANIFEST_INVENTORY, version)
-      end
-      unless File.exist?(File.join(dir, SIGNATURE_CATALOG_PATH))
-        errors << result_hash(NO_SIGNATURE_CATALOG, version)
-      end
+      errors << result_hash(NO_MANIFEST_INVENTORY, version) unless File.exist?(File.join(dir, MANIFEST_INVENTORY_PATH))
+      errors << result_hash(NO_SIGNATURE_CATALOG, version) unless File.exist?(File.join(dir, SIGNATURE_CATALOG_PATH))
       errors
     end
 
-    def latest_manifest_inventory
-      File.join(storage_obj_path, version_directories.last, MANIFEST_INVENTORY_PATH)
-    end
-
     def object_id_from_manifest_inventory
+      latest_manifest_inventory = File.join(storage_obj_path, version_directories.last, MANIFEST_INVENTORY_PATH)
       Nokogiri::XML(File.open(latest_manifest_inventory)).at_xpath('//fileInventory/@objectId').value
     end
   end

data/lib/moab/storage_object_version.rb

@@ -1,9 +1,7 @@
 require 'moab'
 
 module Moab
-
   # A class to represent a version subdirectory within an object's home directory in preservation storage
-  #
   # ====Data Model
   # * {StorageRepository} = represents a digital object repository storage node
   #   * {StorageServices} = supports application layer access to the repository's objects, data, and metadata
@@ -14,7 +12,6 @@ module Moab
   # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
   #   All rights reserved.  See {file:LICENSE.rdoc} for details.
   class StorageObjectVersion
-
     # @return [Integer] The ordinal version number
     attr_accessor :version_id
 
@@ -36,13 +33,13 @@ module Moab
       if version_id.is_a?(Integer)
         @version_id = version_id
       elsif version_id.is_a?(String) and version_id =~ /^v(\d+)$/
-        @version_id = version_id.sub(/^v/,'').to_i
+        @version_id = version_id.sub(/^v/, '').to_i
       else
         raise "version_id (#{version_id}) is not in a recognized format"
       end
       @version_name = StorageObject.version_dirname(@version_id)
       @version_pathname = storage_object.object_pathname.join(@version_name)
-      @storage_object=storage_object
+      @storage_object = storage_object
       @inventory_cache = Hash.new
     end
 
@@ -61,7 +58,7 @@ module Moab
   # @return [FileSignature] signature of the specified file
     def find_signature(file_category, file_id)
       if file_category =~ /manifest/
-        file_inventory('manifests').file_signature('manifests',file_id)
+        file_inventory('manifests').file_signature('manifests', file_id)
       else
         file_inventory('version').file_signature(file_category, file_id)
       end
@@ -103,7 +100,7 @@ module Moab
       if file_category =~ /manifest/
         @version_pathname.join('manifests')
       else
-        @version_pathname.join('data',file_category)
+        @version_pathname.join('data', file_category)
       end
     end
 
@@ -116,12 +113,12 @@ module Moab
         return @inventory_cache[type] if @inventory_cache.has_key?(type)
         @inventory_cache[type] = FileInventory.read_xml_file(@version_pathname.join('manifests'), type)
       else
-        groups = ['content','metadata'].collect { |id| FileGroup.new(:group_id=>id)}
+        groups = ['content', 'metadata'].collect { |id| FileGroup.new(:group_id => id) }
         FileInventory.new(
-            :type=>'version',
-            :digital_object_id => @storage_object.digital_object_id,
-            :version_id => @version_id,
-            :groups => groups
+          :type => 'version',
+          :digital_object_id => @storage_object.digital_object_id,
+          :version_id => @version_id,
+          :groups => groups
         )
       end
     end
@@ -142,10 +139,10 @@ module Moab
     def ingest_bag_data(bag_dir)
       raise "Version already exists: #{@version_pathname}" if @version_pathname.exist?
       @version_pathname.join('manifests').mkpath
-      bag_dir=Pathname(bag_dir)
-      ingest_dir(bag_dir.join('data'),@version_pathname.join('data'))
-      ingest_file(bag_dir.join(FileInventory.xml_filename('version')),@version_pathname.join('manifests'))
-      ingest_file(bag_dir.join(FileInventory.xml_filename('additions')),@version_pathname.join('manifests'))
+      bag_dir = Pathname(bag_dir)
+      ingest_dir(bag_dir.join('data'), @version_pathname.join('data'))
+      ingest_file(bag_dir.join(FileInventory.xml_filename('version')), @version_pathname.join('manifests'))
+      ingest_file(bag_dir.join(FileInventory.xml_filename('additions')), @version_pathname.join('manifests'))
     end
 
     # @api internal
@@ -153,7 +150,7 @@ module Moab
     # @param target_dir [Pathname] The target location of the directory into which files are ingested
     # @param use_links [Boolean] If true, use hard links; if false, make copies
     # @return [void] recursively link or copy the source directory contents to the target directory
-    def ingest_dir(source_dir, target_dir, use_links=true)
+    def ingest_dir(source_dir, target_dir, use_links = true)
       raise "cannot copy - target already exists: #{target_dir.expand_path}" if target_dir.exist?
       target_dir.mkpath
       source_dir.children.each do |child|
@@ -170,7 +167,7 @@ module Moab
     # @param target_dir [Pathname] The location of the directory in which to place the file
     # @param use_links [Boolean] If true, use hard links; if false, make copies
     # @return [void] link or copy the specified file from source location to the version directory
-    def ingest_file(source_file, target_dir, use_links=true)
+    def ingest_file(source_file, target_dir, use_links = true)
       if use_links
         FileUtils.link(source_file.to_s, target_dir.to_s) #, :force => true)
       else
@@ -183,7 +180,7 @@ module Moab
     # @param new_inventory [FileInventory] The new version's inventory
     # @return [void] Updates the catalog to include newly added files, then saves it to disk
     # @see SignatureCatalog#update
-    def update_catalog(signature_catalog,new_inventory)
+    def update_catalog(signature_catalog, new_inventory)
       signature_catalog.update(new_inventory, @version_pathname.join('data'))
       signature_catalog.write_xml_file(@version_pathname.join('manifests'))
     end
@@ -192,7 +189,7 @@ module Moab
     # @param old_inventory [FileInventory] The old version's inventory
     # @param new_inventory [FileInventory] The new version's inventory
     # @return [void] generate a file inventory differences report and save to disk
-    def generate_differences_report(old_inventory,new_inventory)
+    def generate_differences_report(old_inventory, new_inventory)
       differences = FileInventoryDifference.new.compare(old_inventory, new_inventory)
       differences.write_xml_file(@version_pathname.join('manifests'))
     end
@@ -201,11 +198,12 @@ module Moab
     # @return [void] examine the version's directory and create/serialize a {FileInventory} containing the manifest files
     def generate_manifest_inventory
       manifest_inventory = FileInventory.new(
-          :type=>'manifests',
-          :digital_object_id=>@storage_object.digital_object_id,
-          :version_id=>@version_id)
+        :type => 'manifests',
+        :digital_object_id => @storage_object.digital_object_id,
+        :version_id => @version_id
+      )
       pathname = @version_pathname.join('manifests')
-      manifest_inventory.groups << FileGroup.new(:group_id=>'manifests').group_from_directory(pathname, false)
+      manifest_inventory.groups << FileGroup.new(:group_id => 'manifests').group_from_directory(pathname, false)
       manifest_inventory.write_xml_file(pathname)
     end
 
@@ -215,16 +213,16 @@ module Moab
       result.subentities << self.verify_manifest_inventory
       result.subentities << self.verify_version_inventory
       result.subentities << self.verify_version_additions
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
-    # @return [Boolean] return true if the manifest inventory matches the actual files
+    # @return [VerificationResult] return true if the manifest inventory matches the actual files
     def verify_manifest_inventory
       # read/parse manifestInventory.xml
       result = VerificationResult.new("manifest_inventory")
       manifest_inventory = self.file_inventory('manifests')
-      result.subentities << VerificationResult.verify_value('composite_key',self.composite_key,manifest_inventory.composite_key)
+      result.subentities << VerificationResult.verify_value('composite_key', self.composite_key, manifest_inventory.composite_key)
       result.subentities << VerificationResult.verify_truth('manifests_group', !manifest_inventory.group_empty?('manifests'))
       # measure the manifest signatures of the files in the directory (excluding manifestInventory.xml)
       directory_inventory = FileInventory.new.inventory_from_directory(@version_pathname.join('manifests'), 'manifests')
@@ -233,19 +231,20 @@ module Moab
       directory_group.remove_file_having_path("manifestInventory.xml")
       # compare the measured signatures against the values in manifestInventory.xml
       diff = FileInventoryDifference.new
-      diff.compare(manifest_inventory,directory_inventory)
+      diff.compare(manifest_inventory, directory_inventory)
       compare_result = VerificationResult.new('file_differences')
       compare_result.verified = (diff.difference_count == 0)
       compare_result.details = diff.differences_detail
       result.subentities << compare_result
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
+    # @return [VerificationResult]
     def verify_signature_catalog
       result = VerificationResult.new("signature_catalog")
-      signature_catalog =self.signature_catalog
-      result.subentities << VerificationResult.verify_value('signature_key',self.composite_key,signature_catalog.composite_key)
+      signature_catalog = self.signature_catalog
+      result.subentities << VerificationResult.verify_value('signature_key', self.composite_key, signature_catalog.composite_key)
       found = 0
       missing = Array.new
       object_pathname = self.storage_object.object_pathname
@@ -260,12 +259,12 @@ module Moab
       file_result = VerificationResult.new("storage_location")
       file_result.verified = (found == signature_catalog.file_count)
       file_result.details = {
-          'expected' => signature_catalog.file_count,
-          'found' => found
+        'expected' => signature_catalog.file_count,
+        'found' => found
       }
       file_result.details['missing'] = missing unless missing.empty?
       result.subentities << file_result
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
@@ -273,9 +272,9 @@ module Moab
     def verify_version_inventory
       result = VerificationResult.new("version_inventory")
       version_inventory = self.file_inventory('version')
-      result.subentities << VerificationResult.verify_value('inventory_key',self.composite_key,version_inventory.composite_key)
-      signature_catalog =self.signature_catalog
-      result.subentities << VerificationResult.verify_value('signature_key',self.composite_key,signature_catalog.composite_key)
+      result.subentities << VerificationResult.verify_value('inventory_key', self.composite_key, version_inventory.composite_key)
+      signature_catalog = self.signature_catalog
+      result.subentities << VerificationResult.verify_value('signature_key', self.composite_key, signature_catalog.composite_key)
       found = 0
       missing = Array.new
       version_inventory.groups.each do |group|
@@ -294,13 +293,12 @@ module Moab
       file_result = VerificationResult.new("catalog_entry")
       file_result.verified = (found == version_inventory.file_count)
       file_result.details = {
-          'expected' => version_inventory.file_count,
-          'found' => found
+        'expected' => version_inventory.file_count,
+        'found' => found
       }
       file_result.details['missing'] = missing unless missing.empty?
-
       result.subentities << file_result
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
@@ -308,28 +306,27 @@ module Moab
     def verify_version_additions
       result = VerificationResult.new("version_additions")
       version_additions = self.file_inventory('additions')
-      result.subentities << VerificationResult.verify_value('composite_key',self.composite_key,version_additions.composite_key)
+      result.subentities << VerificationResult.verify_value('composite_key', self.composite_key, version_additions.composite_key)
       data_directory = @version_pathname.join('data')
-      directory_inventory = FileInventory.new(:type=>'directory').inventory_from_directory(data_directory)
+      directory_inventory = FileInventory.new(:type => 'directory').inventory_from_directory(data_directory)
       diff = FileInventoryDifference.new
       diff.compare(version_additions, directory_inventory)
       compare_result = VerificationResult.new('file_differences')
       compare_result.verified = (diff.difference_count == 0)
       compare_result.details = diff.differences_detail
       result.subentities << compare_result
-      result.verified = result.subentities.all?{|entity| entity.verified}
+      result.verified = result.subentities.all? { |entity| entity.verified }
       result
     end
 
     # @param timestamp [Time] The time at which the deactivation was initiated.  Used to name the inactive directory
     # @return [null] Deactivate this object version by moving it to another directory.  (Used by restore operation)
     def deactivate(timestamp)
-      if @version_pathname.exist?
-        timestamp_pathname = @version_pathname.parent.join(timestamp.utc.iso8601.gsub(/[-:]/,''))
-        timestamp_pathname.mkpath
-        demote_pathame = timestamp_pathname.join(@version_pathname.basename)
-        @version_pathname.rename(demote_pathame)
-      end
+      return unless @version_pathname.exist?
+      timestamp_pathname = @version_pathname.parent.join(timestamp.utc.iso8601.gsub(/[-:]/, ''))
+      timestamp_pathname.mkpath
+      demote_pathame = timestamp_pathname.join(@version_pathname.basename)
+      @version_pathname.rename(demote_pathame)
     end
   end
 end