class Zipr::Archive

Attributes

checksum_path[RW]
checksums[RW]
mode[RW]
options[RW]

Public Class Methods

add(path, source_folder, files_to_add: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil) click to toggle source

Description:

Add files to an existing archive or create one if it does not exist in a single line. No additional IO handling necessary.

Returns:

Array of 2 objects: String path to the checksum file and the hash of known checksums for archive files.

Parameters:

path: The full path to the archive being added to/created.
see comment of method 'add' below for :source_folder and :files_to_add parameter information.
see comment of method 'open' above for remaining parameter information.
# File lib/zipr/archive.rb, line 40
def self.add(path, source_folder, files_to_add: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil)
  archive = new(path, options: options, checksums: checksums, mode: mode, checksum_file: checksum_file)
  archive.add(source_folder, files_to_add: files_to_add)
end
determine_files_to_add(path, source_folder, files_to_check: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil) click to toggle source

Description:

Determines what files should be added to an archive based on the options and mode provided in a single line.
Can be useful to perform actions on changing files before they are added or to determine idempotency state (like with Chef/Puppet)

Returns:

Array of 2 objects: an array of files to be added (or the :all symbol) and a hash of the known file checksums in the archive

Parameters:

path: The full path to the archive being created/examined.
see comment of method 'determine_files_to_add' for :source_folder and :files_to_check
see comment of method 'open' for remaining parameter information.
# File lib/zipr/archive.rb, line 69
def self.determine_files_to_add(path, source_folder, files_to_check: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil)
  archive = new(path, options: options, checksums: checksums, mode: mode, checksum_file: checksum_file)
  files_to_add = archive.determine_files_to_add(source_folder, files_to_check: files_to_check)
  [files_to_add, archive.checksums]
end
determine_files_to_extract(path, destination_folder, files_to_check: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil) click to toggle source

Description:

Determines what files should be extracted based on the options and mode provided.
Can be useful to perform actions on changing files before they are extracted or to determine idempotency state (like with Chef/Puppet).

Returns:

Array of 2 objects: an array of files to be extracted (or the :all symbol) and a hash of the known file checksums in the archive.

Parameters:

path: The full path to the archive being extracted/examined.
see comment of method 'determine_files_to_extract' for :destination_folder and :files_to_check parameter information.
see comment of method 'open' for remaining parameter information.
# File lib/zipr/archive.rb, line 85
def self.determine_files_to_extract(path, destination_folder, files_to_check: nil, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil)
  archive = new(path, options: options, checksums: checksums, mode: mode, checksum_file: checksum_file)
  files_to_extract = archive.determine_files_to_extract(destination_folder, files_to_check: files_to_check)
  [files_to_extract, archive.checksums]
end
extract(path, destination_folder, files_to_extract: nil, options: {}, checksums: nil, mode: :idempotent, checksum_file: nil) click to toggle source

Description:

Extract files from an archive in a single line. No additional IO handling necessary.

Returns:

Array of 2 objects: String path to the checksum file and the hash of known checksums for archive files.

Parameters:

path: The full path to the archive being extracted.
see comment of method 'extract' for :destination_folder and :files_to_extract parameter information.
see comment of method 'self.open' for remaining parameter information.
# File lib/zipr/archive.rb, line 54
def self.extract(path, destination_folder, files_to_extract: nil, options: {}, checksums: nil, mode: :idempotent, checksum_file: nil)
  archive = new(path, options: options, checksums: checksums, mode: mode, checksum_file: checksum_file)
  archive.extract(destination_folder, files_to_extract: files_to_extract)
end
new(path, options: nil, checksums: nil, mode: nil, checksum_file: nil) click to toggle source

Description:

Initializes the Archive.

Parameters:

path: The path to the existing archive or where the archive will be created.
see comment of method 'open' for remaining parameter information.
# File lib/zipr/archive.rb, line 97
def initialize(path, options: nil, checksums: nil, mode: nil, checksum_file: nil)
  @path = path
  archive_checksum = ::File.exist?(path) ? ::Digest::SHA256.file(path).hexdigest : 'does_not_exist'
  @checksum_path = checksum_file || "#{@cache_path}/checksums/#{::File.basename(path)}-#{archive_checksum}.txt"
  _assign_common_accessors(options: options, checksums: checksums, mode: mode)
  @options[:archive_type] ||= (::File.exist?(@path) ? detect_archive_type : :zip)
end
open(path, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil) { |archive_instance| ... } click to toggle source

Description:

Create an instance of the class.
Allows usage of block form.

Returns:

When used without a block, returns the instance.

Parameters:

options:
  :archive_type - The type of archive - :seven_zip or :zip - Can be omitted if the archive exists or using default. Default: :zip
  :exclude_files - Array of files to be excluded from archiving/extracting - Can be relative or exact paths.
  :exclude_unless_missing - Array of files to be excluded from archiving/extracting only if they already exist - Can be relative or exact paths.
  :exclude_unless_archive_changed - Array of files to be excluded from extracting only if the archive hasn't changed and they already exist - Use relative paths.
  :password - the archive password - currently :seven_zip is the only supported archive_type for encrypted archives.
  :silent - [true/false] No info messages if flagged
checksums: A hash of checksums of the archived files. If you checked one of the determine_files methods for idempotency first, pass the result to this parameter to avoid duplicate processing.
mode:
  :idempotent - Does not add/extract files to/from the archive if they already exist and are the exact same file, verified by checksum.
  :overwrite - Adds/Extracts all eligible files to/from the archive even if the checksums match.
  :if_missing - never overwrites any files, only adds/extracts to/from the archive if the relative path does not exist.
checksum_file: (optional) The path to the initial checksum file. Usually only needed if the archive is not kept on the disk and we need to see if extracted files have changed.
# File lib/zipr/archive.rb, line 26
def self.open(path, options: {}, checksums: {}, mode: :idempotent, checksum_file: nil, &block)
  archive_instance = new(path, options: options, checksums: checksums, mode: mode, checksum_file: checksum_file)
  block.nil? ? archive_instance : yield(archive_instance)
end

Public Instance Methods

add(source_folder, files_to_add: nil) click to toggle source

Description:

Add files to an existing archive or create one if it does not exist

Returns:

Array of 2 objects: String path to the checksum file and the hash of known checksums for archive files.

Parameters:

source_folder: The path from which relative archive paths will be derived.
files_to_add: An array of files to be added to the archive. Relative or full paths accepted. If omitted, takes all files and folders in the source_folder.
# File lib/zipr/archive.rb, line 138
def add(source_folder, files_to_add: nil)
  files_to_add = determine_files_to_add(source_folder, files_to_check: files_to_add)
  FileUtils.mkdir_p(::File.dirname(@path)) unless ::File.directory?(::File.dirname(@path))

  case @options[:archive_type]
  when :zip
    _add_to_zip(source_folder, files_to_add)
  when :seven_zip
    _add_to_seven_zip(source_folder, files_to_add)
  else
    raise "':#{@options[:archive_type]}' is not a supported archive type!"
  end
  raise "Failed to create archive at #{@path}!" unless ::File.file?(@path)
  EasyIO.logger.info "Archiving to #{::File.basename(@path)} finished." unless @options[:silent]
  archive_checksums = @options[:sfx] ? @checksums : update_checksum_file # Don't update the checksum file yet if it's an SFX
  [@checksum_path, archive_checksums]
end
archive_type() click to toggle source

Description:

More readably access the archive_type option.

Returns:

A symbol representing the archive type of the instance.
# File lib/zipr/archive.rb, line 306
def archive_type
  @options[:archive_type]
end
detect_archive_type(archive_types = supported_archive_types) click to toggle source

Description:

Detects what kind of archive the existing file is.

Returns:

The type of archive detected.

Parameters:

archive_types: (optional) The array of archive_types to try. Be default, tries all archive types.
# File lib/zipr/archive.rb, line 274
def detect_archive_type(archive_types = supported_archive_types)
  try_archive_type = archive_types.shift
  case try_archive_type
  when :zip
    ::Zip::File.open(@path) { |_archive_file| } # Test if the file can be opened as a zip file
  when :seven_zip
    SevenZipRuby::Reader.open_file(@path) { |_archive_file| } # Test if the file can be opened as a 7z file
  else
    raise "Archive type for #{try_archive_type} not implemented! Add it to Zipr::Archive.detect_archive_type definition."
  end
  @archive_type = try_archive_type
rescue ::Zip::Error, StandardError
  remaining_message = archive_types.empty? ? 'No remaining types to attempt!' : "Attempting remaining types (#{archive_types.join(', ')})..."
  EasyIO.logger.debug "Archive does not appear to be a #{try_archive_type}. #{remaining_message}"
  return detect_archive_type(archive_types) unless archive_types.empty? # Try the remaining archive types unless none are left
  raise "Archive type for #{@path} could not be detected! Ensure it is in the list of supported types (#{supported_archive_types.join(', ')})."
end
determine_files_to_add(source_folder, files_to_check: nil) click to toggle source

Description:

Determines what files should be added to an archive based on the options and mode provided.

Returns:

An array of files to be added (or the :all symbol).

Parameters:

source_folder: The filesystem directory where files are being added from.
files_to_check: Array of files intended to be added to an archive. Can be exact names/paths or names/paths with wildcards (glob style) or a Regexp.
  default: All files and folders under the source_folder.
# File lib/zipr/archive.rb, line 239
def determine_files_to_add(source_folder, files_to_check: nil)
  files_to_check ||= Dir.glob("#{source_folder}/**/*".tr('\\', '/')) if files_to_check.nil?
  files_to_add = []
  source_folder_glob = nil
  files_to_check.each do |target_search|
    files = if target_search.is_a?(Regexp)
              source_folder_glob ||= Dir.glob("#{source_folder.tr('\\', '/')}/**/*")
              source_folder_glob.select do |path|
                path =~ target_search
              end
              source_folder_glob.select { |path| path.to_s =~ target_search }
            else
              Dir.glob(Zipr.prepend_source_folder(source_folder, target_search))
            end
    files.each do |source_file|
      relative_path = Zipr.slice_source_folder(source_folder, source_file)
      exists_in_zip = !!@checksums[relative_path]
      next if @mode == :if_missing && exists_in_zip
      next if _excluded_file?(relative_path, exists_in_zip: exists_in_zip) || _excluded_file?(source_file, exists_in_zip: exists_in_zip)
      next if @mode == :idempotent && ::File.file?(source_file) && @checksums[relative_path] == Digest::SHA256.file(source_file).hexdigest
      next if ::File.directory?(source_file) && @checksums[relative_path] == 'directory'
      EasyIO.logger.debug "'#{relative_path}' would be added to archive..."
      files_to_add.push(source_file)
    end
  end
  files_to_add
end
determine_files_to_extract(destination_folder, files_to_check: nil) click to toggle source

Description:

Determines what files should be extracted based on the options and mode provided.

Returns:

An array of files to be extracted (or the :all symbol).

Parameters:

destination_folder: Where the files would be extracted to.
files_to_check: Array of files intended to be extracted from an archive. Should be relative names/paths with or without asterisk wildcards or a regular expression.
  default: All files and folders in the archive.
# File lib/zipr/archive.rb, line 207
def determine_files_to_extract(destination_folder, files_to_check: nil)
  files_to_check ||= :all # defaults to :all files

  unless ::File.exist?(@path)
    # If the archive doesn't exist but checksums were provided, check for files to extract based off of checksums
    return @checksums.select { |entry_name, checksum| _extract_file?(entry_name, checksum == 'directory', destination_folder, files_to_check) }.keys unless @checksums.nil? || @checksums.empty?
    # If the archive doesn't exist and no checksums were found, extract all files_to_check
    return files_to_check
  end

  files_to_extract = case @options[:archive_type]
                     when :zip
                       _determine_zip_files_to_extract(destination_folder, files_to_check)
                     when :seven_zip
                       _determine_seven_zip_files_to_extract(destination_folder, files_to_check)
                     else
                       raise "':#{@options[:archive_type]}' is not a supported archive type!"
                     end

  EasyIO.logger.debug "Files to extract: #{files_to_extract.empty? ? 'none' : JSON.pretty_generate(files_to_extract)}"
  files_to_extract
end
extract(destination_folder, files_to_extract: nil) click to toggle source

Description:

Extract files from an archive

Returns:

Array of 2 objects: String path to the checksum file and the hash of known checksums for archive files.

Parameters:

path: The full path to the archive being extracted.
destination_folder: The path where files will be extracted to.
files_to_extract: An array of files to be extracted from the archive. Relative paths should be used. If omitted, extracts all contents of the archive.
# File lib/zipr/archive.rb, line 114
def extract(destination_folder, files_to_extract: nil)
  raise "Unable to extract #{@path}! The file does not exist!" unless ::File.file?(@path)
  @options[:overwrite] = @mode != :if_missing
  files_to_extract = determine_files_to_extract(destination_folder, files_to_check: files_to_extract)

  case @options[:archive_type]
  when :zip
    _extract_zip(destination_folder, files_to_extract)
  when :seven_zip
    _extract_seven_zip(destination_folder, files_to_extract)
  end

  EasyIO.logger.info "Extracting #{::File.basename(@path)} finished." unless @options[:silent]
  [@checksum_path, update_checksum_file]
end
load_checksum_file() click to toggle source

Description:

Loads the known checksums for this archive from the checksum file.

Returns:

A hash of all known checksums for the archive.
# File lib/zipr/archive.rb, line 175
def load_checksum_file
  @checksums = if ::File.exist?(@checksum_path) # Read the checksums file if it hasn't been read yet
                 file_content = ::File.read(@checksum_path)
                 JSON.parse(file_content)
               else
                 {}
               end
end
supported_archive_types() click to toggle source

Description:

Defines all supported archive types.

Returns:

Array of supported archive types.
# File lib/zipr/archive.rb, line 297
def supported_archive_types
  [:zip, :seven_zip]
end
update_checksum_file() click to toggle source

Description:

Writes the archive's checksum file.

Returns:

A hash of all known checksums for the archive.
# File lib/zipr/archive.rb, line 161
def update_checksum_file
  archive_path = @options[:sfx] ? @sfx_path : @path
  archive_checksum = ::Digest::SHA256.file(archive_path).hexdigest
  @checksums['archive_checksum'] = archive_checksum
  @checksum_path = "#{@cache_path}/checksums/#{::File.basename(archive_path)}-#{archive_checksum}.txt"
  FileUtils.mkdir_p(::File.dirname(checksum_path)) unless ::File.directory?(::File.dirname(checksum_path))
  ::File.write(checksum_path, @checksums.to_json)
  @checksums
end
view_file(relative_path) click to toggle source

Description:

Read a file inside a zip file without extracting it to the filesystem.
Currently only supports :zip files

Returns:

A string containing the file contents.

Parameters:

relative_path: The path inside the archive for the file to view.
# File lib/zipr/archive.rb, line 192
def view_file(relative_path)
  raise 'Reading files inside a 7zip archive is not yet supported!' if @options[:archive_type] == :seven_zip
  EasyIO.logger.debug "Reading #{@path} // #{relative_path}..."
  ::Zip::File.open(@path).read(relative_path)
end

Private Instance Methods

_add_item(source_file, add_directory_lambda, add_file_lambda, source_folder) click to toggle source
# File lib/zipr/archive.rb, line 409
def _add_item(source_file, add_directory_lambda, add_file_lambda, source_folder)
  relative_path = source_file.tr('\\', '/')
  relative_path.slice!(source_folder.tr('\\', '/'))
  relative_path = relative_path.reverse.chomp('/').reverse
  EasyIO.logger.info "Adding #{relative_path}..." unless @options[:silent]
  if ::File.directory?(source_file)
    add_directory_lambda.call(relative_path)
    archive_item_checksum = 'directory'
  else
    add_file_lambda.call(relative_path)
    archive_item_checksum = Digest::SHA256.file(source_file).hexdigest
  end

  @checksums[relative_path] = archive_item_checksum
end
_add_to_seven_zip(source_folder, files_to_add) click to toggle source
# File lib/zipr/archive.rb, line 367
def _add_to_seven_zip(source_folder, files_to_add)
  if files_to_add.empty?
    EasyIO.logger.info 'Skipping adding of files to archive. No files have changed.'
    return
  end
  params = @options.reject { |k, _v| k == :sfx }
  SevenZipRuby::Writer.open_file("#{@path}.tmp", params) do |seven_zip_archive|
    EasyIO.logger.info "Adding to #{@path}..." unless @options[:silent]
    _keep_unchanged_seven_zip_files(seven_zip_archive, source_folder, files_to_add) unless @mode == :overwrite
    files_to_add.each do |source_file|
      add_directory_lambda = ->(relative_path) { seven_zip_archive.mkdir(relative_path) }
      add_file_lambda = ->(relative_path) { seven_zip_archive.add_file(source_file, as: relative_path) }
      _add_item(source_file, add_directory_lambda, add_file_lambda, source_folder)
    end
  end
  FileUtils.mv("#{@path}.tmp", @path, force: true)
end
_add_to_zip(source_folder, files_to_add) click to toggle source
# File lib/zipr/archive.rb, line 352
def _add_to_zip(source_folder, files_to_add)
  if files_to_add.empty?
    EasyIO.logger.info 'Skipping adding of files to archive. No files have changed.'
    return
  end
  ::Zip::File.open(@path, ::Zip::File::CREATE) do |zip_archive|
    EasyIO.logger.info "Adding to #{@path}..." unless @options[:silent]
    files_to_add.each do |source_file|
      add_directory_lambda = ->(relative_path) { zip_archive.mkdir(relative_path) }
      add_file_lambda = ->(relative_path) { zip_archive.add(relative_path, source_file) { :overwrite } }
      _add_item(source_file, add_directory_lambda, add_file_lambda, source_folder)
    end
  end
end
_assign_checksums(checksums) click to toggle source
# File lib/zipr/archive.rb, line 476
def _assign_checksums(checksums)
  return load_checksum_file if checksums.nil? || checksums.empty? # Read the checksums file if it hasn't been read yet
  @checksums = checksums || {}
end
_assign_common_accessors(options: nil, checksums: nil, mode: nil) click to toggle source
# File lib/zipr/archive.rb, line 469
def _assign_common_accessors(options: nil, checksums: nil, mode: nil)
  _assign_checksums(checksums)
  @options = options || @options || {}
  @mode = mode || @mode || :idempotent
  @archive_changed = (::File.exist?(@path) && @checksums['archive_checksum'] != Digest::SHA256.file(@path).hexdigest) || !::File.exist?(@checksum_path)
end
_convert_backslashes_and_cast_to_regexp(path) click to toggle source
# File lib/zipr/archive.rb, line 463
def _convert_backslashes_and_cast_to_regexp(path)
  return path if path.is_a?(Regexp) # If it's already a regexp, leave it alone
  path = path.tr('\\', '/')
  /^#{Zipr.wildcard_to_regexp(path)}$/i
end
_determine_seven_zip_files_to_extract(destination_folder, files_to_check) click to toggle source
# File lib/zipr/archive.rb, line 433
def _determine_seven_zip_files_to_extract(destination_folder, files_to_check)
  files_to_extract = []
  SevenZipRuby::Reader.open_file(@path, @options) do |seven_zip_archive|
    files_to_extract = seven_zip_archive.entries.select { |archive_item| _extract_file?(archive_item.path, archive_item.directory?, destination_folder, files_to_check) }.map(&:path)
  end
  files_to_extract
end
_determine_zip_files_to_extract(destination_folder, files_to_check) click to toggle source
# File lib/zipr/archive.rb, line 425
def _determine_zip_files_to_extract(destination_folder, files_to_check)
  files_to_extract = []
  ::Zip::File.open(@path) do |archive_items|
    files_to_extract = archive_items.select { |archive_item| _extract_file?(archive_item.name, archive_item.ftype == :directory, destination_folder, files_to_check) }.map(&:name)
  end
  files_to_extract
end
_excluded_file?(file_path, destination_path: '', exists_in_zip: false) click to toggle source
# File lib/zipr/archive.rb, line 452
def _excluded_file?(file_path, destination_path: '', exists_in_zip: false)
  @options[:exclude_files] ||= []
  @options[:exclude_unless_missing] ||= []
  @options[:exclude_unless_archive_changed] ||= []
  return true if @options[:exclude_files].any? { |e| file_path.tr('\\', '/') =~ _convert_backslashes_and_cast_to_regexp(e) }
  return true if ::File.exist?(destination_path) && @options[:exclude_unless_missing].any? { |e| file_path.tr('\\', '/') =~ _convert_backslashes_and_cast_to_regexp(e) }
  return true if exists_in_zip && @options[:exclude_unless_missing].any? { |e| file_path.tr('\\', '/') =~ _convert_backslashes_and_cast_to_regexp(e) }
  return true if !@archive_changed && ::File.exist?(destination_path) && @options[:exclude_unless_archive_changed].any? { |e| file_path.tr('\\', '/') =~ _convert_backslashes_and_cast_to_regexp(e) }
  false
end
_extract_file?(archive_entry_name, is_a_directory, destination_folder, files_to_check) click to toggle source
# File lib/zipr/archive.rb, line 441
def _extract_file?(archive_entry_name, is_a_directory, destination_folder, files_to_check)
  destination_path = "#{destination_folder}/#{archive_entry_name}"
  return false unless files_to_check == :all || files_to_check.include?(archive_entry_name) # Make sure the file is in the whitelist if it was provided
  return false if archive_entry_name == 'archive_checksum'
  return false if ::File.directory?(destination_path) && is_a_directory # Archive item is a directory and the destination directory exists
  return false if @mode == :if_missing && ::File.exist?(destination_path) # File exists and we're not overwriting existing files due to the mode
  return false if _excluded_file?(archive_entry_name, destination_path: destination_path) # File is excluded in :options
  return false if @mode == :idempotent && ::File.file?(destination_path) && ::Digest::SHA256.file(destination_path).hexdigest == @checksums[archive_entry_name] # Checksum of destination file matches checksum in archive
  true
end
_extract_item(destination_folder, files_to_extract, archive_entry_name, is_directory, extract_item_lambda) click to toggle source
# File lib/zipr/archive.rb, line 332
def _extract_item(destination_folder, files_to_extract, archive_entry_name, is_directory, extract_item_lambda)
  destination_path = ::File.join(destination_folder.tr('\\', '/'), archive_entry_name)
  return unless files_to_extract.nil? || files_to_extract == :all || files_to_extract.include?(archive_entry_name)
  if ::File.exist?(destination_path)
    return unless @options[:overwrite] # skip extract if the file exists and overwrite is false
    FileUtils.rm(destination_path)
  end
  if is_directory
    FileUtils.mkdir_p(destination_path)
    @checksums[archive_entry_name.tr('\\', '/')] = 'directory'
    return
  end

  full_destination_folder = ::File.dirname(destination_path)
  FileUtils.mkdir_p(full_destination_folder) unless ::File.directory?(full_destination_folder)
  EasyIO.logger.info "Extracting #{archive_entry_name}..." unless @options[:silent]
  extract_item_lambda.call(destination_path)
  @checksums[archive_entry_name.tr('\\', '/')] = Digest::SHA256.file(destination_path).hexdigest
end
_extract_seven_zip(destination_folder, files_to_extract) click to toggle source
# File lib/zipr/archive.rb, line 322
def _extract_seven_zip(destination_folder, files_to_extract)
  SevenZipRuby::Reader.open_file(@path, @options) do |seven_zip_archive|
    EasyIO.logger.info "Extracting to #{destination_folder}..." unless @options[:silent]
    seven_zip_archive.entries.each do |archive_item|
      extract_item_lambda = ->(_destination_path) { seven_zip_archive.extract(archive_item.index, destination_folder) }
      _extract_item(destination_folder, files_to_extract, archive_item.path, archive_item.directory?, extract_item_lambda)
    end
  end
end
_extract_zip(destination_folder, files_to_extract) click to toggle source
# File lib/zipr/archive.rb, line 312
def _extract_zip(destination_folder, files_to_extract)
  ::Zip::File.open(@path) do |archive_items|
    EasyIO.logger.info "Extracting to #{destination_folder}..." unless @options[:silent]
    archive_items.each do |archive_item|
      extract_item_lambda = ->(destination_path) { archive_item.extract(destination_path) { :overwrite } }
      _extract_item(destination_folder, files_to_extract, archive_item.name, archive_item.ftype == :directory, extract_item_lambda)
    end
  end
end
_keep_unchanged_seven_zip_files(seven_zip_archive, source_folder, files_to_add) click to toggle source
# File lib/zipr/archive.rb, line 385
def _keep_unchanged_seven_zip_files(seven_zip_archive, source_folder, files_to_add)
  existing_archive = @options[:sfx] ? @sfx_path : @path
  # TODO: Ensure it's not duplicating kept items
  if ::File.exist?(existing_archive) # If the archive already exists, save it's existing content first
    EasyIO.logger.debug "Reading existing 7z archive #{existing_archive}..."
    files_to_add_relative_paths = files_to_add.map { |file| Zipr.slice_source_folder(source_folder, file) }
    SevenZipRuby::Reader.open_file(existing_archive, @options) do |existing_seven_zip_archive|
      items_to_keep = existing_seven_zip_archive.entries.reject do |archive_item| # Don't keep (reject) entries that we'll be adding later
        reject_entry = files_to_add_relative_paths.include?(archive_item.path)
        @checksums.delete(archive_item.path) if reject_entry # Delete from @checksums if it's being rejected
        reject_entry
      end
      items_to_keep.each do |archive_item|
        EasyIO.logger.debug "Keeping #{archive_item.path}..."
        if archive_item.directory?
          seven_zip_archive.mkdir(archive_item.path)
          next
        end
        seven_zip_archive.add_data(existing_seven_zip_archive.extract_data(archive_item.index), archive_item.path)
      end
    end
  end
end