omnizip 0.4.7-x86_64-linux

data/lib/omnizip/commands/metadata_command.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+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)
+        unless File.exist?(archive_path)
+          raise Errno::ENOENT, "Archive not found: #{archive_path}"
+        end
+
+        if seven_zip?(archive_path)
+          show_seven_zip_metadata(archive_path, pattern)
+          return
+        end
+
+        unless zip?(archive_path)
+          raise ArgumentError,
+                "Metadata is supported for .zip and .7z archives: " \
+                "#{archive_path}"
+        end
+
+        Omnizip::Zip::File.open(archive_path) do |archive|
+          if options[:show] || editing_nothing?
+            show_metadata(archive, pattern)
+          else
+            edit_metadata(archive, pattern)
+            puts "Metadata updated successfully"
+          end
+        end
+      end
+
+      private
+
+      def zip?(path)
+        path.end_with?(".zip")
+      end
+
+      def seven_zip?(path)
+        path.end_with?(".7z")
+      end
+
+      # True when no edit option was given — editing would be a no-op
+      def editing_nothing?
+        %i[comment set_mtime chmod set_attribute].none? { |key| options[key] }
+      end
+
+      # Read-only view for 7z archives through the handler registry;
+      # the edit path is zip-only
+      def show_seven_zip_metadata(archive_path, pattern)
+        if options[:comment] || options[:set_mtime] ||
+            options[:chmod] || options[:set_attribute]
+          raise ArgumentError,
+                "Metadata editing is only supported for ZIP archives"
+        end
+
+        entries = Omnizip.list_archive(archive_path, details: true)
+
+        if pattern
+          entries = entries.select do |entry|
+            File.fnmatch(pattern, entry[:name])
+          end
+          if entries.empty?
+            warn "No entries match pattern: #{pattern}"
+            return
+          end
+
+          entries.each { |entry| show_seven_zip_entry(entry) }
+        else
+          files = entries.reject { |entry| entry[:directory] }
+          puts "Archive: #{archive_path}"
+          puts "Entries: #{entries.size} " \
+               "(#{files.size} files, #{entries.size - files.size} dirs)"
+          puts "Total size: #{format_size(files.sum { |entry| entry[:size] })}"
+        end
+      end
+
+      # The display is driven by the registry's field contract for
+      # :seven_zip — optional lines print only for registered fields.
+      def show_seven_zip_entry(entry)
+        registry = Omnizip::Metadata::MetadataRegistry
+        puts "Entry: #{entry[:name]}" if registry.supports?(:seven_zip, :name)
+        puts "  Type: #{entry[:directory] ? 'Directory' : 'File'}" if registry.supports?(:seven_zip, :directory)
+        puts "  Size: #{format_size(entry[:size])}" if registry.supports?(:seven_zip, :size)
+        # Per-entry packed sizes are not tracked by the parser
+        if registry.supports?(:seven_zip, :compressed_size) &&
+            entry[:compressed_size]&.positive?
+          puts "  Compressed: #{format_size(entry[:compressed_size])}"
+        end
+        if registry.supports?(:seven_zip, :mtime) && entry[:mtime]
+          puts "  Modified: #{entry[:mtime]}"
+        end
+        if registry.supports?(:seven_zip, :crc) && entry[:crc]
+          puts "  CRC32: 0x#{entry[:crc].to_s(16).upcase}"
+        end
+      end
+
+      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)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+    end
+  end
+end

data/lib/omnizip/commands/parity_create_command.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+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)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+    end
+  end
+end

data/lib/omnizip/commands/parity_repair_command.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+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,122 @@
+# frozen_string_literal: true
+
+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,54 @@
+# frozen_string_literal: true
+
+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
+
+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}"
+
+        # ProfileRegistry accepts any CompressionProfile subclass.
+        # allowed: a registered subclass may expose base_profile
+        return unless profile.respond_to?(:base_profile) && profile.base_profile
+
+        puts "Based on:    #{profile.base_profile.name}"
+      end
+    end
+  end
+end

data/lib/omnizip/commands.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # CLI command implementations
+  module Commands
+    autoload :CompressCommand, "omnizip/commands/compress_command"
+    autoload :DecompressCommand, "omnizip/commands/decompress_command"
+    autoload :ListCommand, "omnizip/commands/list_command"
+    autoload :ArchiveCreateCommand, "omnizip/commands/archive_create_command"
+    autoload :ArchiveExtractCommand, "omnizip/commands/archive_extract_command"
+    autoload :ArchiveListCommand, "omnizip/commands/archive_list_command"
+    autoload :ProfileListCommand, "omnizip/commands/profile_list_command"
+    autoload :ProfileShowCommand, "omnizip/commands/profile_show_command"
+    autoload :MetadataCommand, "omnizip/commands/metadata_command"
+    autoload :ArchiveVerifyCommand, "omnizip/commands/archive_verify_command"
+    autoload :ArchiveRepairCommand, "omnizip/commands/archive_repair_command"
+    autoload :ParityCreateCommand, "omnizip/commands/parity_create_command"
+    autoload :ParityVerifyCommand, "omnizip/commands/parity_verify_command"
+    autoload :ParityRepairCommand, "omnizip/commands/parity_repair_command"
+  end
+end