omnizip 0.3.1

data/lib/omnizip/commands/archive_list_command.rb

@@ -0,0 +1,218 @@
+# 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_relative "../cli/output_formatter"
+require_relative "../formats/seven_zip/reader"
+require_relative "../extraction"
+
+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)
+        archive = if archive_file.end_with?(".zip")
+                    Omnizip::Zip::File.open(archive_file)
+                  elsif archive_file.end_with?(".rar")
+                    Formats::Rar::Reader.new(archive_file).open
+                  else
+                    Formats::SevenZip::Reader.new(archive_file).open
+                  end
+
+        entries = if patterns || excludes
+                    filter_entries(archive, patterns, excludes)
+                  else
+                    archive.respond_to?(:entries) ? archive.entries : archive.to_a
+                  end
+
+        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(archive, 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) }
+
+        entries = archive.respond_to?(:entries) ? archive.entries : archive.to_a
+        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)
+        return "0 B" if bytes.zero?
+
+        units = %w[B KB MB GB]
+        size = bytes.to_f
+        unit_idx = 0
+
+        while size >= 1024 && unit_idx < units.length - 1
+          size /= 1024.0
+          unit_idx += 1
+        end
+
+        if size < 10
+          format("%.2f %s", size, units[unit_idx])
+        elsif size < 100
+          format("%.1f %s", size, units[unit_idx])
+        else
+          format("%.0f %s", size, units[unit_idx])
+        end
+      end
+
+      # Helper methods to handle different entry types
+      def entry_name(entry)
+        entry.respond_to?(:name) ? entry.name : entry.to_s
+      end
+
+      def entry_directory?(entry)
+        entry.respond_to?(:directory?) && entry.directory?
+      end
+
+      def entry_size(entry)
+        entry.respond_to?(:size) ? entry.size : 0
+      end
+
+      def entry_compressed_size(entry)
+        entry.respond_to?(:compressed_size) ? entry.compressed_size : nil
+      end
+
+      def entry_has_stream?(entry)
+        entry.respond_to?(:has_stream?) ? entry.has_stream? : true
+      end
+
+      def entry_mtime(entry)
+        entry.respond_to?(:mtime) ? entry.mtime : nil
+      end
+    end
+  end
+end

data/lib/omnizip/commands/archive_repair_command.rb

@@ -0,0 +1,131 @@
+# 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)
+        require_relative "../formats/rar"
+
+        raise "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,117 @@
+# 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)
+        require_relative "../formats/rar"
+
+        unless File.exist?(archive_path)
+          raise "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,117 @@
+# 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_relative "../cli/output_formatter"
+
+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,120 @@
+# 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_relative "../cli/output_formatter"
+
+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.
+      #
+      # @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] || 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
+
+      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 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