omnizip 0.4.7-arm-linux

data/lib/omnizip/pipe/stream_decompressor.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Pipe
+    # Stream-based decompression for pipe operations
+    #
+    # Accepts compressed archive from any IO-like source and extracts
+    # to directory or streams to output. Handles multi-file archives
+    # and provides error recovery for corrupted streams.
+    #
+    # @example Decompress to directory
+    #   decompressor = StreamDecompressor.new($stdin, output_dir: 'extracted/')
+    #   decompressor.decompress
+    #
+    # @example Decompress to stdout
+    #   decompressor = StreamDecompressor.new($stdin, output: $stdout)
+    #   decompressor.decompress
+    class StreamDecompressor
+      # Default chunk size for streaming extraction (64KB)
+      DEFAULT_CHUNK_SIZE = 64 * 1024
+
+      attr_reader :input, :output_dir, :output, :options, :bytes_written
+
+      # Initialize stream decompressor
+      #
+      # @param input [IO] Input stream containing archive
+      # @param output_dir [String, nil] Directory to extract to
+      # @param output [IO, nil] Output stream (for single-file extraction)
+      # @param options [Hash] Decompression options
+      # @option options [Symbol] :format Archive format (auto-detected if nil)
+      # @option options [Integer] :chunk_size Write buffer size
+      # @option options [Proc] :progress Progress callback
+      # @option options [Boolean] :preserve_paths Preserve directory structure
+      def initialize(input, output_dir: nil, output: nil, **options)
+        @input = input
+        @output_dir = output_dir
+        @output = output
+        @options = options
+        @chunk_size = options[:chunk_size] || DEFAULT_CHUNK_SIZE
+        @bytes_written = 0
+        @progress_callback = options[:progress]
+        @format = options[:format]
+        @preserve_paths = options.fetch(:preserve_paths, true)
+      end
+
+      # Decompress input stream
+      #
+      # Extracts archive to output directory or streams to output.
+      # Returns hash of extracted files or bytes written.
+      #
+      # @return [Hash<String, Integer>, Integer] Files => bytes or total bytes
+      # @raise [Omnizip::FormatError] If archive format is invalid
+      def decompress
+        if @output
+          decompress_to_stream
+        elsif @output_dir
+          decompress_to_directory
+        else
+          raise ArgumentError,
+                "Either output_dir or output must be specified"
+        end
+      end
+
+      private
+
+      # Decompress to output stream
+      #
+      # Extracts first non-directory entry to output stream.
+      # Useful for single-file archives or piping to stdout.
+      #
+      # @return [Integer] Bytes written to output
+      def decompress_to_stream
+        # Read archive into memory (necessary for format detection)
+        archive_data = @input.read
+
+        Omnizip::Buffer.open(archive_data, format: @format) do |archive|
+          archive.each_entry do |entry|
+            next if entry.directory?
+
+            # Stream first file to output
+            while chunk = entry.read(@chunk_size)
+              @output.write(chunk)
+              @bytes_written += chunk.bytesize
+
+              @progress_callback&.call(entry.name, @bytes_written)
+            end
+
+            break # Only extract first file for streaming
+          end
+        end
+
+        @bytes_written
+      rescue StandardError => e
+        raise Omnizip::Error,
+              "Stream decompression failed: #{e.message}"
+      end
+
+      # Decompress to directory
+      #
+      # Extracts all entries to specified directory with
+      # directory structure preservation.
+      #
+      # @return [Hash<String, Integer>] Filename => bytes mapping
+      def decompress_to_directory
+        FileUtils.mkdir_p(@output_dir)
+
+        # Read archive into memory
+        archive_data = @input.read
+        extracted_files = {}
+
+        Omnizip::Buffer.open(archive_data, format: @format) do |archive|
+          archive.each_entry do |entry|
+            if entry.directory?
+              create_directory(entry)
+            else
+              bytes = extract_file(entry)
+              extracted_files[entry.name] = bytes
+            end
+          end
+        end
+
+        extracted_files
+      rescue StandardError => e
+        raise Omnizip::Error,
+              "Directory extraction failed: #{e.message}"
+      end
+
+      # Create directory from entry
+      #
+      # @param entry [Object] Directory entry
+      def create_directory(entry)
+        return unless @preserve_paths
+
+        dir_path = File.join(@output_dir, entry.name)
+        FileUtils.mkdir_p(dir_path)
+      end
+
+      # Extract file from entry
+      #
+      # @param entry [Object] File entry
+      # @return [Integer] Bytes written
+      def extract_file(entry)
+        dest_path = if @preserve_paths
+                      File.join(@output_dir, entry.name)
+                    else
+                      File.join(@output_dir, File.basename(entry.name))
+                    end
+
+        # Create parent directory if needed
+        FileUtils.mkdir_p(File.dirname(dest_path))
+
+        bytes = 0
+        File.open(dest_path, "wb") do |file|
+          while chunk = entry.read(@chunk_size)
+            file.write(chunk)
+            bytes += chunk.bytesize
+            @bytes_written += chunk.bytesize
+
+            @progress_callback&.call(entry.name, @bytes_written)
+          end
+        end
+
+        # Preserve timestamp if available
+        mtime = entry.mtime if entry.is_a?(Omnizip::Metadata::EntryMetadata)
+        File.utime(mtime, mtime, dest_path) if mtime
+
+        bytes
+      end
+    end
+  end
+end

data/lib/omnizip/pipe.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Unix pipe operations for stdin/stdout integration
+  #
+  # Enables compression and decompression through Unix pipes without
+  # temporary files, supporting container workflows, CI/CD pipelines,
+  # and stream processing scenarios.
+  #
+  # @example Compress stdin to stdout
+  #   Omnizip::Pipe.compress($stdin, $stdout, format: :zip)
+  #
+  # @example Decompress stdin to directory
+  #   Omnizip::Pipe.decompress($stdin, output_dir: 'extracted/')
+  #
+  # @example File-to-file via pipe
+  #   File.open('input.txt', 'rb') do |input|
+  #     File.open('output.zip', 'wb') do |output|
+  #       Omnizip::Pipe.compress(input, output, format: :zip)
+  #     end
+  #   end
+  module Pipe
+    autoload :StreamCompressor, "omnizip/pipe/stream_compressor"
+    autoload :StreamDecompressor, "omnizip/pipe/stream_decompressor"
+    class << self
+      # Compress from input stream to output stream
+      #
+      # @param input [IO] Input stream (stdin, File, Socket, etc.)
+      # @param output [IO] Output stream (stdout, File, network, etc.)
+      # @param format [Symbol] Archive format (:zip, :seven_zip)
+      # @param compression [Symbol] Compression algorithm
+      # @param options [Hash] Additional compression options
+      # @option options [String] :entry_name Name for entry in archive
+      # @option options [Integer] :chunk_size Read buffer size (default 64KB)
+      # @option options [Integer] :level Compression level (1-9)
+      # @return [Integer] Number of bytes written
+      #
+      # @example Compress stdin to stdout
+      #   Omnizip::Pipe.compress($stdin, $stdout, format: :zip)
+      #
+      # @example Compress file with custom options
+      #   File.open('data.txt', 'rb') do |input|
+      #     File.open('data.zip', 'wb') do |output|
+      #       Omnizip::Pipe.compress(
+      #         input, output,
+      #         format: :zip,
+      #         compression: :deflate,
+      #         level: 9,
+      #         entry_name: 'data.txt'
+      #       )
+      #     end
+      #   end
+      def compress(input, output, format: :zip, compression: nil, **options)
+        compressor = Pipe::StreamCompressor.new(
+          input,
+          output,
+          format,
+          compression: compression,
+          **options,
+        )
+        compressor.compress
+      end
+
+      # Decompress from input stream
+      #
+      # @param input [IO] Input stream containing archive
+      # @param output_dir [String, nil] Directory to extract to (nil = stdout)
+      # @param options [Hash] Extraction options
+      # @return [Integer, Hash] Bytes written or extracted files hash
+      #
+      # @example Extract to directory
+      #   Omnizip::Pipe.decompress($stdin, output_dir: 'extracted/')
+      #
+      # @example Extract to stdout (single file)
+      #   Omnizip::Pipe.decompress($stdin, output: $stdout)
+      def decompress(input, output_dir: nil, output: nil, **options)
+        decompressor = Pipe::StreamDecompressor.new(
+          input,
+          output_dir: output_dir,
+          output: output,
+          **options,
+        )
+        decompressor.decompress
+      end
+
+      # Check if running in pipe mode
+      #
+      # Detects if stdin/stdout are pipes (not TTY), indicating
+      # the program is being used in a Unix pipeline.
+      #
+      # @return [Boolean] True if stdin and stdout are pipes
+      #
+      # @example
+      #   if Omnizip::Pipe.pipe_mode?
+      #     # Process stdin to stdout
+      #   else
+      #     # Show interactive help
+      #   end
+      def pipe_mode?
+        !$stdin.tty? && !$stdout.tty?
+      end
+
+      # Detect if input is stdin
+      #
+      # @param input [String, IO] Input path or IO object
+      # @return [Boolean] True if input is stdin
+      def stdin?(input)
+        ["-", $stdin].include?(input)
+      end
+
+      # Detect if output is stdout
+      #
+      # @param output [String, IO] Output path or IO object
+      # @return [Boolean] True if output is stdout
+      def stdout?(output)
+        ["-", $stdout].include?(output)
+      end
+    end
+  end
+end

data/lib/omnizip/platform/ntfs_streams.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Omnizip
+  module Platform
+    # NTFS Alternate Data Streams handler
+    # Windows-only feature for managing file alternate streams
+    module NtfsStreams
+      # Check if NTFS streams are available
+      #
+      # @return [Boolean] true if available
+      def self.available?
+        Platform.supports_ntfs_streams?
+      end
+
+      # List alternate data streams for a file
+      #
+      # @param file_path [String] Path to file
+      # @return [Array<String>] List of stream names
+      def self.list_streams(file_path)
+        return [] unless available?
+        return [] unless File.exist?(file_path)
+
+        streams = []
+
+        begin
+          # Use PowerShell to list streams
+          cmd = "powershell -Command \"Get-Item '#{file_path}' -Stream * | " \
+                "Select-Object -ExpandProperty Stream\""
+          output = `#{cmd} 2>&1`
+
+          if $CHILD_STATUS.success?
+            streams = output.lines.map(&:strip).reject do |s|
+              s.empty? || s == ":$DATA"
+            end
+          end
+        rescue StandardError => e
+          warn "Failed to list NTFS streams: #{e.message}" if ENV["DEBUG"]
+        end
+
+        streams
+      end
+
+      # Read alternate data stream
+      #
+      # @param file_path [String] Path to file
+      # @param stream_name [String] Stream name
+      # @return [String, nil] Stream content or nil
+      def self.read_stream(file_path, stream_name)
+        return nil unless available?
+        return nil unless File.exist?(file_path)
+
+        begin
+          # Read using alternate stream syntax: file.txt:StreamName
+          stream_path = "#{file_path}:#{stream_name}"
+          File.binread(stream_path)
+        rescue Errno::ENOENT, Errno::EINVAL
+          nil
+        rescue StandardError => e
+          warn "Failed to read NTFS stream: #{e.message}" if ENV["DEBUG"]
+          nil
+        end
+      end
+
+      # Write alternate data stream
+      #
+      # @param file_path [String] Path to file
+      # @param stream_name [String] Stream name
+      # @param data [String] Stream data
+      # @return [Boolean] true if successful
+      def self.write_stream(file_path, stream_name, data)
+        return false unless available?
+        return false unless File.exist?(file_path)
+
+        begin
+          # Write using alternate stream syntax: file.txt:StreamName
+          stream_path = "#{file_path}:#{stream_name}"
+          File.binwrite(stream_path, data)
+          true
+        rescue StandardError => e
+          warn "Failed to write NTFS stream: #{e.message}" if ENV["DEBUG"]
+          false
+        end
+      end
+
+      # Delete alternate data stream
+      #
+      # @param file_path [String] Path to file
+      # @param stream_name [String] Stream name
+      # @return [Boolean] true if successful
+      def self.delete_stream(file_path, stream_name)
+        return false unless available?
+        return false unless File.exist?(file_path)
+
+        begin
+          # Use PowerShell to remove stream
+          cmd = "powershell -Command \"Remove-Item -Path '#{file_path}' " \
+                "-Stream '#{stream_name}'\""
+          system(cmd)
+          $CHILD_STATUS.success?
+        rescue StandardError => e
+          warn "Failed to delete NTFS stream: #{e.message}" if ENV["DEBUG"]
+          false
+        end
+      end
+
+      # Copy all alternate streams from source to destination
+      #
+      # @param source_path [String] Source file
+      # @param dest_path [String] Destination file
+      # @return [Integer] Number of streams copied
+      def self.copy_streams(source_path, dest_path)
+        return 0 unless available?
+        return 0 unless File.exist?(source_path)
+        return 0 unless File.exist?(dest_path)
+
+        copied = 0
+        streams = list_streams(source_path)
+
+        streams.each do |stream|
+          next if stream == "$DATA" # Skip main data stream
+
+          data = read_stream(source_path, stream)
+          copied += 1 if data && write_stream(dest_path, stream, data)
+        end
+
+        copied
+      end
+
+      # Get stream information
+      #
+      # @param file_path [String] Path to file
+      # @param stream_name [String] Stream name
+      # @return [Hash, nil] Stream info or nil
+      def self.stream_info(file_path, stream_name)
+        return nil unless available?
+        return nil unless File.exist?(file_path)
+
+        data = read_stream(file_path, stream_name)
+        return nil unless data
+
+        {
+          name: stream_name,
+          size: data.bytesize,
+          exists: true,
+        }
+      end
+
+      # Check if file has any alternate streams
+      #
+      # @param file_path [String] Path to file
+      # @return [Boolean] true if has streams
+      def self.has_streams?(file_path)
+        return false unless available?
+
+        streams = list_streams(file_path)
+        streams.any? { |s| s != "$DATA" }
+      end
+
+      # Archive streams to a hash
+      #
+      # @param file_path [String] Path to file
+      # @return [Hash<String, String>] Stream name => data
+      def self.archive_streams(file_path)
+        return {} unless available?
+
+        streams_data = {}
+        streams = list_streams(file_path)
+
+        streams.each do |stream|
+          next if stream == "$DATA"
+
+          data = read_stream(file_path, stream)
+          streams_data[stream] = data if data
+        end
+
+        streams_data
+      end
+
+      # Restore streams from hash
+      #
+      # @param file_path [String] Path to file
+      # @param streams_data [Hash<String, String>] Stream name => data
+      # @return [Integer] Number of streams restored
+      def self.restore_streams(file_path, streams_data)
+        return 0 unless available?
+        return 0 unless File.exist?(file_path)
+
+        restored = 0
+
+        streams_data.each do |stream_name, data|
+          restored += 1 if write_stream(file_path, stream_name, data)
+        end
+
+        restored
+      end
+    end
+  end
+end

data/lib/omnizip/platform.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Platform detection and capabilities
+  # Provides cross-platform compatibility checks
+  module Platform
+    # Detect if running on Windows
+    #
+    # @return [Boolean] true if Windows
+    def self.windows?
+      !!(RUBY_PLATFORM =~ /mswin|mingw|cygwin/)
+    end
+
+    # Detect if running on macOS
+    #
+    # @return [Boolean] true if macOS
+    def self.macos?
+      !!RUBY_PLATFORM.include?("darwin")
+    end
+
+    # Detect if running on Linux
+    #
+    # @return [Boolean] true if Linux
+    def self.linux?
+      !!RUBY_PLATFORM.include?("linux")
+    end
+
+    # Detect if running on Unix-like system
+    #
+    # @return [Boolean] true if Unix-like (macOS, Linux, BSD, etc.)
+    def self.unix?
+      !windows?
+    end
+
+    # Get platform name
+    #
+    # @return [String] Platform name
+    def self.name
+      return "Windows" if windows?
+      return "macOS" if macos?
+      return "Linux" if linux?
+
+      "Unknown"
+    end
+
+    # Check if NTFS alternate streams are supported
+    # Only available on Windows with NTFS filesystem
+    #
+    # @return [Boolean] true if NTFS streams supported
+    def self.supports_ntfs_streams?
+      windows?
+    end
+
+    # Check if symbolic links are supported
+    #
+    # @return [Boolean] true if symlinks supported
+    def self.supports_symlinks?
+      unix? || (windows? && windows_developer_mode?)
+    end
+
+    # Check if hard links are supported
+    #
+    # @return [Boolean] true if hard links supported
+    def self.supports_hardlinks?
+      true # Supported on all modern platforms
+    end
+
+    # Check if extended attributes are supported
+    #
+    # @return [Boolean] true if xattrs supported
+    def self.supports_extended_attributes?
+      unix?
+    end
+
+    # Check if file permissions are supported
+    #
+    # @return [Boolean] true if POSIX permissions supported
+    def self.supports_file_permissions?
+      unix?
+    end
+
+    # Get platform-specific features
+    #
+    # @return [Hash] Feature flags
+    def self.features
+      {
+        ntfs_streams: supports_ntfs_streams?,
+        symlinks: supports_symlinks?,
+        hardlinks: supports_hardlinks?,
+        extended_attributes: supports_extended_attributes?,
+        file_permissions: supports_file_permissions?,
+      }
+    end
+
+    # Check Windows Developer Mode (for symlink support)
+    #
+    # @return [Boolean] true if developer mode enabled
+    def self.windows_developer_mode?
+      return false unless windows?
+
+      # Check registry for developer mode setting
+      # HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock
+      # AllowDevelopmentWithoutDevLicense = 1
+      begin
+        require "win32/registry"
+        Win32::Registry::HKEY_LOCAL_MACHINE.open(
+          'SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock',
+          Win32::Registry::KEY_READ,
+        ) do |reg|
+          value = reg["AllowDevelopmentWithoutDevLicense"]
+          return value == 1
+        end
+      rescue LoadError, StandardError
+        # win32/registry not available or key doesn't exist
+        false
+      end
+    end
+
+    # Get file system type for a path
+    #
+    # @param path [String] File or directory path
+    # @return [String, nil] Filesystem type or nil if unknown
+    def self.filesystem_type(path)
+      return nil unless File.exist?(path)
+
+      if windows?
+        detect_windows_filesystem(path)
+      elsif macos?
+        detect_macos_filesystem(path)
+      elsif linux?
+        detect_linux_filesystem(path)
+      end
+    end
+
+    # Check if path is on NTFS filesystem
+    #
+    # @param path [String] File or directory path
+    # @return [Boolean] true if NTFS
+    def self.ntfs?(path)
+      filesystem_type(path)&.upcase == "NTFS"
+    end
+
+    # Detect Windows filesystem type
+    #
+    # @param path [String] Path
+    # @return [String, nil] Filesystem type
+    def self.detect_windows_filesystem(path)
+      # Get drive letter
+      drive = File.expand_path(path)[0, 2]
+      return nil unless drive =~ /^[A-Za-z]:$/
+
+      # Use fsutil to get filesystem type
+      output = `fsutil fsinfo volumeinfo #{drive} 2>&1`
+      Regexp.last_match(1) if output =~ /File System Name\s*:\s*(\w+)/i
+    rescue StandardError
+      nil
+    end
+
+    # Detect macOS filesystem type
+    #
+    # @param path [String] Path
+    # @return [String, nil] Filesystem type
+    def self.detect_macos_filesystem(path)
+      output = `df -T #{path} 2>&1`.lines.last
+      return nil unless output
+
+      # Format: filesystem type blocks used avail capacity mounted
+      parts = output.split
+      parts[1] if parts.size > 1
+    rescue StandardError
+      nil
+    end
+
+    # Detect Linux filesystem type
+    #
+    # @param path [String] Path
+    # @return [String, nil] Filesystem type
+    def self.detect_linux_filesystem(path)
+      output = `df -T #{path} 2>&1`.lines.last
+      return nil unless output
+
+      # Format: filesystem type blocks used avail use% mounted
+      parts = output.split
+      parts[1] if parts.size > 1
+    rescue StandardError
+      nil
+    end
+  end
+end