omnizip 0.4.7-aarch64-linux

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

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "English"
+require "fileutils"
+require "tmpdir"
+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 Omnizip::RarNotAvailableError, "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 Omnizip::RarNotAvailableError, "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 Omnizip::RarNotAvailableError, "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
+            if Gem.win_platform?
+              find_command_windows
+            else
+              find_command_unix
+            end
+          end
+
+          # Find unrar command on Unix
+          #
+          # @return [String, nil] Command path or nil
+          def find_command_unix
+            ["unrar", "/usr/bin/unrar", "/usr/local/bin/unrar"].each do |cmd|
+              return cmd if system("which #{cmd} > #{File::NULL} 2>&1")
+            end
+            nil
+          end
+
+          # Find unrar command on Windows
+          #
+          # @return [String, nil] Command path or nil
+          def find_command_windows
+            # Check for unrar in PATH
+            ["UnRAR.exe", "unrar.exe"].each do |cmd|
+              return cmd if system("where #{cmd} > #{File::NULL} 2>&1")
+            end
+
+            # Check common WinRAR install locations
+            [
+              File.join(ENV.fetch("ProgramFiles", 'C:\Program Files'),
+                        "WinRAR", "UnRAR.exe"),
+              File.join(
+                ENV.fetch("ProgramFiles(x86)",
+                          'C:\Program Files (x86)'),
+                "WinRAR", "UnRAR.exe"
+              ),
+            ].each do |path|
+              return path if File.exist?(path)
+            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 Omnizip::DecompressionError, "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 Omnizip::DecompressionError, "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 Omnizip::DecompressionError, "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 Omnizip::DecompressionError, "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 Omnizip::DecompressionError, "Gem entry extraction failed: #{e.message}"
+          end
+
+          # Extract entry with command
+          #
+          # unrar cannot extract a single entry without walking the
+          # archive, so the archive spills to a cache directory ONCE
+          # per archive path; subsequent extractions copy out of the
+          # cache instead of re-running unrar over the whole file.
+          def extract_entry_with_command(archive_path, entry_name,
+                                         output_path, password)
+            cache_key = begin
+              File.realpath(archive_path)
+            rescue StandardError
+              archive_path
+            end
+
+            cached_dir = extract_cache[cache_key]
+            unless cached_dir
+              cached_dir = Dir.mktmpdir("omnizip_unrar")
+              cmd = build_extract_command(archive_path, cached_dir, password)
+              unless system(*cmd)
+                FileUtils.rm_rf(cached_dir)
+                raise Omnizip::DecompressionError, "Command entry extraction failed: #{entry_name}"
+              end
+              extract_cache[cache_key] = cached_dir
+              install_exit_sweeper
+            end
+
+            source = File.join(cached_dir, entry_name)
+            FileUtils.cp(source, output_path) if File.exist?(source)
+          end
+
+          # Extracted-archive cache: archive path => spill directory.
+          # Cleared by .clear_extract_cache!; an at_exit sweeper
+          # reclaims everything at normal process termination.
+          def extract_cache
+            @extract_cache ||= {}
+          end
+
+          # Drop the extraction cache and remove its directories
+          def clear_extract_cache!
+            extract_cache.each_value { |dir| FileUtils.rm_rf(dir) }
+            extract_cache.clear
+          end
+
+          # Reclaim spill directories when the process exits normally
+          def install_exit_sweeper
+            return if @exit_sweeper_installed
+
+            at_exit { clear_extract_cache! }
+            @exit_sweeper_installed = true
+          end
+
+          # Build extract command
+          def build_extract_command(archive_path, output_dir, password)
+            # Array form: no shell involved, so paths and passwords
+            # with special characters stay literal. -idq silences the
+            # per-file progress banner.
+            cmd = [command_path, "x", "-idq", "-y"]
+            cmd << "-p#{password}" if password
+            cmd << archive_path
+            cmd << "#{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,311 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+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 Omnizip::CompressionError, "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 Omnizip::CompressionError, "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