omnizip 0.4.7-x86_64-linux

data/lib/omnizip/commands/archive_repair_command.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Commands
+    # Archive repair command
+    class ArchiveRepairCommand
+      attr_reader :options
+
+      # Initialize command
+      #
+      # @param options [Hash] Command options
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Run repair
+      #
+      # @param input_path [String] Path to corrupted archive
+      # @param output_path [String] Path for repaired archive
+      def run(input_path, output_path)
+        raise Omnizip::IOError, "Archive not found: #{input_path}" unless File.exist?(input_path)
+
+        # Detect format
+        format = detect_format(input_path)
+
+        case format
+        when :rar
+          repair_rar(input_path, output_path)
+        else
+          puts "Repair not supported for #{format} archives"
+          exit 1
+        end
+      end
+
+      private
+
+      # Detect archive format
+      #
+      # @param path [String] Archive path
+      # @return [Symbol] Format
+      def detect_format(path)
+        ext = File.extname(path).downcase
+        case ext
+        when ".rar", ".r00", ".r01"
+          :rar
+        when ".zip"
+          :zip
+        when ".7z"
+          :seven_zip
+        else
+          :unknown
+        end
+      end
+
+      # Repair RAR archive
+      #
+      # @param input_path [String] Path to corrupted archive
+      # @param output_path [String] Path for repaired archive
+      def repair_rar(input_path, output_path)
+        puts "Repairing #{input_path}..." if @options[:verbose]
+
+        repair_options = {
+          use_external_rev: !@options[:no_external_rev],
+          verify_repaired: !@options[:no_verify],
+          verbose: @options[:verbose],
+        }
+
+        result = Omnizip::Formats::Rar.repair(
+          input_path,
+          output_path,
+          repair_options,
+        )
+
+        display_repair_result(input_path, output_path, result)
+
+        exit 1 unless result.success?
+      end
+
+      # Display repair results
+      #
+      # @param input_path [String] Input archive path
+      # @param output_path [String] Output archive path
+      # @param result [ArchiveRepairer::RepairResult] Repair results
+      def display_repair_result(input_path, output_path, result)
+        puts "\nRepair Results:"
+        puts "Input: #{input_path}"
+        puts "Output: #{output_path}"
+
+        if result.success?
+          puts "\nStatus: SUCCESS"
+          puts "Repaired files: #{result.repaired_files.size}"
+          puts "Repaired blocks: #{result.repaired_blocks.size}"
+
+          if @options[:verbose] && result.repaired_files.any?
+            puts "\nRepaired:"
+            result.repaired_files.each do |filename|
+              puts "  ✓ #{filename}"
+            end
+          end
+        else
+          puts "\nStatus: FAILED"
+
+          if result.repaired_files.any?
+            puts "Partially repaired: #{result.repaired_files.size} files"
+          end
+
+          if result.unrepaired_files.any?
+            puts "Unrepaired: #{result.unrepaired_files.size} files"
+
+            if @options[:verbose]
+              result.unrepaired_files.each do |filename|
+                puts "  ✗ #{filename}"
+              end
+            end
+          end
+
+          if result.errors.any?
+            puts "\nErrors:"
+            result.errors.each do |error|
+              puts "  - #{error}"
+            end
+          end
+        end
+
+        puts "\n#{result.summary}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/archive_verify_command.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Commands
+    # Archive verification command
+    class ArchiveVerifyCommand
+      attr_reader :options
+
+      # Initialize command
+      #
+      # @param options [Hash] Command options
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Run verification
+      #
+      # @param archive_path [String] Path to archive
+      def run(archive_path)
+        unless File.exist?(archive_path)
+          raise Omnizip::IOError, "Archive not found: #{archive_path}"
+        end
+
+        # Detect format
+        format = detect_format(archive_path)
+
+        case format
+        when :rar
+          verify_rar(archive_path)
+        else
+          puts "Verification not supported for #{format} archives"
+          exit 1
+        end
+      end
+
+      private
+
+      # Detect archive format
+      #
+      # @param path [String] Archive path
+      # @return [Symbol] Format (:rar, :zip, :7z)
+      def detect_format(path)
+        ext = File.extname(path).downcase
+        case ext
+        when ".rar", ".r00", ".r01"
+          :rar
+        when ".zip"
+          :zip
+        when ".7z"
+          :seven_zip
+        else
+          :unknown
+        end
+      end
+
+      # Verify RAR archive
+      #
+      # @param archive_path [String] Path to RAR archive
+      def verify_rar(archive_path)
+        puts "Verifying #{archive_path}..." if @options[:verbose]
+
+        result = Omnizip::Formats::Rar.verify(
+          archive_path,
+          use_recovery: !@options[:no_recovery],
+        )
+
+        display_verification_result(archive_path, result)
+
+        exit 1 unless result.valid?
+      end
+
+      # Display verification results
+      #
+      # @param archive_path [String] Archive path
+      # @param result [ArchiveVerifier::VerificationResult] Results
+      def display_verification_result(archive_path, result)
+        puts "\nArchive: #{archive_path}"
+        puts "Format: RAR"
+
+        if result.recovery_available
+          puts "Recovery records: Yes"
+        else
+          puts "Recovery records: No"
+        end
+
+        puts "\nFiles:"
+        puts "  Total: #{result.files_total}"
+        puts "  OK: #{result.files_ok}"
+        puts "  Corrupted: #{result.files_corrupted}"
+
+        if result.files_corrupted.positive?
+          puts "\nCorrupted files:"
+          result.corrupted_files.each do |filename|
+            puts "  - #{filename}"
+          end
+
+          if result.can_repair?
+            puts "\nCan repair: Yes (using recovery records)"
+          else
+            puts "\nCan repair: No"
+          end
+        end
+
+        if @options[:verbose] && result.errors.any?
+          puts "\nErrors:"
+          result.errors.each do |error|
+            puts "  - #{error}"
+          end
+        end
+
+        puts "\n#{result.summary}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/compress_command.rb

@@ -0,0 +1,115 @@
+# 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 compress files using specified algorithm.
+    class CompressCommand
+      attr_reader :options
+
+      # Initialize compress command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the compress command.
+      #
+      # @param input_file [String] Path to input file
+      # @param output_file [String] Path to output file
+      # @return [void]
+      def run(input_file, output_file)
+        validate_inputs(input_file, output_file)
+
+        algorithm_name = options[:algorithm] || "lzma"
+        level = options[:level] || 5
+        verbose = options[:verbose] || false
+
+        CliOutputFormatter.verbose_puts(
+          "Compressing #{input_file} to #{output_file}...",
+          verbose,
+        )
+        CliOutputFormatter.verbose_puts(
+          "Algorithm: #{algorithm_name}, Level: #{level}",
+          verbose,
+        )
+
+        start_time = Time.now
+
+        compress_file(input_file, output_file, algorithm_name, level)
+
+        elapsed = Time.now - start_time
+
+        input_size = File.size(input_file)
+        output_size = File.size(output_file)
+
+        if verbose
+          puts ""
+          puts CliOutputFormatter.format_compression_stats(
+            input_size,
+            output_size,
+            elapsed,
+          )
+        else
+          puts "Compressed: #{input_file} -> #{output_file}"
+        end
+      end
+
+      private
+
+      def validate_inputs(input_file, output_file)
+        unless File.exist?(input_file)
+          raise Omnizip::IOError, "Input file not found: #{input_file}"
+        end
+
+        unless File.readable?(input_file)
+          raise Omnizip::IOError,
+                "Input file not readable: #{input_file}"
+        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 compress_file(input_file, output_file, algorithm_name, level)
+        algorithm_class = AlgorithmRegistry.get(algorithm_name.to_sym)
+        algorithm = algorithm_class.new(level: level)
+
+        File.open(input_file, "rb") do |input|
+          File.open(output_file, "wb") do |output|
+            algorithm.compress(input, output)
+          end
+        end
+      rescue UnknownAlgorithmError => e
+        raise e
+      rescue StandardError => e
+        raise Omnizip::CompressionError,
+              "Failed to compress file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/decompress_command.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+#
+# 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 decompress files using specified algorithm.
+    class DecompressCommand
+      attr_reader :options
+
+      # Initialize decompress command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the decompress command.
+      #
+      # Archives (.zip/.7z/.tar/...) extract into the output
+      # directory; single-file streams decompress to the output file.
+      #
+      # @param input_file [String] Path to input file
+      # @param output_file [String] Path to output file or directory
+      # @return [void]
+      def run(input_file, output_file)
+        validate_inputs(input_file, output_file)
+
+        if archive_input?(input_file) || File.directory?(output_file)
+          run_archive_extract(input_file, output_file)
+          return
+        end
+
+        algorithm_name = options[:algorithm] || detect_algorithm
+        verbose = options[:verbose] || false
+
+        CliOutputFormatter.verbose_puts(
+          "Decompressing #{input_file} to #{output_file}...",
+          verbose,
+        )
+        CliOutputFormatter.verbose_puts(
+          "Algorithm: #{algorithm_name}",
+          verbose,
+        )
+
+        start_time = Time.now
+
+        decompress_file(input_file, output_file, algorithm_name)
+
+        elapsed = Time.now - start_time
+
+        input_size = File.size(input_file)
+        output_size = File.size(output_file)
+
+        if verbose
+          puts ""
+          puts CliOutputFormatter.format_compression_stats(
+            output_size,
+            input_size,
+            elapsed,
+          )
+        else
+          puts "Decompressed: #{input_file} -> #{output_file}"
+        end
+      end
+
+      # Archive-vs-stream routing derives from the registry's
+      # extension routes so new formats route here automatically
+      ARCHIVE_EXTENSIONS = (Convenience::ARCHIVE_FORMAT_EXTENSIONS.keys +
+                            Convenience::READ_ARCHIVE_FORMAT_EXTENSIONS.keys).freeze
+
+      private
+
+      def archive_input?(path)
+        ext = File.extname(path).downcase
+        ARCHIVE_EXTENSIONS.include?(ext)
+      end
+
+      def run_archive_extract(input_file, output_dir)
+        FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+
+        entries = Omnizip.list_archive(input_file)
+        Omnizip.extract_archive(input_file, output_dir)
+
+        puts "Extracted #{entries.size} file(s) to: #{output_dir}"
+      rescue StandardError => e
+        raise Omnizip::IOError, "Failed to extract archive: #{e.message}"
+      end
+
+      def validate_inputs(input_file, output_file)
+        unless File.exist?(input_file)
+          raise Omnizip::IOError, "Input file not found: #{input_file}"
+        end
+
+        unless File.readable?(input_file)
+          raise Omnizip::IOError,
+                "Input file not readable: #{input_file}"
+        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 detect_algorithm
+        "lzma"
+      end
+
+      def decompress_file(input_file, output_file, algorithm_name)
+        algorithm_class = AlgorithmRegistry.get(algorithm_name.to_sym)
+        algorithm = algorithm_class.new
+
+        File.open(input_file, "rb") do |input|
+          File.open(output_file, "wb") do |output|
+            algorithm.decompress(input, output)
+          end
+        end
+      rescue UnknownAlgorithmError => e
+        raise e
+      rescue StandardError => e
+        raise Omnizip::CompressionError,
+              "Failed to decompress file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/list_command.rb

@@ -0,0 +1,51 @@
+# 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 available compression algorithms.
+    class ListCommand
+      attr_reader :options
+
+      # Initialize list command with options.
+      #
+      # @param options [Hash] Command options from Thor
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the list command.
+      #
+      # @return [void]
+      def run
+        algorithms = fetch_algorithms
+        output = CliOutputFormatter.format_algorithms_table(algorithms)
+        puts output
+      end
+
+      private
+
+      def fetch_algorithms
+        AlgorithmRegistry.available.map do |name|
+          algorithm_class = AlgorithmRegistry.get(name)
+          algorithm_class.metadata
+        end
+      end
+    end
+  end
+end