moab-versioning 4.2.1 → 4.2.2

data/lib/moab/file_inventory_difference.rb

@@ -1,5 +1,3 @@
-require 'moab'
-
 module Moab
   # Compares two {FileInventory} instances based primarily on file signatures and secondarily on file pathnames.
   # Although the usual use will be to compare the content of 2 different temporal versions of the same object,
@@ -24,7 +22,7 @@ module Moab
 
     # (see Serializable#initialize)
     def initialize(opts = {})
-      @group_differences = Array.new
+      @group_differences = []
       super(opts)
     end
 
@@ -34,7 +32,7 @@ module Moab
 
     # @attribute
     # @return [Integer] the number of differences found between the two inventories that were compared (dynamically calculated)
-    attribute :difference_count, Integer, :tag => 'differenceCount', :on_save => Proc.new { |i| i.to_s }
+    attribute :difference_count, Integer, :tag => 'differenceCount', :on_save => proc { |i| i.to_s }
 
     def difference_count
       @group_differences.inject(0) { |sum, group| sum + group.difference_count }
@@ -66,7 +64,7 @@ module Moab
 
     # @return [Array<String>] The data fields to include in summary reports
     def summary_fields
-      %w{digital_object_id difference_count basis other report_datetime group_differences}
+      %w[digital_object_id difference_count basis other report_datetime group_differences]
     end
 
     # @param [String] group_id The identifer of the group to be selected
@@ -110,11 +108,11 @@ module Moab
     # @return [Hash] Serializes the data and then filters it to report only the changes
     def differences_detail
       #return self.summary if difference_count == 0
-      inv_diff = self.to_hash
+      inv_diff = to_hash
       inv_diff["group_differences"].each_value do |group_diff|
         delete_subsets = []
         group_diff["subsets"].each do |change_type, subset|
-          delete_subsets << change_type if change_type == "identical" or subset["count"] == 0
+          delete_subsets << change_type if (change_type == "identical") || (subset["count"] == 0)
         end
         delete_subsets.each do |change_type|
           group_diff["subsets"].delete(change_type)

data/lib/moab/file_manifestation.rb

@@ -1,5 +1,3 @@
-require 'moab'
-
 module Moab
   # A container for a file signature and all the physical file instances that have that signature
   # This element has one child {FileSignature} element, and one or more {FileInstance} elements
@@ -24,7 +22,7 @@ module Moab
 
     # (see Serializable#initialize)
     def initialize(opts = {})
-      @instances = Array.new
+      @instances = []
       super(opts)
     end
 
@@ -47,7 +45,7 @@ module Moab
     # @api internal
     # @return [Array<String>] Create an array from all the file paths of the child {FileInstance} objects
     def paths
-      instances.collect { |i| i.path }
+      instances.collect(&:path)
     end
 
     # @api internal
@@ -76,8 +74,8 @@ module Moab
     # @param other [FileManifestation] The {FileManifestation} object to compare with self
     # @return [Boolean] True if {FileManifestation} objects have same content
     def ==(other)
-      return false unless (other.respond_to?(:signature) && other.respond_to?(:instances)) # Cannot equal an incomparable type!
-      (self.signature == other.signature) && (self.instances == other.instances)
+      return false unless other.respond_to?(:signature) && other.respond_to?(:instances) # Cannot equal an incomparable type!
+      (signature == other.signature) && (instances == other.instances)
     end
   end
 end

data/lib/moab/file_signature.rb

@@ -1,5 +1,3 @@
-require 'moab'
-
 module Moab
   # The fixity properties of a file, used to determine file content equivalence regardless of filename.
   # Placing this data in a class by itself facilitates using file size together with the MD5 and SHA1 checksums
@@ -46,19 +44,19 @@ module Moab
 
     # @attribute
     # @return [Integer] The size of the file in bytes
-    attribute :size, Integer, :on_save => Proc.new { |n| n.to_s }
+    attribute :size, Integer, :on_save => proc { |n| n.to_s }
 
     # @attribute
     # @return [String] The MD5 checksum value of the file
-    attribute :md5, String, :on_save => Proc.new { |n| n.nil? ? "" : n.to_s }
+    attribute :md5, String, :on_save => proc { |n| n.nil? ? "" : n.to_s }
 
     # @attribute
     # @return [String] The SHA1 checksum value of the file
-    attribute :sha1, String, :on_save => Proc.new { |n| n.nil? ? "" : n.to_s }
+    attribute :sha1, String, :on_save => proc { |n| n.nil? ? "" : n.to_s }
 
     # @attribute
     # @return [String] The SHA256 checksum value of the file
-    attribute :sha256, String, :on_save => Proc.new { |n| n.nil? ? "" : n.to_s }
+    attribute :sha256, String, :on_save => proc { |n| n.nil? ? "" : n.to_s }
 
     KNOWN_ALGOS = {
       md5: proc { Digest::MD5.new },
@@ -106,12 +104,11 @@ module Moab
 
    # @return [Hash<Symbol,String>] A hash of the checksum data
     def checksums
-      checksum_hash = Hash.new
-      checksum_hash[:md5] = @md5
-      checksum_hash[:sha1] = @sha1
-      checksum_hash[:sha256] = @sha256
-      checksum_hash.delete_if { |_key, value| value.nil? or value.empty? }
-      checksum_hash
+      {
+        md5: md5,
+        sha1: sha1,
+        sha256: sha256
+      }.reject { |_key, value| value.nil? || value.empty? }
     end
 
     # @return [Boolean] The signature contains all of the 3 desired checksums
@@ -120,24 +117,21 @@ module Moab
     end
 
     # @api internal
-    # @return [Hash<Symbol,String>] A hash of fixity data from this signataure object
+    # @return [Hash<Symbol => String>] A hash of fixity data from this signataure object
     def fixity
-      fixity_hash = Hash.new
-      fixity_hash[:size] = @size.to_s
-      fixity_hash.merge!(checksums)
-      fixity_hash
+      { size: size.to_s }.merge(checksums)
     end
 
     # @api internal
     # @param other [FileSignature] The other file signature being compared to this signature
     # @return [Boolean] Returns true if self and other have comparable fixity data.
     def eql?(other)
-      return false unless (other.respond_to?(:size) && other.respond_to?(:checksums))
-      return false if self.size.to_i != other.size.to_i
-      self_checksums = self.checksums
+      return false unless other.respond_to?(:size) && other.respond_to?(:checksums)
+      return false if size.to_i != other.size.to_i
+      self_checksums = checksums
       other_checksums = other.checksums
       matching_keys = self_checksums.keys & other_checksums.keys
-      return false if matching_keys.size == 0
+      return false if matching_keys.empty?
       matching_keys.each do |key|
         return false if self_checksums[key] != other_checksums[key]
       end
@@ -181,31 +175,26 @@ module Moab
     # @return [FileSignature] The full signature derived from the file, unless the fixity is inconsistent with current values
     def normalized_signature(pathname)
       sig_from_file = FileSignature.new.signature_from_file(pathname)
-      if self.eql?(sig_from_file)
-        # The full signature from file is consistent with current values
-        return sig_from_file
-      else
-        # One or more of the fixity values is inconsistent, so raise an exception
-        raise "Signature inconsistent between inventory and file for #{pathname}: #{self.diff(sig_from_file).inspect}"
-      end
+      return sig_from_file if eql?(sig_from_file)
+      # The full signature from file is consistent with current values, or...
+      # One or more of the fixity values is inconsistent, so raise an exception
+      raise "Signature inconsistent between inventory and file for #{pathname}: #{diff(sig_from_file).inspect}"
     end
 
     # @return [Hash<Symbol,String>] Key is type (e.g. :sha1), value is checksum names (e.g. ['SHA-1', 'SHA1'])
-    def FileSignature.checksum_names_for_type
-      names_for_type = Hash.new
-      names_for_type[:md5] = ['MD5']
-      names_for_type[:sha1] = ['SHA-1', 'SHA1']
-      names_for_type[:sha256] = ['SHA-256', 'SHA256']
-      names_for_type
+    def self.checksum_names_for_type
+      {
+        md5: ['MD5'],
+        sha1: ['SHA-1', 'SHA1'],
+        sha256: ['SHA-256', 'SHA256']
+      }
     end
 
    # @return [Hash<String, Symbol>] Key is checksum name (e.g. MD5), value is checksum type (e.g. :md5)
-    def FileSignature.checksum_type_for_name
-      type_for_name = Hash.new
-      self.checksum_names_for_type.each do |type, names|
-        names.each do |name|
-          type_for_name[name] = type
-        end
+    def self.checksum_type_for_name
+      type_for_name = {}
+      checksum_names_for_type.each do |type, names|
+        names.each { |name| type_for_name[name] = type }
       end
       type_for_name
     end

data/lib/moab/signature_catalog.rb

@@ -1,5 +1,3 @@
-require 'moab'
-
 module Moab
   # A digital object's Signature Catalog is derived from an filtered aggregation of the file inventories
   # of a digital object's set of versions.  (see {#update})
@@ -32,8 +30,8 @@ module Moab
 
     # (see Serializable#initialize)
     def initialize(opts = {})
-      @entries = Array.new
-      @signature_hash = Hash.new
+      @entries = []
+      @signature_hash = {}
       super(opts)
     end
 
@@ -43,7 +41,7 @@ module Moab
 
     # @attribute
     # @return [Integer] The ordinal version number
-    attribute :version_id, Integer, :tag => 'versionId', :key => true, :on_save => Proc.new { |n| n.to_s }
+    attribute :version_id, Integer, :tag => 'versionId', :key => true, :on_save => proc { |n| n.to_s }
 
     # @return [String] The unique identifier concatenating digital object id with version id
     def composite_key
@@ -64,7 +62,7 @@ module Moab
 
     # @attribute
     # @return [Integer] The total number of data files (dynamically calculated)
-    attribute :file_count, Integer, :tag => 'fileCount', :on_save => Proc.new { |t| t.to_s }
+    attribute :file_count, Integer, :tag => 'fileCount', :on_save => proc { |t| t.to_s }
 
     def file_count
       entries.size
@@ -72,7 +70,7 @@ module Moab
 
     # @attribute
     # @return [Integer] The total size (in bytes) of all data files (dynamically calculated)
-    attribute :byte_count, Integer, :tag => 'byteCount', :on_save => Proc.new { |t| t.to_s }
+    attribute :byte_count, Integer, :tag => 'byteCount', :on_save => proc { |t| t.to_s }
 
     def byte_count
       entries.inject(0) { |sum, entry| sum + entry.signature.size.to_i }
@@ -80,7 +78,7 @@ module Moab
 
     # @attribute
     # @return [Integer] The total disk usage (in 1 kB blocks) of all data files (estimating du -k result) (dynamically calculated)
-    attribute :block_count, Integer, :tag => 'blockCount', :on_save => Proc.new { |t| t.to_s }
+    attribute :block_count, Integer, :tag => 'blockCount', :on_save => proc { |t| t.to_s }
 
     def block_count
       block_size = 1024
@@ -89,7 +87,7 @@ module Moab
 
     # @return [Array<String>] The data fields to include in summary reports
     def summary_fields
-      %w{digital_object_id version_id catalog_datetime file_count byte_count block_count}
+      %w[digital_object_id version_id catalog_datetime file_count byte_count block_count]
     end
 
     # @attribute
@@ -134,7 +132,7 @@ module Moab
       end
       group.files.each do |file|
         unless file.signature.complete?
-          if @signature_hash.has_key?(file.signature)
+          if @signature_hash.key?(file.signature)
             file.signature = @signature_hash.find { |k, _v| k == file.signature }[0]
           elsif group_pathname
             file_pathname = group_pathname.join(file.instances[0].path)
@@ -153,7 +151,7 @@ module Moab
     def update(version_inventory, data_pathname)
       version_inventory.groups.each do |group|
         group.files.each do |file|
-          unless @signature_hash.has_key?(file.signature)
+          unless @signature_hash.key?(file.signature)
             entry = SignatureCatalogEntry.new
             entry.version_id = version_inventory.version_id
             entry.group_id = group.group_id
@@ -183,11 +181,11 @@ module Moab
       version_inventory.groups.each do |group|
         group_addtions = FileGroup.new(:group_id => group.group_id)
         group.files.each do |file|
-          unless @signature_hash.has_key?(file.signature)
+          unless @signature_hash.key?(file.signature)
             group_addtions.add_file_instance(file.signature, file.instances[0])
           end
         end
-        version_additions.groups << group_addtions if group_addtions.files.size > 0
+        version_additions.groups << group_addtions unless group_addtions.files.empty?
       end
       version_additions
     end

data/lib/moab/signature_catalog_entry.rb

@@ -1,5 +1,3 @@
-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)
@@ -25,7 +23,7 @@ module Moab
 
     # @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 { |n| n.to_s }
 
     # @attribute
     # @return [String] The name of the file group

data/lib/moab/storage_object.rb

@@ -1,5 +1,3 @@
-require 'moab'
-
 module Moab
   # A class to represent a digital object's repository storage location
   # and methods for
@@ -122,27 +120,25 @@ module Moab
     # @param version_id [Integer] The version identifier of an object version
     # @return [String] The directory name of the version, relative to the digital object home directory (e.g v0002)
     def self.version_dirname(version_id)
-      ("v%04d" % version_id)
+      format("v%04d", version_id)
     end
 
     # @return [Array<Integer>] The list of all version ids for this object
     def version_id_list
-      list = Array.new
+      list = []
       return list unless @object_pathname.exist?
       @object_pathname.children.each do |dirname|
         vnum = dirname.basename.to_s
-        if vnum =~ /^v(\d+)$/
-          list << vnum[1..-1].to_i
-        end
+        list << vnum[1..-1].to_i if vnum =~ /^v(\d+)$/
       end
       list.sort
     end
 
     # @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| storage_object_version(id) }
     end
-    alias :versions :version_list
+    alias versions version_list
 
     # @return [Boolean] true if there are no versions yet in this object
     def empty?
@@ -152,12 +148,12 @@ module Moab
     # @api external
     # @return [Integer] The identifier of the latest version of this object, or 0 if no versions exist
     def current_version_id
-      @current_version_id ||= self.version_id_list.last || 0
+      @current_version_id ||= version_id_list.last || 0
     end
 
     # @return [StorageObjectVersion] The most recent version in the storage object
     def current_version
-      self.storage_object_version(current_version_id)
+      storage_object_version(current_version_id)
     end
 
     # @api internal
@@ -191,21 +187,18 @@ module Moab
     # * Version 0 is a special case used to generate empty manifests
     # * 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)
-      else
-        raise "Version ID not specified"
-      end
+      raise "Version ID not specified" unless version_id
+      StorageObjectVersion.new(self, version_id)
     end
 
     # @return [VerificationResult] Return result of storage verification
     def verify_object_storage
       result = VerificationResult.new(digital_object_id)
-      self.version_list.each do |version|
+      version_list.each do |version|
         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?(&:verified)
       result
     end
 
@@ -216,7 +209,7 @@ module Moab
       recovery_object = StorageObject.new(@digital_object_id, recovery_path, false)
       recovery_object.versions.each do |recovery_version|
         version_id = recovery_version.version_id
-        storage_version = self.storage_object_version(version_id)
+        storage_version = storage_object_version(version_id)
         # rename/save the original
         storage_version.deactivate(timestamp)
         # copy the recovered version into place

data/lib/moab/storage_object_validator.rb

@@ -1,4 +1,3 @@
-require 'moab'
 require 'set'
 
 module Moab
@@ -59,11 +58,11 @@ module Moab
           NO_SIGNATURE_CATALOG => "Version %{addl}: Missing signatureCatalog.xml",
           NO_MANIFEST_INVENTORY => "Version %{addl}: Missing manifestInventory.xml",
           NO_FILES_IN_MANIFEST_DIR => "Version %{addl}: No files present in manifest dir",
-          METADATA_SUB_DIRS_DETECTED => "Version %{addl}: metadata directory should only contain files, not directories",
+          METADATA_SUB_DIRS_DETECTED => "Version %{version}: metadata directory should only contain files, not directories. Found directory: %{dir}",
           VERSIONS_NOT_IN_ORDER => "Should contain only sequential version directories. Current directories: %{addl}",
           NO_FILES_IN_METADATA_DIR => "Version %{addl}: No files present in metadata dir",
           NO_FILES_IN_CONTENT_DIR => "Version %{addl}: No files present in content dir",
-          CONTENT_SUB_DIRS_DETECTED => "Version %{addl}: content directory should only contain files, not directories",
+          CONTENT_SUB_DIRS_DETECTED => "Version %{version}: content directory should only contain files, not directories. Found directory: %{dir}",
           BAD_SUB_DIR_IN_CONTENT_DIR => "Version %{addl}: content directory has forbidden sub-directory name: vnnnn or #{FORBIDDEN_CONTENT_SUB_DIRS}"
         }.freeze
     end
@@ -139,7 +138,8 @@ module Moab
       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?
-      errors << result_hash(CONTENT_SUB_DIRS_DETECTED, basename(version_path)) if contains_sub_dir?(content_dir_path) && !allow_content_subdirs
+      content_sub_dir = contains_sub_dir?(content_dir_path)
+      errors << result_hash(CONTENT_SUB_DIRS_DETECTED, version: basename(version_path), dir: content_sub_dir) if content_sub_dir && !allow_content_subdirs
       if allow_content_subdirs && contains_sub_dir?(content_dir_path) && contains_forbidden_content_sub_dir?(content_dir_path)
         errors << result_hash(BAD_SUB_DIR_IN_CONTENT_DIR, basename(version_path))
       end
@@ -158,7 +158,8 @@ module Moab
       errors = []
       metadata_dir_path = File.join(version_path, DATA_DIR, METADATA_DIR)
       errors << result_hash(NO_FILES_IN_METADATA_DIR, basename(version_path)) if directory_entries(metadata_dir_path).empty?
-      errors << result_hash(METADATA_SUB_DIRS_DETECTED, basename(version_path)) if contains_sub_dir?(metadata_dir_path)
+      metadata_sub_dir = contains_sub_dir?(metadata_dir_path)
+      errors << result_hash(METADATA_SUB_DIRS_DETECTED, version: basename(version_path), dir: metadata_sub_dir) if metadata_sub_dir
       errors
     end
 
@@ -204,12 +205,25 @@ module Moab
       path.split(File::SEPARATOR)[-1]
     end
 
-    def result_hash(response_code, addl = nil)
-      { response_code => error_code_msg(response_code, addl) }
+    # @param [Integer] response_code one of the recognized values in error_code_to_messages
+    # @param [Hash<Symbol => String>, String] msg_args Value(s) folded into the error message
+    # @return [Hash<Integer => String>] single key/value Hash
+    # @example Usage
+    #  sov.result_hash(10, '/some/dir')
+    #  sov.result_hash(10, addl: '/some/dir') # equivalent
+    #  sov.result_hash(8, version: '3', dir: '/other/dir')
+    def result_hash(response_code, msg_args = nil)
+      { response_code => error_code_msg(response_code, msg_args) }
     end
 
     def error_code_msg(response_code, addl = nil)
-      format(self.class.error_code_to_messages[response_code], addl: addl)
+      arg_hash = {}
+      if addl.is_a?(Hash)
+        arg_hash.merge!(addl)
+      else
+        arg_hash[:addl] = addl
+      end
+      self.class.error_code_to_messages[response_code] % arg_hash
     end
 
     def check_required_manifest_files(dir, version)