omnizip 0.3.1

data/lib/omnizip/convenience.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Convenience methods for common archive operations
+  module Convenience
+    # Compress a single file to a ZIP archive
+    # @param input_path [String] Path to input file
+    # @param output_path [String] Path to output ZIP file
+    # @param options [Hash] Compression options
+    # @option options [Symbol, Omnizip::Profile::CompressionProfile] :profile
+    #   Compression profile (:fast, :balanced, :maximum, :text, :binary, :archive, :auto)
+    # @option options [Symbol] :compression Compression method (:deflate, :bzip2, :lzma, :zstandard)
+    # @option options [Integer] :level Compression level (1-9)
+    # @option options [Boolean] :chunked Use chunked processing for large files
+    # @option options [Integer] :chunk_size Chunk size in bytes (default: 64MB)
+    # @option options [Integer] :max_memory Maximum memory usage (default: 256MB)
+    # @option options [Proc] :progress Progress callback
+    # @return [String] Path to created archive
+    #
+    # @example
+    #   Omnizip.compress_file('document.txt', 'document.zip')
+    #   Omnizip.compress_file('image.png', 'image.zip', compression: :lzma, level: 9)
+    #   Omnizip.compress_file('huge.dat', 'huge.zip', chunked: true, max_memory: 128.megabytes)
+    #   Omnizip.compress_file('data.txt', 'data.zip', profile: :fast)
+    #   Omnizip.compress_file('app.exe', 'app.zip', profile: :auto)
+    def compress_file(input_path, output_path, **options)
+      unless ::File.exist?(input_path)
+        raise Errno::ENOENT,
+              "Input file not found: #{input_path}"
+      end
+      if ::File.directory?(input_path)
+        raise ArgumentError,
+              "Input is a directory: #{input_path}"
+      end
+
+      # Apply profile settings if specified
+      options = apply_profile(input_path, options) if options[:profile]
+
+      # Use chunked processing for large files if requested
+      if options[:chunked]
+        return Omnizip::Chunked.compress_file(input_path, output_path,
+                                              **options)
+      end
+
+      Omnizip::Zip::File.create(output_path) do |zip|
+        basename = ::File.basename(input_path)
+        zip.add(basename, input_path)
+      end
+
+      output_path
+    end
+
+    # Compress a directory to a ZIP archive
+    # @param input_dir [String] Path to input directory
+    # @param output_path [String] Path to output ZIP file
+    # @param options [Hash] Compression options
+    # @option options [Symbol, Omnizip::Profile::CompressionProfile] :profile
+    #   Compression profile (:fast, :balanced, :maximum, etc.)
+    # @option options [Symbol] :compression Compression method
+    # @option options [Integer] :level Compression level (1-9)
+    # @option options [Boolean] :recursive Include subdirectories (default: true)
+    # @option options [Integer] :max_memory Maximum memory usage for large files
+    # @option options [Proc] :progress Progress callback
+    # @return [String] Path to created archive
+    #
+    # @example
+    #   Omnizip.compress_directory('project/', 'backup.zip')
+    #   Omnizip.compress_directory('src/', 'src.zip', compression: :lzma2, level: 9)
+    #   Omnizip.compress_directory('large/', 'backup.zip', max_memory: 256.megabytes)
+    #   Omnizip.compress_directory('src/', 'backup.7z', profile: :maximum)
+    def compress_directory(input_dir, output_path, recursive: true, **options)
+      unless ::File.exist?(input_dir)
+        raise Errno::ENOENT,
+              "Input directory not found: #{input_dir}"
+      end
+      unless ::File.directory?(input_dir)
+        raise ArgumentError,
+              "Input is not a directory: #{input_dir}"
+      end
+
+      # Apply profile settings if specified (use first file for auto-detection)
+      if options[:profile]
+        first_file = find_first_file(input_dir)
+        apply_profile(first_file, options)
+      end
+
+      Omnizip::Zip::File.create(output_path) do |zip|
+        add_directory_contents(zip, input_dir, "", recursive: recursive)
+      end
+
+      output_path
+    end
+
+    # Extract a ZIP archive to a directory
+    # @param archive_path [String] Path to ZIP archive
+    # @param output_dir [String] Path to output directory
+    # @param options [Hash] Extraction options
+    # @option options [Boolean] :overwrite Overwrite existing files (default: false)
+    # @return [Array<String>] List of extracted file paths
+    #
+    # @example
+    #   Omnizip.extract_archive('backup.zip', 'restore/')
+    #   Omnizip.extract_archive('archive.zip', 'output/', overwrite: true)
+    def extract_archive(archive_path, output_dir, overwrite: false, **_options)
+      unless ::File.exist?(archive_path)
+        raise Errno::ENOENT,
+              "Archive not found: #{archive_path}"
+      end
+
+      extracted_files = []
+
+      Omnizip::Zip::File.open(archive_path) do |zip|
+        zip.each do |entry|
+          dest_path = ::File.join(output_dir, entry.name)
+
+          # Handle overwrite option
+          on_exists = if overwrite
+                        proc { true }
+                      else
+                        proc { |_e, path| raise "File exists: #{path}" }
+                      end
+
+          zip.extract(entry, dest_path, &on_exists)
+          extracted_files << dest_path
+        end
+      end
+
+      extracted_files
+    end
+
+    # List contents of a ZIP archive
+    # @param archive_path [String] Path to ZIP archive
+    # @param options [Hash] Listing options
+    # @option options [Boolean] :details Include detailed information (default: false)
+    # @return [Array<String>, Array<Hash>] List of entry names or detailed info
+    #
+    # @example
+    #   Omnizip.list_archive('backup.zip')
+    #   # => ["file1.txt", "file2.txt", "dir/"]
+    #
+    #   Omnizip.list_archive('backup.zip', details: true)
+    #   # => [{name: "file1.txt", size: 1024, compressed_size: 512, ...}, ...]
+    def list_archive(archive_path, details: false, **_options)
+      unless ::File.exist?(archive_path)
+        raise Errno::ENOENT,
+              "Archive not found: #{archive_path}"
+      end
+
+      Omnizip::Zip::File.open(archive_path) do |zip|
+        if details
+          zip.entries.map do |entry|
+            {
+              name: entry.name,
+              size: entry.size,
+              compressed_size: entry.compressed_size,
+              compression_method: entry.compression_method,
+              crc: entry.crc,
+              time: entry.time,
+              directory: entry.directory?,
+            }
+          end
+        else
+          zip.names
+        end
+      end
+    end
+
+    # Read a single file from a ZIP archive
+    # @param archive_path [String] Path to ZIP archive
+    # @param entry_name [String] Name of entry to read
+    # @return [String] Contents of the file
+    #
+    # @example
+    #   content = Omnizip.read_from_archive('backup.zip', 'config.yml')
+    def read_from_archive(archive_path, entry_name)
+      unless ::File.exist?(archive_path)
+        raise Errno::ENOENT,
+              "Archive not found: #{archive_path}"
+      end
+
+      Omnizip::Zip::File.open(archive_path) do |zip|
+        entry = zip.get_entry(entry_name)
+        raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+        zip.read(entry)
+      end
+    end
+
+    # Add a file to an existing ZIP archive
+    # @param archive_path [String] Path to ZIP archive
+    # @param entry_name [String] Name for entry in archive
+    # @param source_path [String] Path to source file
+    # @return [String] Path to archive
+    #
+    # @example
+    #   Omnizip.add_to_archive('backup.zip', 'new_file.txt', 'path/to/new_file.txt')
+    def add_to_archive(archive_path, entry_name, source_path)
+      unless ::File.exist?(archive_path)
+        raise Errno::ENOENT,
+              "Archive not found: #{archive_path}"
+      end
+      unless ::File.exist?(source_path)
+        raise Errno::ENOENT,
+              "Source file not found: #{source_path}"
+      end
+
+      Omnizip::Zip::File.open(archive_path) do |zip|
+        zip.add(entry_name, source_path)
+      end
+
+      archive_path
+    end
+
+    # Remove a file from a ZIP archive
+    # @param archive_path [String] Path to ZIP archive
+    # @param entry_name [String] Name of entry to remove
+    # @return [String] Path to archive
+    #
+    # @example
+    #   Omnizip.remove_from_archive('backup.zip', 'old_file.txt')
+    def remove_from_archive(archive_path, entry_name)
+      unless ::File.exist?(archive_path)
+        raise Errno::ENOENT,
+              "Archive not found: #{archive_path}"
+      end
+
+      Omnizip::Zip::File.open(archive_path) do |zip|
+        zip.remove(entry_name)
+      end
+
+      archive_path
+    end
+
+    # Create a RAR archive
+    # @param archive_path [String] Path to output RAR file
+    # @param options [Hash] Creation options
+    # @option options [Integer] :version RAR version (4 or 5, default: 5 for pure Ruby)
+    # @option options [Symbol] :compression For RAR5: :store, :lzma, :auto (default: :store)
+    # @option options [Integer] :level For RAR5: LZMA compression level 1-5 (default: 3)
+    # @option options [Boolean] :include_mtime Include modification time (RAR5 only, default: false)
+    # @option options [Boolean] :include_crc32 Include CRC32 checksum (RAR5 only, default: false)
+    # @yield [writer] RAR writer instance
+    # @return [String] Path to created archive
+    #
+    # @example Create RAR5 archive with STORE compression
+    #   Omnizip.create_rar('backup.rar') do |rar|
+    #     rar.add_file('document.pdf')
+    #   end
+    #
+    # @example Create RAR5 with LZMA compression
+    #   Omnizip.create_rar('backup.rar', compression: :lzma, level: 5) do |rar|
+    #     rar.add_file('data.txt')
+    #   end
+    #
+    # @example Create RAR5 with optional fields
+    #   Omnizip.create_rar('backup.rar',
+    #     compression: :lzma,
+    #     level: 3,
+    #     include_mtime: true,
+    #     include_crc32: true
+    #   ) do |rar|
+    #     rar.add_file('important.doc')
+    #   end
+    # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+    def create_rar(archive_path, **options, &block)
+      # Default to RAR5 (pure Ruby) unless explicitly specified
+      options[:version] ||= 5
+
+      Omnizip::Formats::Rar.create(archive_path, options, &block)
+    end
+    # rubocop:enable Naming/BlockForwarding, Style/ArgumentsForwarding
+
+    private
+
+    # Apply compression profile to options
+    #
+    # @param file_path [String, nil] File path for auto-detection
+    # @param options [Hash] Compression options
+    # @return [Hash] Updated options with profile settings
+    def apply_profile(file_path, options)
+      profile_spec = options.delete(:profile)
+      return options unless profile_spec
+
+      # Get the profile
+      profile = case profile_spec
+                when :auto
+                  # Auto-detect based on file
+                  file_path ? Omnizip::Profile.detect(file_path) : Omnizip::Profile.get(:balanced)
+                when Symbol
+                  # Get by name
+                  Omnizip::Profile.get(profile_spec) || Omnizip::Profile.get(:balanced)
+                when Omnizip::Profile::CompressionProfile
+                  # Use the profile directly
+                  profile_spec
+                else
+                  Omnizip::Profile.get(:balanced)
+                end
+
+      # Apply profile to options
+      profile.apply_to(options)
+    end
+
+    # Find first file in directory for profile detection
+    #
+    # @param dir_path [String] Directory path
+    # @return [String, nil] Path to first file or nil
+    def find_first_file(dir_path)
+      Dir.foreach(dir_path) do |entry|
+        next if [".", ".."].include?(entry)
+
+        full_path = ::File.join(dir_path, entry)
+        return full_path if ::File.file?(full_path)
+
+        # Check subdirectories
+        if ::File.directory?(full_path)
+          result = find_first_file(full_path)
+          return result if result
+        end
+      end
+      nil
+    end
+
+    # Recursively add directory contents to archive
+    def add_directory_contents(zip, base_dir, relative_path, recursive: true)
+      dir_path = ::File.join(base_dir, relative_path)
+
+      Dir.foreach(dir_path) do |entry|
+        next if [".", ".."].include?(entry)
+
+        full_path = ::File.join(dir_path, entry)
+
+        # Create archive path (strip leading separator if at root)
+        archive_path = if relative_path.empty?
+                         entry
+                       else
+                         ::File.join(relative_path, entry)
+                       end
+
+        if ::File.directory?(full_path)
+          # Add directory entry with trailing slash
+          dir_entry_name = archive_path.end_with?("/") ? archive_path : "#{archive_path}/"
+          zip.add(dir_entry_name)
+
+          # Recursively add contents if requested
+          if recursive
+            add_directory_contents(zip, base_dir, archive_path,
+                                   recursive: recursive)
+          end
+        else
+          # Add file with its data
+          zip.add(archive_path, full_path)
+        end
+      end
+    end
+  end
+
+  # Extend Omnizip module with convenience methods
+  extend Convenience
+end

data/lib/omnizip/converter/conversion_registry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Converter
+    # Registry for conversion strategies
+    class ConversionRegistry
+      @strategies = []
+
+      class << self
+        # Register a conversion strategy
+        # @param strategy_class [Class] Strategy class
+        def register(strategy_class)
+          @strategies << strategy_class unless @strategies.include?(strategy_class)
+        end
+
+        # Find strategy for source and target formats
+        # @param source [String] Source file path
+        # @param target [String] Target file path
+        # @return [Class, nil] Strategy class or nil
+        def find_strategy(source, target)
+          @strategies.find { |strategy| strategy.can_convert?(source, target) }
+        end
+
+        # Get all registered strategies
+        # @return [Array<Class>] List of strategy classes
+        def strategies
+          @strategies
+        end
+
+        # Check if conversion is supported
+        # @param source [String] Source file path
+        # @param target [String] Target file path
+        # @return [Boolean] True if supported
+        def supported?(source, target)
+          !find_strategy(source, target).nil?
+        end
+
+        # Reset registry (for testing)
+        def reset
+          @strategies = []
+        end
+      end
+    end
+
+    # Register built-in strategies
+    ConversionRegistry.register(ZipToSevenZipStrategy)
+    ConversionRegistry.register(SevenZipToZipStrategy)
+  end
+end

data/lib/omnizip/converter/conversion_strategy.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Converter
+    # Base class for archive format conversion strategies
+    class ConversionStrategy
+      attr_reader :source_path, :target_path, :options
+
+      # Initialize conversion strategy
+      # @param source_path [String] Source archive path
+      # @param target_path [String] Target archive path
+      # @param options [ConversionOptions] Conversion options
+      def initialize(source_path, target_path, options)
+        @source_path = source_path
+        @target_path = target_path
+        @options = options
+        @warnings = []
+      end
+
+      # Perform the conversion
+      # @return [ConversionResult] Conversion result
+      # @raise [NotImplementedError] Subclasses must implement
+      def convert
+        raise NotImplementedError, "#{self.class} must implement #convert"
+      end
+
+      # Get source format
+      # @return [Symbol] Source format
+      # @raise [NotImplementedError] Subclasses must implement
+      def source_format
+        raise NotImplementedError, "#{self.class} must implement #source_format"
+      end
+
+      # Get target format
+      # @return [Symbol] Target format
+      # @raise [NotImplementedError] Subclasses must implement
+      def target_format
+        raise NotImplementedError, "#{self.class} must implement #target_format"
+      end
+
+      # Check if this strategy can handle the conversion
+      # @param source [String] Source file path
+      # @param target [String] Target file path
+      # @return [Boolean] True if can handle
+      def self.can_convert?(_source, _target)
+        false
+      end
+
+      protected
+
+      # Add a warning message
+      # @param message [String] Warning message
+      def add_warning(message)
+        @warnings << message
+      end
+
+      # Get all warnings
+      # @return [Array<String>] List of warnings
+      def warnings
+        @warnings
+      end
+
+      # Detect format from file extension
+      # @param path [String] File path
+      # @return [Symbol] Format
+      def detect_format(path)
+        ext = File.extname(path).downcase
+        case ext
+        when ".zip"
+          :zip
+        when ".7z"
+          :seven_zip
+        else
+          raise ArgumentError, "Unknown format for file: #{path}"
+        end
+      end
+
+      # Create conversion result
+      # @param start_time [Time] Start time
+      # @param entry_count [Integer] Number of entries
+      # @return [ConversionResult] Result object
+      def create_result(start_time, entry_count)
+        require_relative "../models/conversion_result"
+
+        duration = Time.now - start_time
+        source_size = File.size(source_path)
+        target_size = File.size(target_path)
+
+        Omnizip::Models::ConversionResult.new(
+          source_path: source_path,
+          target_path: target_path,
+          source_format: source_format,
+          target_format: target_format,
+          source_size: source_size,
+          target_size: target_size,
+          duration: duration,
+          entry_count: entry_count,
+          warnings: warnings,
+        )
+      end
+
+      # Check if metadata is compatible between formats
+      # @param entry [Entry] Entry to check
+      # @return [Boolean] True if fully compatible
+      def metadata_compatible?(_entry)
+        # ZIP supports most metadata
+        # 7z has limited metadata support
+        case [source_format, target_format]
+        when %i[zip seven_zip]
+          # Some metadata loss (comments, extra fields)
+          false
+        when %i[seven_zip zip]
+          # Can preserve most 7z metadata in ZIP
+          true
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/converter/seven_zip_to_zip_strategy.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "conversion_strategy"
+
+module Omnizip
+  module Converter
+    # Convert 7-Zip archives to ZIP format
+    class SevenZipToZipStrategy < ConversionStrategy
+      # Perform 7z to ZIP conversion
+      # @return [ConversionResult] Conversion result
+      def convert
+        start_time = Time.now
+        0
+
+        require_relative "../formats/seven_zip"
+        require_relative "../zip/file"
+
+        # Open source 7z archive
+        reader = Omnizip::Formats::SevenZip::Reader.new(source_path)
+        reader.read
+
+        # Collect entries
+        entries_data = collect_seven_zip_entries(reader)
+        entry_count = entries_data.size
+
+        # Create target ZIP archive
+        create_zip(entries_data)
+
+        create_result(start_time, entry_count)
+      end
+
+      # Get source format
+      # @return [Symbol] Source format (:seven_zip)
+      def source_format
+        :seven_zip
+      end
+
+      # Get target format
+      # @return [Symbol] Target format (:zip)
+      def target_format
+        :zip
+      end
+
+      # Check if can convert
+      # @param source [String] Source file
+      # @param target [String] Target file
+      # @return [Boolean] True if can convert
+      def self.can_convert?(source, target)
+        source.end_with?(".7z") && target.end_with?(".zip")
+      end
+
+      private
+
+      def collect_seven_zip_entries(reader)
+        entries = []
+
+        reader.entries.each do |entry|
+          data = {
+            name: entry.name,
+            content: nil,
+            mtime: entry.mtime || Time.now,
+          }
+
+          # Extract entry data
+          unless entry.name.end_with?("/")
+            File.open(source_path, "rb") do |io|
+              data[:content] = reader.send(:extract_entry_data, io, entry)
+            end
+          end
+
+          entries << data
+        end
+
+        entries
+      end
+
+      def create_zip(entries)
+        Omnizip::Zip::File.create(target_path) do |zip|
+          entries.each do |entry_data|
+            if entry_data[:name].end_with?("/")
+              # Directory entry
+              zip.add(entry_data[:name])
+            else
+              # File entry
+              zip.add(entry_data[:name]) { entry_data[:content] }
+            end
+          end
+
+          # Set archive comment if preserving metadata
+          if options.preserve_metadata
+            zip.comment = "Converted from 7z by Omnizip"
+          end
+        end
+      end
+    end
+  end
+end