omnizip 0.3.1

data/lib/omnizip/formats/rar/constants.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR format constants
+      module Constants
+        # RAR signatures
+        RAR4_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00].freeze
+        RAR5_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00].freeze
+
+        # Block types (RAR4)
+        BLOCK_MARKER = 0x72
+        BLOCK_ARCHIVE = 0x73
+        BLOCK_FILE = 0x74
+        BLOCK_COMMENT = 0x75
+        BLOCK_OLD_EXTRA = 0x76
+        BLOCK_OLD_SUBBLOCK = 0x77
+        BLOCK_OLD_RECOVERY = 0x78
+        BLOCK_OLD_AUTH = 0x79
+        BLOCK_SUBBLOCK = 0x7A
+        BLOCK_ENDARC = 0x7B
+
+        # Archive flags
+        ARCHIVE_VOLUME = 0x0001
+        ARCHIVE_COMMENT = 0x0002
+        ARCHIVE_LOCKED = 0x0004
+        ARCHIVE_SOLID = 0x0008
+        ARCHIVE_NEW_NAMING = 0x0010
+        ARCHIVE_AUTH_INFO = 0x0020
+        ARCHIVE_RECOVERY = 0x0040
+        ARCHIVE_ENCRYPTED = 0x0080
+        ARCHIVE_FIRST_VOLUME = 0x0100
+
+        # File flags
+        FILE_SPLIT_BEFORE = 0x0001
+        FILE_SPLIT_AFTER = 0x0002
+        FILE_ENCRYPTED = 0x0004
+        FILE_COMMENT = 0x0008
+        FILE_SOLID = 0x0010
+        FILE_DIRECTORY = 0x00E0
+        FILE_LARGE = 0x0100
+        FILE_UNICODE = 0x0200
+        FILE_SALT = 0x0400
+        FILE_VERSION = 0x0800
+        FILE_EXT_TIME = 0x1000
+
+        # RAR5 header types
+        RAR5_HEADER_MAIN = 1
+        RAR5_HEADER_FILE = 2
+        RAR5_HEADER_SERVICE = 3
+        RAR5_HEADER_ENCRYPTION = 4
+        RAR5_HEADER_END = 5
+
+        # RAR5 flags
+        RAR5_FLAG_EXTRA_AREA = 0x0001
+        RAR5_FLAG_DATA_AREA = 0x0002
+        RAR5_FLAG_UNKNOWN_BLOCKS = 0x0004
+        RAR5_FLAG_DATA_INHERITED = 0x0008
+        RAR5_FLAG_CHILD_BLOCKS = 0x0010
+        RAR5_FLAG_IS_DIR = 0x0020
+        RAR5_FLAG_MULTI_VOLUME = 0x0001
+
+        # Compression methods
+        METHOD_STORE = 0x30
+        METHOD_FASTEST = 0x31
+        METHOD_FAST = 0x32
+        METHOD_NORMAL = 0x33
+        METHOD_GOOD = 0x34
+        METHOD_BEST = 0x35
+
+        # Host OS
+        OS_MSDOS = 0
+        OS_OS2 = 1
+        OS_WIN32 = 2
+        OS_UNIX = 3
+        OS_MACOS = 4
+        OS_BEOS = 5
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/decompressor.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "English"
+module Omnizip
+  module Formats
+    module Rar
+      # RAR decompressor wrapper
+      # Provides fallback chain: unrar gem → system command → error
+      class Decompressor
+        class << self
+          # Check if RAR decompression is available
+          #
+          # @return [Boolean] true if available
+          def available?
+            gem_available? || command_available?
+          end
+
+          # Get decompressor information
+          #
+          # @return [Hash] Decompressor type and version
+          def info
+            if gem_available?
+              { type: :gem, version: gem_version }
+            elsif command_available?
+              { type: :command, version: command_version }
+            else
+              { type: :none, version: nil }
+            end
+          end
+
+          # Check if unrar gem is available
+          #
+          # @return [Boolean] true if gem available
+          def gem_available?
+            require "unrar"
+            true
+          rescue LoadError
+            false
+          end
+
+          # Check if system unrar command is available
+          #
+          # @return [Boolean] true if command available
+          def command_available?
+            !command_path.nil?
+          end
+
+          # Get unrar command path
+          #
+          # @return [String, nil] Path to unrar or nil
+          def command_path
+            @command_path ||= find_command
+          end
+
+          # Extract RAR archive to directory
+          #
+          # @param archive_path [String] Path to RAR archive
+          # @param output_dir [String] Output directory
+          # @param password [String, nil] Optional password
+          # @raise [RuntimeError] if extraction fails
+          def extract(archive_path, output_dir, password: nil)
+            raise "RAR extraction not available" unless available?
+
+            if gem_available?
+              extract_with_gem(archive_path, output_dir, password)
+            elsif command_available?
+              extract_with_command(archive_path, output_dir, password)
+            else
+              raise unsupported_error
+            end
+          end
+
+          # List RAR archive contents
+          #
+          # @param archive_path [String] Path to RAR archive
+          # @return [Array<Hash>] Entry information
+          # @raise [RuntimeError] if listing fails
+          def list(archive_path)
+            raise "RAR extraction not available" unless available?
+
+            if gem_available?
+              list_with_gem(archive_path)
+            elsif command_available?
+              list_with_command(archive_path)
+            else
+              raise unsupported_error
+            end
+          end
+
+          # Extract single entry from RAR
+          #
+          # @param archive_path [String] Path to RAR archive
+          # @param entry_name [String] Entry name
+          # @param output_path [String] Output path
+          # @param password [String, nil] Optional password
+          def extract_entry(archive_path, entry_name, output_path,
+                            password: nil)
+            raise "RAR extraction not available" unless available?
+
+            if gem_available?
+              extract_entry_with_gem(archive_path, entry_name,
+                                     output_path, password)
+            elsif command_available?
+              extract_entry_with_command(archive_path, entry_name,
+                                         output_path, password)
+            else
+              raise unsupported_error
+            end
+          end
+
+          private
+
+          # Find unrar command
+          #
+          # @return [String, nil] Command path or nil
+          def find_command
+            ["unrar", "/usr/bin/unrar", "/usr/local/bin/unrar"].each do |cmd|
+              return cmd if system("which #{cmd} > /dev/null 2>&1")
+            end
+            nil
+          end
+
+          # Get gem version
+          #
+          # @return [String] Version string
+          def gem_version
+            require "unrar"
+            begin
+              Unrar::VERSION
+            rescue StandardError
+              "unknown"
+            end
+          end
+
+          # Get command version
+          #
+          # @return [String] Version string
+          def command_version
+            return nil unless command_available?
+
+            output = `#{command_path} 2>&1`
+            output.match(/UNRAR\s+([\d.]+)/i)&.captures&.first || "unknown"
+          end
+
+          # Extract with unrar gem
+          def extract_with_gem(archive_path, output_dir, password)
+            require "unrar"
+            Unrar.extract(archive_path, output_dir, password: password)
+          rescue StandardError => e
+            raise "Gem extraction failed: #{e.message}"
+          end
+
+          # Extract with system command
+          def extract_with_command(archive_path, output_dir, password)
+            cmd = build_extract_command(archive_path, output_dir, password)
+            return if system(cmd)
+
+            raise "Command extraction failed: #{archive_path}"
+          end
+
+          # List with unrar gem
+          def list_with_gem(archive_path)
+            require "unrar"
+            archive = Unrar::Archive.new(archive_path)
+            archive.list.map do |entry|
+              {
+                name: entry.filename,
+                size: entry.unpacked_size,
+                compressed_size: entry.packed_size,
+                is_dir: entry.directory?,
+                mtime: entry.file_time,
+              }
+            end
+          rescue StandardError => e
+            raise "Gem listing failed: #{e.message}"
+          end
+
+          # List with system command
+          def list_with_command(archive_path)
+            output = `#{command_path} vb "#{archive_path}" 2>&1`
+            raise "Command listing failed" unless $CHILD_STATUS.success?
+
+            output.split("\n").map do |line|
+              { name: line.strip, size: 0, compressed_size: 0,
+                is_dir: false, mtime: nil }
+            end
+          end
+
+          # Extract entry with gem
+          def extract_entry_with_gem(archive_path, entry_name,
+                                     output_path, password)
+            require "unrar"
+            archive = Unrar::Archive.new(archive_path)
+            archive.extract_to_file(entry_name, output_path,
+                                    password: password)
+          rescue StandardError => e
+            raise "Gem entry extraction failed: #{e.message}"
+          end
+
+          # Extract entry with command
+          def extract_entry_with_command(archive_path, entry_name,
+                                         output_path, password)
+            temp_dir = Dir.mktmpdir
+            cmd = build_extract_command(archive_path, temp_dir, password)
+            unless system(cmd)
+              raise "Command entry extraction failed: #{entry_name}"
+            end
+
+            source = File.join(temp_dir, entry_name)
+            FileUtils.mv(source, output_path) if File.exist?(source)
+          ensure
+            FileUtils.rm_rf(temp_dir) if temp_dir
+          end
+
+          # Build extract command
+          def build_extract_command(archive_path, output_dir, password)
+            cmd = "#{command_path} x -y"
+            cmd += " -p#{password}" if password
+            cmd += " \"#{archive_path}\" \"#{output_dir}/\""
+            cmd
+          end
+
+          # Unsupported error message
+          def unsupported_error
+            <<~ERROR
+              RAR extraction not available.
+
+              To enable RAR support, install one of:
+              1. unrar gem: gem install unrar
+              2. System unrar: brew install unrar (macOS) or
+                 apt-get install unrar (Linux)
+            ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/external_writer.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require_relative "license_validator"
+
+module Omnizip
+  module Formats
+    module Rar
+      # External RAR writer using licensed WinRAR installation
+      #
+      # This class provides RAR archive creation by wrapping the user's
+      # licensed WinRAR command-line tool. It does NOT implement RAR
+      # compression internally due to proprietary licensing restrictions.
+      #
+      # @example Create a RAR archive
+      #   writer = ExternalWriter.new('archive.rar')
+      #   writer.add_file('document.pdf')
+      #   writer.add_directory('photos/')
+      #   writer.write
+      #
+      # @example Create with options
+      #   writer = ExternalWriter.new('archive.rar',
+      #     compression: :best,
+      #     solid: true,
+      #     recovery: 5
+      #   )
+      class ExternalWriter
+        # @return [String] Output archive path
+        attr_reader :output_path
+
+        # @return [Hash] Compression options
+        attr_reader :options
+
+        # @return [Array<String>] Files to add
+        attr_reader :files
+
+        # Check if RAR creation is available
+        #
+        # @return [Boolean] true if WinRAR executable found
+        def self.available?
+          !find_rar_executable.nil?
+        end
+
+        # Get RAR executable information
+        #
+        # @return [Hash] Executable path and version
+        def self.info
+          exe = find_rar_executable
+          return { available: false } unless exe
+
+          version_output, = Open3.capture2e(exe)
+          version = version_output.match(/RAR\s+([\d.]+)/i)&.[](1) || "unknown"
+
+          {
+            available: true,
+            executable: exe,
+            version: version,
+          }
+        end
+
+        # Find RAR executable on system
+        #
+        # @return [String, nil] Path to executable or nil
+        def self.find_rar_executable
+          if RUBY_PLATFORM.match?(/win32|mingw/)
+            find_windows_rar
+          else
+            find_unix_rar
+          end
+        end
+
+        # Initialize RAR writer
+        #
+        # @param output_path [String] Output RAR file path
+        # @param options [Hash] Compression options
+        # @option options [Symbol] :compression Compression level
+        #   (:store, :fastest, :fast, :normal, :good, :best)
+        # @option options [Boolean] :solid Create solid archive
+        # @option options [Integer] :recovery Recovery record percentage (0-10)
+        # @option options [Boolean] :encrypt_headers Encrypt file names
+        # @option options [String] :password Archive password
+        # @option options [Integer] :volume_size Split into volumes (bytes)
+        # @option options [Boolean] :test_after_create Test archive after creation
+        # @option options [Boolean] :license_confirmed Skip license confirmation
+        def initialize(output_path, options = {})
+          @output_path = output_path
+          @options = default_options.merge(options)
+          @files = []
+          @directories = []
+
+          validate_availability!
+          validate_license! unless @options[:license_confirmed]
+        end
+
+        # Add file to archive
+        #
+        # @param file_path [String] Path to file
+        # @param archive_path [String, nil] Path within archive
+        # @raise [ArgumentError] if file does not exist
+        def add_file(file_path, archive_path = nil)
+          raise ArgumentError, "File not found: #{file_path}" unless
+            File.exist?(file_path)
+
+          @files << {
+            source: File.expand_path(file_path),
+            archive_path: archive_path,
+          }
+        end
+
+        # Add directory to archive
+        #
+        # @param dir_path [String] Path to directory
+        # @param recursive [Boolean] Include subdirectories
+        # @param archive_path [String, nil] Path within archive
+        # @raise [ArgumentError] if directory does not exist
+        def add_directory(dir_path, recursive: true, archive_path: nil)
+          raise ArgumentError, "Directory not found: #{dir_path}" unless
+            Dir.exist?(dir_path)
+
+          @directories << {
+            source: File.expand_path(dir_path),
+            recursive: recursive,
+            archive_path: archive_path,
+          }
+        end
+
+        # Create RAR archive
+        #
+        # @raise [RarNotAvailableError] if WinRAR not available
+        # @raise [RuntimeError] if archive creation fails
+        def write
+          raise RarNotAvailableError unless self.class.available?
+
+          # Build command
+          cmd = build_command
+
+          # Execute RAR
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          unless status.success?
+            raise "RAR creation failed: #{stderr}\n#{stdout}"
+          end
+
+          # Test archive if requested
+          test_archive if @options[:test_after_create]
+
+          @output_path
+        end
+
+        private
+
+        # Default compression options
+        #
+        # @return [Hash] Default options
+        def default_options
+          {
+            compression: :normal,
+            solid: false,
+            recovery: 0,
+            encrypt_headers: false,
+            password: nil,
+            volume_size: nil,
+            test_after_create: false,
+            license_confirmed: false,
+          }
+        end
+
+        # Validate WinRAR availability
+        #
+        # @raise [RarNotAvailableError] if not available
+        def validate_availability!
+          raise RarNotAvailableError unless self.class.available?
+        end
+
+        # Validate license ownership
+        #
+        # @raise [NotLicensedError] if license not confirmed
+        def validate_license!
+          return if LicenseValidator.license_confirmed?
+
+          return if LicenseValidator.confirm_license!
+
+          raise NotLicensedError
+        end
+
+        # Build RAR command line
+        #
+        # @return [Array<String>] Command and arguments
+        def build_command
+          cmd = [rar_executable]
+
+          # Command: a = add
+          cmd << "a"
+
+          # Compression method
+          cmd << compression_switch
+
+          # Solid archive
+          cmd << "-s" if @options[:solid]
+
+          # Recovery record
+          cmd << "-rr#{@options[:recovery]}%" if @options[:recovery].positive?
+
+          # Password
+          if @options[:password]
+            cmd << "-p#{@options[:password]}"
+            cmd << "-hp" if @options[:encrypt_headers]
+          end
+
+          # Volume size
+          cmd << "-v#{@options[:volume_size]}b" if @options[:volume_size]
+
+          # Overwrite existing
+          cmd << "-o+"
+
+          # Output archive path
+          cmd << @output_path
+
+          # Add files and directories
+          @files.each do |file_info|
+            cmd << if file_info[:archive_path]
+                     # RAR doesn't support renaming in command line easily
+                     # Would need to use temporary directory structure
+                   end
+            file_info[:source]
+          end
+
+          @directories.each do |dir_info|
+            cmd << "-r" if dir_info[:recursive]
+            cmd << "#{dir_info[:source]}/*"
+          end
+
+          cmd
+        end
+
+        # Get compression switch for level
+        #
+        # @return [String] Compression switch
+        def compression_switch
+          case @options[:compression]
+          when :store then "-m0"
+          when :fastest then "-m1"
+          when :fast then "-m2"
+          when :normal then "-m3"
+          when :good then "-m4"
+          when :best then "-m5"
+          else "-m3"
+          end
+        end
+
+        # Test archive integrity
+        #
+        # @raise [RuntimeError] if test fails
+        def test_archive
+          cmd = [rar_executable, "t", @output_path]
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          return if status.success?
+
+          raise "Archive test failed: #{stderr}\n#{stdout}"
+        end
+
+        # Get RAR executable path
+        #
+        # @return [String] Path to executable
+        def rar_executable
+          self.class.find_rar_executable
+        end
+
+        # Find WinRAR on Windows
+        #
+        # @return [String, nil] Path or nil
+        def self.find_windows_rar
+          # Check common installation paths
+          paths = [
+            "C:\\Program Files\\WinRAR\\Rar.exe",
+            "C:\\Program Files (x86)\\WinRAR\\Rar.exe",
+          ]
+
+          # Check PATH
+          path_rar = which("rar.exe") || which("Rar.exe")
+          paths.unshift(path_rar) if path_rar
+
+          paths.find { |path| File.exist?(path) }
+        end
+
+        # Find RAR on Unix systems
+        #
+        # @return [String, nil] Path or nil
+        def self.find_unix_rar
+          which("rar")
+        end
+
+        # Find executable in PATH
+        #
+        # @param cmd [String] Command name
+        # @return [String, nil] Path or nil
+        def self.which(cmd)
+          exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+          ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              exe = File.join(path, "#{cmd}#{ext}")
+              return exe if File.executable?(exe) && !File.directory?(exe)
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end