zipr 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59ff464e79a2fcb648409fa45f1732713f282b34
+  data.tar.gz: 3fad749fa16e837f55419322237e945da88e6156
+SHA512:
+  metadata.gz: c16b81553150ba9eb0953136387c2fbd9f6d31e57f630a3501005a7eb0dd4d80bc77fbfbdaa8124ccc4e538cfc429361c7ab5cf77b1d82e1018bf0b09e17977c
+  data.tar.gz: 548670732186cf43020dd5f47a5d147b6868669da7be05da055967d76ffd1b55c32e23921fcdb40f12d7d9b2a92e325c535944ace9cff2fef02d4bdaf9e6f45f

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/lib/zipr.rb

@@ -0,0 +1,30 @@
+#
+# Author:: Alex Munoz (<amunoz951@gmail.com>)
+# Copyright:: Copyright (c) 2020 Alex Munoz
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'zip' # rubyzip gem
+require 'digest'
+require 'easy_io'
+require 'json'
+require 'tmpdir'
+require 'fileutils'
+require 'seven_zip_ruby_am'
+require 'os'
+
+require_relative 'zipr/config'
+require_relative 'zipr/archive'
+require_relative 'zipr/helper'
+require_relative 'zipr/sfx'

data/lib/zipr/archive.rb

@@ -0,0 +1,462 @@
+module Zipr
+  class Archive
+    @cache_path = "#{Zipr.config['paths']['cache']}/zipr"
+    attr_accessor :checksum_path, :options, :checksums, :mode
+
+    #
+    # 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.
+    #     :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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # Description:
+    #   Writes the archive's checksum file.
+    # Returns:
+    #   A hash of all known checksums for the archive.
+    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
+
+    # Description:
+    #   Loads the known checksums for this archive from the checksum file.
+    # Returns:
+    #   A hash of all known checksums for the archive.
+    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
+
+    #
+    # 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.
+    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
+
+    #
+    # 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.
+    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 if @checksums.nil? || @checksums.empty?
+        # If the archive doesn't exist and no checksums were found, extract all files_to_check or :all files
+        return files_to_check || :all
+      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
+
+    #
+    # 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).
+    #     default: All files and folders under the source_folder.
+    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 = []
+      files_to_check.each do |target_search|
+        files = Dir.glob(Zipr.prepend_source_folder(source_folder, target_search))
+        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
+
+    #
+    # 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.
+    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
+
+    #
+    # Description:
+    #   Defines all supported archive types.
+    # Returns:
+    #   Array of supported archive types.
+    def supported_archive_types
+      [:zip, :seven_zip]
+    end
+
+    #
+    # Description:
+    #   More readably access the archive_type option.
+    # Returns:
+    #   A symbol representing the archive type of the instance.
+    def archive_type
+      @options[:archive_type]
+    end
+
+    private
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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 ::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
+
+    def _excluded_file?(file_path, destination_path: '', exists_in_zip: false)
+      @options[:exclude_files] ||= []
+      @options[:exclude_unless_missing] ||= []
+      return true if @options[:exclude_files].any? { |e| file_path.tr('\\', '/') =~ /^#{Zipr.wildcard_to_regex(e.tr('\\', '/'))}$/i }
+      return true if ::File.exist?(destination_path) && @options[:exclude_unless_missing].any? { |e| file_path.tr('\\', '/') =~ /^#{Zipr.wildcard_to_regex(e.tr('\\', '/'))}$/i }
+      return true if exists_in_zip && @options[:exclude_unless_missing].any? { |e| file_path.tr('\\', '/') =~ /^#{Zipr.wildcard_to_regex(e.tr('\\', '/'))}$/i }
+      false
+    end
+
+    def _assign_common_accessors(options: nil, checksums: nil, mode: nil)
+      @options = options || @options || {}
+      @checksums = checksums || @checksums || {}
+      @mode = mode || @mode || :idempotent
+
+      archive_changed = ::File.exist?(@path) && @checksums['archive_checksum'] != Digest::SHA256.file(@path).hexdigest
+      outdated_checksums = @checksums.empty? || archive_changed
+      load_checksum_file if outdated_checksums # Read the checksums file if it hasn't been read yet
+    end
+
+    # TODO: Add delete method to remove something from an archive
+  end
+end

data/lib/zipr/config.rb

@@ -0,0 +1,15 @@
+module Zipr
+  module_function
+
+  def config
+    @config ||= EasyJSON.config(defaults: defaults)
+  end
+
+  def defaults
+    {
+      'paths' => {
+        'cache' => Dir.tmpdir,
+      },
+    }
+  end
+end

data/lib/zipr/helper.rb

@@ -0,0 +1,53 @@
+module Zipr
+  module_function
+
+  def seven_zip_executable_path
+    path = node['seven_zip']['home']
+    EasyIO.logger.debug "7-zip home: '#{path}'" unless path.nil?
+    path ||= seven_zip_exe_from_registry if OS.windows?
+    EasyIO.logger.debug "7-zip path: '#{path}'"
+    ::File.join(path, OS.windows? ? '7z.exe' : '7z')
+  end
+
+  def seven_zip_exe_from_registry
+    key_path = 'SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\7zFM.exe'
+    return nil unless EasyIO::Registry.key_exists?(key_path)
+    # Read path from recommended Windows App Paths registry location
+    # docs: https://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
+    EasyIO::Registry.read(key_path, 'Path')
+  end
+
+  # returns results of all files found in the array of files, including files found by wildcard, as relative paths.
+  def flattened_paths(source_folder, files)
+    return files if source_folder.nil? || source_folder.empty?
+    result = []
+    files.each do |entry|
+      standardized_entry = "#{source_folder.tr('\\', '/')}/#{slice_source_folder(source_folder, entry)}"
+      files_found = Dir.glob(standardized_entry)
+      if files_found.empty?
+        result.push(entry)
+      else
+        result += files_found.map { |e| slice_source_folder(source_folder, e) }
+      end
+    end
+    result
+  end
+
+  def wildcard_to_regex(entry)
+    entry.gsub(/([^\.\]])\*/, '\1.*') # convert any asterisk wildcard not preceded by a period or square bracket to .*
+         .sub(/^\*/, '.*') # convert a string that starts with an asterisk to .* (not preceded by anything)
+  end
+
+  def prepend_source_folder(source_folder, entry)
+    return entry.tr('\\', '/') if source_folder.nil? || source_folder.empty? || entry.tr('\\', '/').start_with?(source_folder.tr('\\', '/'))
+    "#{source_folder.tr('\\', '/')}/#{entry.tr('\\', '/')}"
+  end
+
+  def slice_source_folder(source_folder, entry)
+    entry.tr('\\', '/').sub(source_folder.tr('\\', '/'), '').reverse.chomp('/').reverse
+  end
+
+  def checksums_folder
+    "#{@cache_path}/zipr/archive_checksums"
+  end
+end

data/lib/zipr/sfx.rb

@@ -0,0 +1,113 @@
+module Zipr
+  class SFX < Zipr::Archive
+    attr_accessor :info_file
+    attr_reader :sfx_path
+    attr_reader :sfx_cache_path
+
+    #
+    # Description:
+    #   Create an SFX archive in one 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 SFX archive being created.
+    #   see comment of method 'create' for :source_folder, :files_to_add, and :info_hash parameter information.
+    #   see comment of method 'initialize' for :temp_subfolder parameter information.
+    #   see comment of Zipr::Archive.open for remaining parameter information.
+    def self.create(path, source_folder, files_to_add: nil, info_hash: nil, temp_subfolder: nil, options: nil, checksums: nil, mode: nil)
+      sfx_archive = new(path, temp_subfolder: temp_subfolder, options: options, checksums: checksums, mode: mode) # Create new SFX instance
+      sfx_archive.create(source_folder, files_to_add: files_to_add, info_hash: info_hash)
+    end
+
+    #
+    # 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.
+    def initialize(path, temp_subfolder: nil, checksum_file: nil, options: nil, checksums: nil, mode: nil)
+      basename = ::File.basename(path).sub(/\.[^\.]+$/, '')
+      mode ||= :overwrite
+      temp_subfolder ||= basename
+      invalid_basename = basename.empty? || ::File.directory?(path)
+      if temp_subfolder.empty? || invalid_basename
+        @skip_cleanup = true
+        raise "SFX path was not complete! Ensure the path includes a filename.\n  path: #{path}" if invalid_basename
+        raise 'Subfolder provided to initialize Zipr::SFX archive was empty!'
+      end
+
+      @sfx_path = path
+      @sfx_cache_path = "#{Zipr.config['paths']['cache']}/zipr/SFX/#{temp_subfolder}"
+      @path = "#{@sfx_cache_path}/#{basename}.sfx.7z" # Inherited class uses @path for the 7z file
+      path_checksum = ::File.exist?(path) ? ::Digest::SHA256.file(path).hexdigest : 'does_not_exist'
+      @checksum_path = checksum_file || "#{@cache_path}/checksums/#{::File.basename(path)}-#{path_checksum}.txt"
+      _assign_common_accessors(options: options, checksums: checksums, mode: mode)
+      @options[:sfx] = true
+      @options[:archive_type] = :seven_zip
+    end
+
+    # Description:
+    #   Generate an info file for the SFX used for executing a command/file after extraction
+    # Parameters:
+    #   info_hash: (optional)
+    #     Title: Title for messages
+    #     BeginPrompt: Message to prompt user before launching RunProgram or ExecuteFile
+    #     Progress: Value can be "yes" or "no". Default value is "yes".
+    #     RunProgram: Command for executing. Default value is "setup.exe". Use double backslashes for directories.
+    #     InstallPath: Directory where files will be extracted and run from. Default value is ".\\" - Ensure the directory ends with a double slash.
+    #     Delete: Directory to delete after launched executable exits. Use double backslashes.
+    #     ExecuteFile: Name of file for executing
+    #     ExecuteParameters: Parameters for "ExecuteFile"
+    def generate_info_file(info_hash = nil)
+      info_hash ||= {}
+      @info_file = <<-EOS.strip
+        ;!@Install@!UTF-8!
+        #{info_hash.map { |k, v| "#{k}=\"#{v}\"" }.join("\n")}
+        ;!@InstallEnd@!
+      EOS
+      ::File.open("#{sfx_cache_path}/sfx_info.txt", 'wb:UTF-8') { |file| file.write(@info_file) }
+    end
+
+    #
+    # Description:
+    #   Create the SFX package
+    # 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 SFX archive. Relative or full paths accepted. Wildcards accepted. If omitted, takes all files and folders in the source_folder.
+    #   info_hash: (optional) A hash containing the installer config info file. See comments for method 'generate_info_file' for more information.
+    def create(source_folder, files_to_add: nil, info_hash: nil)
+      changed_files = determine_files_to_add(source_folder, files_to_check: files_to_add)
+      if changed_files.empty? && ::File.exist?(@sfx_path)
+        EasyIO.logger.info 'No files in the SFX have changed. Skipping SFX creation.'
+        return [@checksum_path, @checksums]
+      end
+      EasyIO.logger.info "Creating SFX archive: #{sfx_path}"
+      add(source_folder, files_to_add: files_to_add)
+      use_info_file = !(info_hash.nil? || info_hash.empty?)
+      generate_info_file(info_hash) if use_info_file
+      sfx_module = "#{__dir__}/#{use_info_file ? '7zsd_All.sfx' : '7zS2.sfx'}"
+      sfx_components = [sfx_module] # Start with the module
+      sfx_components.push("#{sfx_cache_path}/sfx_info.txt") if ::File.exist?("#{sfx_cache_path}/sfx_info.txt") # Add the info file if it exists
+      sfx_components.push(@path) # Add the temporary .7z archive
+      ::File.open(sfx_path, 'wb') do |sfx_archive|
+        sfx_components.each do |file|
+          EasyIO.logger.debug "Adding #{file} to SFX"
+          sfx_archive.write(::File.open(file, 'rb').read)
+        end
+      end
+      EasyIO.logger.info 'SFX created successfully.'
+      [@checksum_path, update_checksum_file]
+    ensure
+      cleanup unless @skip_cleanup
+    end
+
+    #
+    # Description:
+    #   Deletes temporary files/folders used while creating this SFX
+    def cleanup
+      FileUtils.rm_rf(sfx_cache_path)
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: zipr
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Alex Munoz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: easy_io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: seven_zip_ruby_am
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.5.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.5.4
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 
+email:
+- amunoz951@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/zipr.rb
+- lib/zipr/7zS2.sfx
+- lib/zipr/7zsd_All.sfx
+- lib/zipr/archive.rb
+- lib/zipr/config.rb
+- lib/zipr/helper.rb
+- lib/zipr/sfx.rb
+homepage: https://github.com/amunoz951/zipr
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Ruby library for easily extracting and creating 7zip and zip archives idempotently.
+test_files: []