omnizip 0.4.7-aarch64-linux

data/lib/omnizip/commands/archive_create_command.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Commands
+    # Command to create .7z archives from files and directories.
+    class ArchiveCreateCommand
+      attr_reader :options
+
+      # Initialize archive create command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the archive create command.
+      #
+      # @param output_file [String] Path to output archive
+      # @param inputs [Array<String>] Paths to files/directories to archive
+      # @return [void]
+      # Execute the archive create command.
+      #
+      # Routes through the Archive facade: the handler registry
+      # picks each format's writer and applies its option semantics,
+      # so this command only translates CLI vocabulary and reports.
+      #
+      # @param output_file [String] Path to output archive
+      # @param inputs [Array<String>] Paths to files/directories to archive
+      # @return [void]
+      def run(output_file, *inputs)
+        validate_inputs(output_file, inputs)
+
+        # Apply profile settings if specified
+        opts = Omnizip::Profile.apply(options, paths: inputs)
+
+        format = (opts[:format] || detect_format(output_file)).to_sym
+        handler_opts = handler_options(format, opts)
+        verbose = opts[:verbose] || false
+
+        announce(output_file, format, handler_opts, opts, verbose)
+
+        start_time = Time.now
+
+        Omnizip::Archive.create(output_file, format: format,
+                                             **handler_opts) do |archive|
+          inputs.each do |input|
+            if File.directory?(input)
+              CliOutputFormatter.verbose_puts(
+                "Adding directory: #{input}",
+                verbose,
+              )
+              archive.add_directory(input)
+            else
+              CliOutputFormatter.verbose_puts(
+                "Adding file: #{input}",
+                verbose,
+              )
+              archive.add_file(input)
+            end
+          end
+        end
+
+        elapsed = Time.now - start_time
+        archive_size = calculate_archive_size(output_file,
+                                              handler_opts[:volume_size])
+
+        if verbose
+          puts ""
+          puts "Archive created successfully"
+          if handler_opts[:volume_size]
+            puts "Total size: #{format_bytes(archive_size)}"
+            puts "Volumes: #{count_volumes(output_file)}"
+          else
+            puts "Archive size: #{format_bytes(archive_size)}"
+          end
+          puts "Time elapsed: #{elapsed.round(2)}s"
+        else
+          puts "Created: #{output_file}"
+        end
+      end
+
+      private
+
+      def detect_format(filename)
+        case File.extname(filename).downcase
+        when ".rar" then :rar
+        else :seven_zip
+        end
+      end
+
+      # Translate the format-agnostic CLI vocabulary into the option
+      # keywords each format's writer understands; nil values drop
+      def handler_options(format, opts)
+        case format
+        when :rar
+          rar_options(opts)
+        else
+          seven_zip_options(opts)
+        end
+      end
+
+      def rar_options(opts)
+        {
+          version: opts[:rar_version],
+          compression: opts[:rar_compression]&.to_sym,
+          level: opts[:level],
+          include_mtime: opts[:include_mtime],
+          include_crc32: opts[:include_crc32],
+          solid: opts[:solid],
+          multi_volume: opts[:multi_volume],
+          volume_size: opts[:volume_size],
+          volume_naming: opts[:volume_naming],
+          password: opts[:password],
+          kdf_iterations: opts[:kdf_iterations],
+          recovery: opts[:recovery],
+          recovery_percent: opts[:recovery_percent],
+        }.compact
+      end
+
+      def seven_zip_options(opts)
+        {
+          algorithm: (opts[:algorithm] || "lzma2").to_sym,
+          level: opts[:level] || 5,
+          solid: opts.fetch(:solid, true),
+          filters: parse_filters(opts[:filters]),
+          volume_size: parse_volume_size(opts[:volume_size]),
+          password: opts[:password],
+          encrypt_headers: opts[:encrypt_headers] || false,
+        }.compact
+      end
+
+      def announce(output_file, format, handler_opts, _opts, verbose)
+        return unless verbose
+
+        CliOutputFormatter.verbose_puts(
+          "Creating archive: #{output_file}",
+          true,
+        )
+        CliOutputFormatter.verbose_puts(
+          "Format: #{format == :rar ? "RAR#{handler_opts[:version] || 5}" : '7z'}, " \
+          "Algorithm: #{handler_opts[:algorithm] || handler_opts[:compression]}, " \
+          "Level: #{handler_opts[:level]}, Solid: #{handler_opts[:solid]}",
+          true,
+        )
+        if handler_opts[:volume_size]
+          CliOutputFormatter.verbose_puts(
+            "Volume size: #{format_bytes(handler_opts[:volume_size])}",
+            true,
+          )
+        end
+        if handler_opts[:password]
+          CliOutputFormatter.verbose_puts(
+            "Encryption: enabled",
+            true,
+          )
+        end
+      end
+
+      def validate_inputs(output_file, inputs)
+        raise Omnizip::IOError, "No input files specified" if
+          inputs.empty?
+
+        inputs.each do |input|
+          unless File.exist?(input)
+            raise Omnizip::IOError, "Input not found: #{input}"
+          end
+        end
+
+        output_dir = File.dirname(output_file)
+        unless File.directory?(output_dir)
+          raise Omnizip::IOError,
+                "Output directory does not exist: #{output_dir}"
+        end
+
+        return if File.writable?(output_dir)
+
+        raise Omnizip::IOError,
+              "Output directory not writable: #{output_dir}"
+      end
+
+      def parse_filters(filter_str)
+        return [] if filter_str.nil? || filter_str.empty?
+
+        filter_str.split(",").map(&:strip).map(&:to_sym)
+      end
+
+      def format_bytes(bytes)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+
+      def parse_volume_size(size_str)
+        return nil if size_str.nil? || size_str.empty?
+
+        Omnizip::Models::SplitOptions.parse_volume_size(size_str)
+      end
+
+      def calculate_archive_size(output_file, volume_size)
+        if volume_size
+          # Count all volumes
+          base = output_file.sub(/\.\d{3}$/, "")
+          total = 0
+          volume_num = 1
+          loop do
+            volume_path = format("%s.%03d", base, volume_num)
+            break unless File.exist?(volume_path)
+
+            total += File.size(volume_path)
+            volume_num += 1
+          end
+          total
+        else
+          File.size(output_file)
+        end
+      end
+
+      def count_volumes(output_file)
+        base = output_file.sub(/\.\d{3}$/, "")
+        count = 0
+        loop do
+          volume_path = format("%s.%03d", base, count + 1)
+          break unless File.exist?(volume_path)
+
+          count += 1
+        end
+        count
+      end
+    end
+  end
+end

data/lib/omnizip/commands/archive_extract_command.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+require "fileutils"
+
+module Omnizip
+  module Commands
+    # Command to extract .7z archives to a directory.
+    class ArchiveExtractCommand
+      attr_reader :options
+
+      # Initialize archive extract command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the archive extract command.
+      #
+      # @param archive_file [String] Path to .7z archive
+      # @param output_dir [String] Directory to extract to
+      # @return [void]
+      def run(archive_file, output_dir = nil)
+        validate_input(archive_file)
+
+        # Default to current directory if not specified
+        output_dir ||= "."
+        output_dir = File.expand_path(output_dir)
+
+        verbose = options[:verbose] || false
+        patterns = Array(options[:pattern]) if options[:pattern]
+        excludes = Array(options[:exclude]) if options[:exclude]
+        regex = options[:regex]
+
+        if verbose
+          CliOutputFormatter.verbose_puts(
+            "Extracting archive: #{archive_file}",
+            true,
+          )
+          CliOutputFormatter.verbose_puts(
+            "Output directory: #{output_dir}",
+            true,
+          )
+          if patterns
+            CliOutputFormatter.verbose_puts(
+              "Include patterns: #{patterns.join(', ')}",
+              true,
+            )
+          end
+          if excludes
+            CliOutputFormatter.verbose_puts(
+              "Exclude patterns: #{excludes.join(', ')}",
+              true,
+            )
+          end
+          if regex
+            CliOutputFormatter.verbose_puts(
+              "Regex pattern: #{regex}",
+              true,
+            )
+          end
+        end
+
+        start_time = Time.now
+
+        file_count = if patterns || excludes || regex
+                       extract_with_patterns(archive_file, output_dir, verbose)
+                     else
+                       extract_archive(archive_file, output_dir, verbose)
+                     end
+
+        elapsed = Time.now - start_time
+
+        if verbose
+          puts ""
+          puts "Extraction completed successfully"
+          puts "Files extracted: #{file_count}"
+          puts "Time elapsed: #{elapsed.round(2)}s"
+        else
+          puts "Extracted #{file_count} file(s) to: #{output_dir}"
+        end
+      end
+
+      private
+
+      def validate_input(archive_file)
+        unless File.exist?(archive_file)
+          raise Omnizip::IOError, "Archive not found: #{archive_file}"
+        end
+
+        return if File.readable?(archive_file)
+
+        raise Omnizip::IOError,
+              "Archive not readable: #{archive_file}"
+      end
+
+      def extract_archive(archive_file, output_dir, verbose)
+        # Single-file compression formats decompress directly
+        case File.extname(archive_file).downcase
+        when ".gz", ".gzip"
+          extract_gzip(archive_file, output_dir, verbose)
+          return 1
+        when ".bz2", ".bzip2"
+          extract_bzip2(archive_file, output_dir, verbose)
+          return 1
+        when ".xz"
+          extract_xz(archive_file, output_dir, verbose)
+          return 1
+        end
+
+        # Archives route through the handler seam: the extension
+        # routes pick each format's reader instead of hand-rolled
+        # branches, and zip/7z/rar/tar/cpio/iso all extract the same
+        # way
+        Omnizip.extract_archive(archive_file, output_dir).size
+      rescue StandardError => e
+        raise Omnizip::CompressionError,
+              "Failed to extract archive: #{e.message}"
+      end
+
+      def extract_with_patterns(archive_file, output_dir, verbose)
+        # Route through the facade: the extension routes pick each
+        # format's reader, and the reader session holds no open
+        # resources to close
+        archive = Omnizip::Archive.open(archive_file)
+
+        # Build filter chain
+        filter = Extraction::FilterChain.new
+
+        # Add include patterns
+        if options[:pattern]
+          Array(options[:pattern]).each do |pattern|
+            filter.include_pattern(pattern)
+          end
+        end
+
+        # Add regex pattern
+        if options[:regex]
+          filter.include_pattern(Regexp.new(options[:regex]))
+        end
+
+        # Add exclude patterns
+        if options[:exclude]
+          Array(options[:exclude]).each do |pattern|
+            filter.exclude_pattern(pattern)
+          end
+        end
+
+        # Extract with filter
+        extract_options = {
+          preserve_paths: !options[:flatten],
+          flatten: options[:flatten] || false,
+          overwrite: true,
+        }
+
+        extracted = Extraction.extract_with_filter(
+          archive,
+          filter,
+          output_dir,
+          extract_options,
+        )
+
+        if verbose
+          extracted.each do |path|
+            CliOutputFormatter.verbose_puts(
+              "Extracted: #{File.basename(path)}",
+              verbose,
+            )
+          end
+        end
+
+        extracted.size
+      end
+
+      def extract_gzip(archive_file, output_dir, verbose)
+        output_file = File.join(
+          output_dir,
+          File.basename(archive_file, ".*"),
+        )
+        CliOutputFormatter.verbose_puts(
+          "Decompressing GZIP: #{archive_file}",
+          verbose,
+        )
+        FileUtils.mkdir_p(output_dir)
+        Formats::Gzip.decompress(archive_file, output_file)
+      end
+
+      def extract_bzip2(archive_file, output_dir, verbose)
+        output_file = File.join(
+          output_dir,
+          File.basename(archive_file, ".*"),
+        )
+        CliOutputFormatter.verbose_puts(
+          "Decompressing BZIP2: #{archive_file}",
+          verbose,
+        )
+        FileUtils.mkdir_p(output_dir)
+        Formats::Bzip2File.decompress(archive_file, output_file)
+      end
+
+      def extract_xz(archive_file, output_dir, verbose)
+        output_file = File.join(
+          output_dir,
+          File.basename(archive_file, ".*"),
+        )
+        CliOutputFormatter.verbose_puts(
+          "Decompressing XZ: #{archive_file}",
+          verbose,
+        )
+        FileUtils.mkdir_p(output_dir)
+        Formats::Xz.decompress(archive_file, output_file)
+      end
+    end
+  end
+end

data/lib/omnizip/commands/archive_list_command.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Commands
+    # Command to list contents of .7z archives.
+    class ArchiveListCommand
+      attr_reader :options
+
+      # Initialize archive list command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the archive list command.
+      #
+      # @param archive_file [String] Path to .7z archive
+      # @return [void]
+      def run(archive_file)
+        validate_input(archive_file)
+
+        verbose = options[:verbose] || false
+        patterns = Array(options[:pattern]) if options[:pattern]
+        excludes = Array(options[:exclude]) if options[:exclude]
+        count_only = options[:count] || false
+
+        list_archive(archive_file, verbose, patterns, excludes, count_only)
+      end
+
+      private
+
+      def validate_input(archive_file)
+        unless File.exist?(archive_file)
+          raise Omnizip::IOError, "Archive not found: #{archive_file}"
+        end
+
+        return if File.readable?(archive_file)
+
+        raise Omnizip::IOError,
+              "Archive not readable: #{archive_file}"
+      end
+
+      def list_archive(archive_file, verbose, patterns, excludes, count_only)
+        # Route through the handler seam: every format's reader is
+        # chosen by the extension routes, not by hand-rolled branches
+        entries = Omnizip.list_archive(archive_file, details: true)
+          .map { |h| EntryAdapter.new(h) }
+
+        entries = filter_entries(entries, patterns, excludes) if patterns || excludes
+
+        if count_only
+          puts "Matches: #{entries.size}"
+          return
+        end
+
+        puts "Archive: #{archive_file}"
+        puts ""
+
+        if verbose
+          display_detailed_listing_filtered(entries)
+        else
+          display_simple_listing_filtered(entries)
+        end
+
+        puts ""
+        summary_stats_filtered(entries)
+      rescue StandardError => e
+        raise Omnizip::CompressionError,
+              "Failed to list archive: #{e.message}"
+      end
+
+      def filter_entries(entries, patterns, excludes)
+        filter = Extraction::FilterChain.new
+
+        # Add include patterns
+        patterns&.each { |pattern| filter.include_pattern(pattern) }
+
+        # Add exclude patterns
+        excludes&.each { |pattern| filter.exclude_pattern(pattern) }
+
+        filter.filter(entries)
+      end
+
+      def display_simple_listing_filtered(entries)
+        puts "Contents:"
+        puts ""
+
+        entries.each do |entry|
+          type_indicator = entry_directory?(entry) ? "D" : "F"
+          name = entry_name(entry)
+          puts "  [#{type_indicator}] #{name}"
+        end
+      end
+
+      def display_detailed_listing_filtered(entries)
+        puts "Type       Size         Compressed   Modified             Name"
+        puts "-" * 80
+
+        entries.each do |entry|
+          type = entry_directory?(entry) ? "Dir" : "File"
+          size = entry_directory?(entry) ? "-" : format_bytes(entry_size(entry))
+          compressed = if entry_directory?(entry) || !entry_has_stream?(entry)
+                         "-"
+                       else
+                         format_bytes(entry_compressed_size(entry) || 0)
+                       end
+          mtime = if entry_mtime(entry)
+                    entry_mtime(entry).strftime("%Y-%m-%d %H:%M:%S")
+                  else
+                    "-"
+                  end
+          name = entry_name(entry)
+
+          puts format(
+            "%-10s %-12s %-12s %-20s %s",
+            type,
+            size,
+            compressed,
+            mtime,
+            name,
+          )
+        end
+      end
+
+      def summary_stats_filtered(entries)
+        total_files = entries.count { |e| !entry_directory?(e) }
+        total_dirs = entries.count { |e| entry_directory?(e) }
+        total_size = entries.sum { |e| entry_size(e) || 0 }
+        total_compressed = entries.sum { |e| entry_compressed_size(e) || 0 }
+
+        puts "Summary:"
+        puts "  Files: #{total_files}"
+        puts "  Directories: #{total_dirs}"
+        puts "  Total size: #{format_bytes(total_size)}"
+        return unless total_compressed.positive? && total_size.positive?
+
+        ratio = (1.0 - (total_compressed.to_f / total_size)) * 100
+        puts "  Compressed size: #{format_bytes(total_compressed)}"
+        puts "  Compression ratio: #{ratio.round(1)}%"
+      end
+
+      def format_bytes(bytes)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+
+      # Helper methods to handle different entry types. Each delegates
+      # to the Omnizip::Entry contract; format-specific accessors stay
+      # on the format entry classes themselves.
+      def entry_name(entry)
+        entry.entry_name || entry.to_s
+      end
+
+      def entry_directory?(entry)
+        entry.entry_directory?
+      end
+
+      def entry_size(entry)
+        entry.entry_size || 0
+      end
+
+      def entry_compressed_size(entry)
+        entry.compressed_size
+      end
+
+      def entry_has_stream?(entry)
+        entry.has_stream?
+      end
+
+      def entry_mtime(entry)
+        entry.entry_mtime
+      end
+
+      # Presents handler list-detail hashes under the Omnizip::Entry
+      # contract the display helpers already use
+      # :fields, not :hash — Struct members must not override
+      # Struct#hash
+      EntryAdapter = Struct.new(:fields) do
+        def entry_name = fields[:name]
+        def entry_directory? = fields[:directory]
+        def entry_size = fields[:size]
+        def entry_mtime = fields[:mtime] || fields[:time]
+        def compressed_size = fields[:compressed_size]
+        def has_stream? = !fields[:directory] && fields[:size].to_i.positive?
+      end
+    end
+  end
+end