omnizip 0.3.1

data/lib/omnizip/commands/list_command.rb

@@ -0,0 +1,53 @@
+# 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 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

data/lib/omnizip/commands/metadata_command.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "../cli/output_formatter"
+
+module Omnizip
+  module Commands
+    # Metadata command implementation
+    class MetadataCommand
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Run the metadata command
+      # @param archive_path [String] Path to archive
+      # @param pattern [String, nil] Optional pattern to match entries
+      def run(archive_path, pattern = nil)
+        require_relative "../zip/file"
+        require_relative "../metadata"
+
+        unless File.exist?(archive_path)
+          raise Errno::ENOENT, "Archive not found: #{archive_path}"
+        end
+
+        Omnizip::Zip::File.open(archive_path) do |archive|
+          if options[:show]
+            show_metadata(archive, pattern)
+          else
+            edit_metadata(archive, pattern)
+          end
+        end
+
+        puts "Metadata updated successfully" unless options[:show]
+      end
+
+      private
+
+      def show_metadata(archive, pattern)
+        if pattern
+          # Show entry metadata
+          entry = archive.get_entry(pattern)
+          unless entry
+            warn "Entry not found: #{pattern}"
+            return
+          end
+
+          show_entry_metadata(entry)
+        else
+          # Show archive metadata
+          show_archive_metadata(archive)
+        end
+      end
+
+      def show_archive_metadata(archive)
+        metadata = archive.metadata
+        puts "Archive: #{archive.name}"
+        puts "Comment: #{metadata.comment}" unless metadata.comment.empty?
+        puts "Created: #{metadata.created_at}" if metadata.created_at
+        puts "Modified: #{metadata.modified_at}" if metadata.modified_at
+        puts "Entries: #{metadata.entry_count} (#{metadata.file_count} files, #{metadata.directory_count} dirs)"
+        puts "Total size: #{format_size(metadata.total_size)}"
+        puts "Compressed: #{format_size(metadata.total_compressed_size)}"
+        puts "Ratio: #{(metadata.compression_ratio * 100).round(1)}%"
+      end
+
+      def show_entry_metadata(entry)
+        metadata = entry.metadata
+        puts "Entry: #{entry.name}"
+        puts "Comment: #{metadata.comment}" unless metadata.comment.empty?
+        puts "Modified: #{metadata.mtime}"
+        puts "Permissions: 0#{metadata.unix_permissions.to_s(8)}"
+        puts "Size: #{format_size(entry.size)}"
+        puts "Compressed: #{format_size(entry.compressed_size)}"
+        puts "CRC32: 0x#{entry.crc.to_s(16).upcase}"
+        puts "Type: #{entry.directory? ? 'Directory' : 'File'}"
+      end
+
+      def edit_metadata(archive, pattern)
+        if pattern
+          edit_entry_metadata(archive, pattern)
+        else
+          edit_archive_metadata(archive)
+        end
+
+        archive.save_metadata
+      end
+
+      def edit_archive_metadata(archive)
+        metadata = archive.metadata
+
+        if options[:comment]
+          metadata.comment = options[:comment]
+        end
+      end
+
+      def edit_entry_metadata(archive, pattern)
+        entries = if pattern.include?("*") || pattern.include?("?")
+                    # Glob pattern
+                    archive.entries.select { |e| File.fnmatch(pattern, e.name) }
+                  else
+                    # Single entry
+                    [archive.get_entry(pattern)].compact
+                  end
+
+        if entries.empty?
+          warn "No entries match pattern: #{pattern}"
+          return
+        end
+
+        entries.each do |entry|
+          metadata = entry.metadata
+
+          metadata.comment = options[:comment] if options[:comment]
+          metadata.mtime = parse_time(options[:set_mtime]) if options[:set_mtime]
+          metadata.unix_permissions = parse_permissions(options[:chmod]) if options[:chmod]
+          metadata.attributes = options[:set_attribute].to_sym if options[:set_attribute]
+
+          entry.save_metadata
+        end
+
+        puts "Updated #{entries.size} #{entries.size == 1 ? 'entry' : 'entries'}" if options[:verbose]
+      end
+
+      def parse_time(time_str)
+        return Time.now if time_str == "now"
+
+        Time.parse(time_str)
+      rescue ArgumentError => e
+        raise ArgumentError, "Invalid time format: #{time_str} (#{e.message})"
+      end
+
+      def parse_permissions(perms_str)
+        # Handle octal (755) or decimal
+        if perms_str.start_with?("0")
+          perms_str.to_i(8)
+        else
+          perms_str.to_i
+        end
+      end
+
+      def format_size(bytes)
+        return "0 B" if bytes.zero?
+
+        units = %w[B KB MB GB TB]
+        exp = (Math.log(bytes) / Math.log(1024)).to_i
+        exp = [exp, units.size - 1].min
+
+        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+      end
+    end
+  end
+end

data/lib/omnizip/commands/parity_create_command.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "../parity"
+
+module Omnizip
+  module Commands
+    # Command to create PAR2 parity files
+    class ParityCreateCommand
+      # @return [Array<String>] Files to protect
+      attr_reader :files
+
+      # @return [Hash] Command options
+      attr_reader :options
+
+      # Initialize command
+      #
+      # @param files [Array<String>] Files or patterns to protect
+      # @param options [Hash] Command options
+      def initialize(files, options = {})
+        @files = files
+        @options = default_options.merge(options)
+      end
+
+      # Execute command
+      #
+      # @return [Integer] Exit code (0 for success)
+      def run
+        validate_inputs!
+
+        progress = create_progress_callback if @options[:verbose]
+
+        created_files = []
+        @files.each do |file_pattern|
+          par2_files = Parity.create(
+            file_pattern,
+            redundancy: @options[:redundancy],
+            block_size: @options[:block_size],
+            output_dir: @options[:output_dir],
+            progress: progress,
+          )
+
+          created_files.concat(par2_files)
+        end
+
+        report_success(created_files)
+        0
+      rescue StandardError => e
+        report_error(e)
+        1
+      end
+
+      private
+
+      # Default command options
+      #
+      # @return [Hash] Default options
+      def default_options
+        {
+          redundancy: 5,
+          block_size: Parity::Par2Creator::DEFAULT_BLOCK_SIZE,
+          output_dir: nil,
+          verbose: false,
+        }
+      end
+
+      # Validate command inputs
+      #
+      # @raise [ArgumentError] if inputs invalid
+      def validate_inputs!
+        raise ArgumentError, "No files specified" if @files.empty?
+
+        unless @options[:redundancy].between?(0, 100)
+          raise ArgumentError, "Redundancy must be 0-100%"
+        end
+      end
+
+      # Create progress callback
+      #
+      # @return [Proc] Progress callback
+      def create_progress_callback
+        ->(percent, message) do
+          puts "[#{percent.to_s.rjust(3)}%] #{message}"
+        end
+      end
+
+      # Report successful creation
+      #
+      # @param files [Array<String>] Created files
+      def report_success(files)
+        puts "\n✓ Created #{files.size} PAR2 file(s):"
+        files.each do |file|
+          size = File.size(file)
+          puts "  - #{File.basename(file)} (#{format_size(size)})"
+        end
+        puts "\nRedundancy: #{@options[:redundancy]}%"
+        puts "Block size: #{format_size(@options[:block_size])}"
+      end
+
+      # Report error
+      #
+      # @param error [Exception] Error that occurred
+      def report_error(error)
+        puts "\n✗ Failed to create PAR2 files:"
+        puts "  #{error.message}"
+      end
+
+      # Format byte size for display
+      #
+      # @param bytes [Integer] Size in bytes
+      # @return [String] Formatted size
+      def format_size(bytes)
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(1)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(1)} MB"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/commands/parity_repair_command.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "../parity"
+
+module Omnizip
+  module Commands
+    # Command to repair files using PAR2
+    class ParityRepairCommand
+      # @return [String] PAR2 file path
+      attr_reader :par2_file
+
+      # @return [Hash] Command options
+      attr_reader :options
+
+      # Initialize command
+      #
+      # @param par2_file [String] Path to .par2 index file
+      # @param options [Hash] Command options
+      def initialize(par2_file, options = {})
+        @par2_file = par2_file
+        @options = default_options.merge(options)
+      end
+
+      # Execute command
+      #
+      # @return [Integer] Exit code (0 for success)
+      def run
+        validate_inputs!
+
+        puts "Repairing files with PAR2: #{File.basename(@par2_file)}"
+        puts
+
+        progress = create_progress_callback if @options[:verbose]
+
+        result = Parity.repair(
+          @par2_file,
+          output_dir: @options[:output_dir],
+          progress: progress,
+        )
+
+        display_results(result)
+
+        result.success? ? 0 : 1
+      rescue StandardError => e
+        report_error(e)
+        1
+      end
+
+      private
+
+      # Default command options
+      #
+      # @return [Hash] Default options
+      def default_options
+        {
+          output_dir: nil,
+          verbose: false,
+        }
+      end
+
+      # Validate command inputs
+      #
+      # @raise [ArgumentError] if inputs invalid
+      def validate_inputs!
+        unless File.exist?(@par2_file)
+          raise ArgumentError, "PAR2 file not found: #{@par2_file}"
+        end
+      end
+
+      # Create progress callback
+      #
+      # @return [Proc] Progress callback
+      def create_progress_callback
+        ->(percent, message) do
+          puts "[#{percent.to_s.rjust(3)}%] #{message}"
+        end
+      end
+
+      # Display repair results
+      #
+      # @param result [Omnizip::Parity::Par2Repairer::RepairResult]
+      def display_results(result)
+        if result.success?
+          puts "✓ Repair successful"
+          puts
+
+          if result.recovered_files.any?
+            puts "Recovered files (#{result.recovered_files.size}):"
+            result.recovered_files.each do |file|
+              puts "  - #{file}"
+            end
+          else
+            puts "No repairs needed - all files were intact"
+          end
+
+          puts
+          puts "Recovered blocks: #{result.recovered_blocks}"
+        else
+          puts "✗ Repair failed"
+          puts
+          puts "Error: #{result.error_message}"
+          puts
+
+          if result.unrecoverable.any?
+            puts "Unrecoverable files (#{result.unrecoverable.size}):"
+            result.unrecoverable.each do |file|
+              puts "  - #{file}"
+            end
+          end
+        end
+      end
+
+      # Report error
+      #
+      # @param error [Exception] Error that occurred
+      def report_error(error)
+        puts "\n✗ Repair failed:"
+        puts "  #{error.message}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/parity_verify_command.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../parity"
+
+module Omnizip
+  module Commands
+    # Command to verify files using PAR2
+    class ParityVerifyCommand
+      # @return [String] PAR2 file path
+      attr_reader :par2_file
+
+      # @return [Hash] Command options
+      attr_reader :options
+
+      # Initialize command
+      #
+      # @param par2_file [String] Path to .par2 index file
+      # @param options [Hash] Command options
+      def initialize(par2_file, options = {})
+        @par2_file = par2_file
+        @options = default_options.merge(options)
+      end
+
+      # Execute command
+      #
+      # @return [Integer] Exit code (0 if all OK, 1 if damage, 2 if error)
+      def run
+        validate_inputs!
+
+        puts "Verifying files with PAR2: #{File.basename(@par2_file)}"
+        puts
+
+        result = Parity.verify(@par2_file)
+
+        display_results(result)
+
+        # Exit code based on results
+        if result.all_ok?
+          0
+        elsif result.repairable?
+          1 # Damage but repairable
+        else
+          2 # Damage not repairable
+        end
+      rescue StandardError => e
+        report_error(e)
+        2
+      end
+
+      private
+
+      # Default command options
+      #
+      # @return [Hash] Default options
+      def default_options
+        {
+          verbose: false,
+        }
+      end
+
+      # Validate command inputs
+      #
+      # @raise [ArgumentError] if inputs invalid
+      def validate_inputs!
+        unless File.exist?(@par2_file)
+          raise ArgumentError, "PAR2 file not found: #{@par2_file}"
+        end
+      end
+
+      # Display verification results
+      #
+      # @param result [Omnizip::Parity::Par2Verifier::VerificationResult]
+      def display_results(result)
+        if result.all_ok?
+          puts "✓ All files verified successfully"
+          puts
+          puts "Total blocks: #{result.total_blocks}"
+          puts "Recovery blocks available: #{result.recovery_blocks}"
+        else
+          puts "✗ File corruption detected"
+          puts
+
+          if result.damaged_files.any?
+            puts "Damaged files (#{result.damaged_files.size}):"
+            result.damaged_files.each do |file|
+              puts "  - #{file}"
+            end
+            puts
+          end
+
+          if result.missing_files.any?
+            puts "Missing files (#{result.missing_files.size}):"
+            result.missing_files.each do |file|
+              puts "  - #{file}"
+            end
+            puts
+          end
+
+          puts "Damaged blocks: #{result.damaged_blocks.size}"
+          puts "Total blocks: #{result.total_blocks}"
+          puts "Recovery blocks available: #{result.recovery_blocks}"
+          puts
+
+          if result.repairable?
+            puts "✓ Damage is repairable"
+            puts "  Run repair command to fix files:"
+            puts "  omnizip parity repair #{@par2_file}"
+          else
+            puts "✗ Damage exceeds recovery capacity"
+            puts "  Cannot repair: insufficient recovery blocks"
+          end
+        end
+      end
+
+      # Report error
+      #
+      # @param error [Exception] Error that occurred
+      def report_error(error)
+        puts "\n✗ Verification failed:"
+        puts "  #{error.message}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands/profile_list_command.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../cli/output_formatter"
+
+module Omnizip
+  module Commands
+    # Command to list available compression profiles
+    class ProfileListCommand
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run
+        profiles = Omnizip::Profile.registry.all.sort_by(&:name)
+
+        if @options[:verbose]
+          list_detailed(profiles)
+        else
+          list_simple(profiles)
+        end
+      end
+
+      private
+
+      def list_simple(profiles)
+        puts "Available compression profiles:"
+        puts ""
+
+        profiles.each do |profile|
+          default_marker = profile.name == :balanced ? " [default]" : ""
+          puts format(
+            "  %-12s - %s%s",
+            profile.name,
+            profile.description,
+            default_marker,
+          )
+        end
+      end
+
+      def list_detailed(profiles)
+        puts "Available compression profiles:"
+        puts ""
+
+        profiles.each do |profile|
+          puts "Profile: #{profile.name}"
+          puts "  Algorithm:   #{profile.algorithm}"
+          puts "  Level:       #{profile.level}"
+          puts "  Filter:      #{profile.filter || 'none'}"
+          puts "  Solid:       #{profile.solid}"
+          puts "  Description: #{profile.description}"
+          puts ""
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/commands/profile_show_command.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../cli/output_formatter"
+
+module Omnizip
+  module Commands
+    # Command to show details of a specific compression profile
+    class ProfileShowCommand
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(profile_name)
+        profile_sym = profile_name.to_sym
+        profile = Omnizip::Profile.get(profile_sym)
+
+        unless profile
+          warn "Profile '#{profile_name}' not found"
+          warn ""
+          warn "Available profiles:"
+          Omnizip::Profile.list.each { |name| warn "  - #{name}" }
+          exit 1
+        end
+
+        display_profile(profile)
+      end
+
+      private
+
+      def display_profile(profile)
+        puts "Profile: #{profile.name}"
+        puts "Algorithm:   #{profile.algorithm}"
+        puts "Level:       #{profile.level}"
+        puts "Filter:      #{profile.filter || 'none'}"
+        puts "Solid:       #{profile.solid}"
+        puts "Description: #{profile.description}"
+
+        return unless profile.respond_to?(:base_profile) && profile.base_profile
+
+        puts "Based on:    #{profile.base_profile.name}"
+      end
+    end
+  end
+end