omnizip 0.4.7-aarch64-linux

data/lib/omnizip/implementations/xz_utils/lzma2.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module XZUtils
+      # XZ Utils LZMA2 implementation namespace
+      module LZMA2
+        autoload :Encoder, "omnizip/implementations/xz_utils/lzma2/encoder"
+        autoload :Decoder, "omnizip/implementations/xz_utils/lzma2/decoder"
+      end
+    end
+  end
+end

data/lib/omnizip/implementations/xz_utils.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    # XZ Utils reference implementations
+    module XZUtils
+      autoload :LZMA2, "omnizip/implementations/xz_utils/lzma2"
+    end
+  end
+end

data/lib/omnizip/implementations.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Bit-level SDK ports: state machines, range coders, match finders,
+  # raw LZMA/LZMA2 encoders and decoders.
+  #
+  # This namespace owns the *primitives*; +Omnizip::Algorithms+ owns
+  # the *streaming contract*. The boundary is: +Algorithms+ calls
+  # +Implementations+, never the reverse. Files under this tree
+  # should never reach across into format-specific concerns (no
+  # .7z header parsing, no ZIP central directory, no tar entry
+  # metadata).
+  #
+  # The two top-level sub-namespaces mirror the upstream SDK split:
+  # - +SevenZip+ : ports of 7-Zip's LZMA/LZMA2 encoder + decoder
+  # - +XZUtils+ : ports of XZ Utils' LZMA/LZMA2 encoder + decoder
+  #
+  # Despite the LZMA name, the two SDKs diverge in subtle ways (no
+  # EOS marker, different chunk padding, different property-byte
+  # handling); keeping them in separate trees makes those
+  # divergences visible rather than hidden in flag parameters.
+  module Implementations
+    autoload :Base, "omnizip/implementations/base"
+  end
+end

data/lib/omnizip/io/buffered_input.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module IO
+    # Buffered input stream for efficient reading.
+    #
+    # This class provides buffered reading capabilities with methods
+    # for reading bytes, integers, and other data types efficiently.
+    class BufferedInput
+      DEFAULT_BUFFER_SIZE = 65_536
+
+      attr_reader :source, :buffer_size, :position
+
+      # Initialize buffered input.
+      #
+      # @param source [IO, #read] Input source
+      # @param buffer_size [Integer] Size of internal buffer
+      def initialize(source, buffer_size: DEFAULT_BUFFER_SIZE)
+        @source = source
+        @buffer_size = buffer_size
+        @buffer = String.new(capacity: buffer_size)
+        @buffer_pos = 0
+        @buffer_end = 0
+        @position = 0
+        @eof = false
+      end
+
+      # Read bytes from the stream.
+      #
+      # @param num_bytes [Integer] Number of bytes to read
+      # @return [String, nil] Read bytes or nil if EOF
+      def read(num_bytes)
+        return nil if @eof && @buffer_pos >= @buffer_end
+
+        result = String.new(capacity: num_bytes)
+        read_into_result(result, num_bytes)
+        result.empty? ? nil : result
+      end
+
+      # Read a single byte.
+      #
+      # @return [Integer, nil] Byte value (0-255) or nil if EOF
+      def read_byte
+        return nil if @eof && @buffer_pos >= @buffer_end
+
+        ensure_buffer_filled
+        return nil if @buffer_pos >= @buffer_end
+
+        consume_byte
+      end
+
+      # Check if at end of stream.
+      #
+      # @return [Boolean] True if at EOF
+      def eof?
+        @eof && @buffer_pos >= @buffer_end
+      end
+
+      # Close the underlying source.
+      #
+      # @return [void]
+      def close
+        # allowed: caller-supplied source may not be closeable
+        @source.close if @source.respond_to?(:close)
+      end
+
+      private
+
+      def read_into_result(result, num_bytes)
+        while result.bytesize < num_bytes && !eof?
+          copy_from_buffer(result, num_bytes)
+        end
+      end
+
+      def copy_from_buffer(result, num_bytes)
+        available = @buffer_end - @buffer_pos
+        if available.positive?
+          copy_available_bytes(result, num_bytes, available)
+        else
+          fill_buffer
+        end
+      end
+
+      def copy_available_bytes(result, num_bytes, available)
+        to_copy = [num_bytes - result.bytesize, available].min
+        result << @buffer[@buffer_pos, to_copy]
+        @buffer_pos += to_copy
+        @position += to_copy
+      end
+
+      def ensure_buffer_filled
+        fill_buffer if @buffer_pos >= @buffer_end
+      end
+
+      def consume_byte
+        byte = @buffer.getbyte(@buffer_pos)
+        @buffer_pos += 1
+        @position += 1
+        byte
+      end
+
+      def fill_buffer
+        return if @eof
+
+        data = @source.read(@buffer_size)
+        update_buffer(data)
+      end
+
+      def update_buffer(data)
+        if data.nil? || data.empty?
+          mark_eof
+        else
+          update_buffer_data(data)
+        end
+      end
+
+      def mark_eof
+        @eof = true
+        @buffer = +""
+        @buffer_pos = 0
+        @buffer_end = 0
+      end
+
+      def update_buffer_data(data)
+        @buffer = data
+        @buffer_pos = 0
+        @buffer_end = data.bytesize
+      end
+    end
+  end
+end

data/lib/omnizip/io/buffered_output.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module IO
+    # Buffered output stream for efficient writing.
+    #
+    # This class provides buffered writing capabilities to minimize
+    # I/O operations and improve performance.
+    class BufferedOutput
+      DEFAULT_BUFFER_SIZE = 65_536
+
+      attr_reader :destination, :buffer_size, :position
+
+      # Initialize buffered output.
+      #
+      # @param destination [IO, #write] Output destination
+      # @param buffer_size [Integer] Size of internal buffer
+      def initialize(destination, buffer_size: DEFAULT_BUFFER_SIZE)
+        @destination = destination
+        @buffer_size = buffer_size
+        @buffer = String.new(capacity: buffer_size)
+        @position = 0
+      end
+
+      # Write data to the stream.
+      #
+      # @param data [String] Data to write
+      # @return [Integer] Number of bytes written
+      def write(data)
+        return 0 if data.nil? || data.empty?
+
+        bytes_written = 0
+        offset = 0
+
+        while offset < data.bytesize
+          offset = write_chunk(data, offset)
+          bytes_written = offset
+        end
+
+        bytes_written
+      end
+
+      # Write a single byte.
+      #
+      # @param byte [Integer] Byte value (0-255)
+      # @return [Integer] Number of bytes written (1)
+      def write_byte(byte)
+        @buffer << byte.chr
+        @position += 1
+
+        flush if @buffer.bytesize >= @buffer_size
+
+        1
+      end
+
+      # Flush buffered data to destination.
+      #
+      # @return [void]
+      def flush
+        return if @buffer.empty?
+
+        @destination.write(@buffer)
+        @buffer.clear
+      end
+
+      # Close the stream and flush remaining data.
+      #
+      # @return [void]
+      def close
+        flush
+        # allowed: caller-supplied destination may not be closeable
+        @destination.close if @destination.respond_to?(:close)
+      end
+
+      private
+
+      def write_chunk(data, offset)
+        available = @buffer_size - @buffer.bytesize
+        to_write = [data.bytesize - offset, available].min
+
+        @buffer << data[offset, to_write]
+        @position += to_write
+
+        flush if @buffer.bytesize >= @buffer_size
+
+        offset + to_write
+      end
+    end
+  end
+end

data/lib/omnizip/io/source.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tempfile"
+
+module Omnizip
+  module IO
+    # Polymorphic adapter for "things we can read bytes from".
+    #
+    # Callers that previously did:
+    #
+    #     data = input.respond_to?(:read) ? input.read : File.binread(input)
+    #
+    # should now do:
+    #
+    #     data = Omnizip::IO::Source.for(input).read
+    #
+    # Adapters:
+    # - +IO+/+StringIO+/+Tempfile+ → wrapped as-is
+    # - +String+ → treated as a file path; read with +File.binread+
+    #   unless the string contains no NUL bytes and does not exist on
+    #   disk, in which case it is treated as literal data
+    # - +Object+ responding to +:read+ → delegated to
+    class Source
+      # Build a Source wrapper appropriate for +input+.
+      #
+      # @param input [IO, StringIO, String, #read] the read target
+      # @return [Source]
+      def self.for(input)
+        case input
+        when ::IO, ::StringIO, ::Tempfile then new(input)
+        when String then StringSource.new(input)
+        else
+          # allowed: boundary validation; duck-typing ends at this adapter
+          unless input.respond_to?(:read)
+            raise ArgumentError,
+                  "Cannot adapt #{input.inspect} to Omnizip::IO::Source"
+          end
+
+          new(input)
+        end
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      # Delegate reading to the underlying IO-like object.
+      def read(length = nil, outbuf = nil)
+        if length.nil?
+          @io.read
+        elsif outbuf
+          @io.read(length, outbuf)
+        else
+          @io.read(length)
+        end
+      end
+
+      def close
+        # allowed: wrapped object may be a read-only duck with no close
+        @io.close if @io.respond_to?(:close)
+      end
+
+      # String input adapter. Treats the value as a file path if it
+      # exists on disk and contains no NUL bytes, otherwise as raw
+      # bytes.
+      class StringSource < Source
+        def initialize(value)
+          super(nil)
+          @value = value
+        end
+
+        def read(_length = nil, _outbuf = nil)
+          if file_path?
+            File.binread(@value)
+          else
+            @value.b
+          end
+        end
+
+        def close; end
+
+        private
+
+        def file_path?
+          !@value.include?("\0") && File.exist?(@value)
+        end
+      end
+    end
+
+    # Polymorphic adapter for "things we can write bytes to".
+    #
+    # Adapters:
+    # - +IO+/+StringIO+/+Tempfile+ → wrapped as-is
+    # - +String+ → treated as a file path; writes via +File.binwrite+
+    # - +Object+ responding to +:write+ → delegated to
+    class Sink
+      def self.for(output)
+        case output
+        when ::IO, ::StringIO, ::Tempfile then new(output)
+        when String then PathSink.new(output)
+        else
+          # allowed: boundary validation; duck-typing ends at this adapter
+          unless output.respond_to?(:write)
+            raise ArgumentError,
+                  "Cannot adapt #{output.inspect} to Omnizip::IO::Sink"
+          end
+
+          new(output)
+        end
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      def write(data)
+        @io.write(data)
+      end
+
+      def close
+        # allowed: wrapped object may be a write-only duck with no close
+        @io.close if @io.respond_to?(:close)
+      end
+
+      # File-path sink: opens the file for binary write on #write and
+      # closes after.
+      class PathSink < Sink
+        def initialize(path)
+          super(nil)
+          @path = path
+          @file = nil
+        end
+
+        def write(data)
+          File.binwrite(@path, data)
+        end
+
+        def close; end
+      end
+    end
+  end
+end

data/lib/omnizip/io/stream_manager.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+require "stringio"
+
+module Omnizip
+  module IO
+    # Manages I/O operations and wraps various source types.
+    #
+    # This class provides a unified interface for different I/O sources
+    # including files, IO objects, and strings.
+    class StreamManager
+      attr_reader :source
+
+      # Initialize stream manager.
+      #
+      # @param source [String, IO, File, StringIO] Input source
+      # @param mode [String] File mode (for file paths)
+      def initialize(source, mode: "rb")
+        @source = normalize_source(source, mode)
+        @owned = source.is_a?(String) && File.exist?(source)
+      end
+
+      # Create a buffered input from the source.
+      #
+      # @param buffer_size [Integer] Buffer size
+      # @return [BufferedInput] Buffered input stream
+      def buffered_input(buffer_size: BufferedInput::DEFAULT_BUFFER_SIZE)
+        BufferedInput.new(@source, buffer_size: buffer_size)
+      end
+
+      # Create a buffered output to the source.
+      #
+      # @param buffer_size [Integer] Buffer size
+      # @return [BufferedOutput] Buffered output stream
+      def buffered_output(buffer_size: BufferedOutput::DEFAULT_BUFFER_SIZE)
+        BufferedOutput.new(@source, buffer_size: buffer_size)
+      end
+
+      # Read all data from source.
+      #
+      # @return [String] All data from source
+      def read_all
+        @source.read
+      end
+
+      # Write data to source.
+      #
+      # @param data [String] Data to write
+      # @return [Integer] Number of bytes written
+      def write(data)
+        @source.write(data)
+      end
+
+      # Close the underlying source if owned.
+      #
+      # @return [void]
+      def close
+        @source.close if @owned
+      end
+
+      # Check if source is at end.
+      #
+      # @return [Boolean] True if at EOF
+      def eof?
+        # allowed: write-only sources have no eof?
+        @source.eof? if @source.respond_to?(:eof?)
+      end
+
+      private
+
+      def normalize_source(source, mode)
+        case source
+        when String
+          normalize_string_source(source, mode)
+        when IO, File, StringIO
+          source
+        else
+          validate_io_interface(source)
+        end
+      end
+
+      def normalize_string_source(source, mode)
+        if File.exist?(source)
+          File.open(source, mode)
+        else
+          StringIO.new(source)
+        end
+      end
+
+      def validate_io_interface(source)
+        # allowed: boundary validation of a caller-supplied IO-like object
+        if source.respond_to?(:read) || source.respond_to?(:write)
+          source
+        else
+          raise ArgumentError,
+                "Invalid source type: #{source.class}"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/io.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # I/O utilities module
+  #
+  # Provides buffered I/O operations and stream management
+  # for efficient handling of large files.
+  module IO
+    autoload :BufferedInput, "omnizip/io/buffered_input"
+    autoload :BufferedOutput, "omnizip/io/buffered_output"
+    autoload :StreamManager, "omnizip/io/stream_manager"
+    autoload :Source, "omnizip/io/source"
+    autoload :Sink, "omnizip/io/source"
+  end
+end

data/lib/omnizip/link_handler/hard_link.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module LinkHandler
+    # Model for hard links
+    class HardLink
+      attr_reader :target, :path, :inode
+
+      def initialize(target:, path: nil, inode: nil)
+        @target = target
+        @path = path
+        @inode = inode
+      end
+
+      # Create the hard link on the filesystem
+      def create(link_path)
+        LinkHandler.create_hardlink(@target, link_path)
+      end
+
+      # Serialize for archive storage
+      def serialize
+        {
+          target: @target,
+          inode: @inode,
+        }
+      end
+
+      # Deserialize from archive storage
+      def self.deserialize(data, path: nil)
+        if data.is_a?(Hash)
+          new(
+            target: data[:target] || data["target"],
+            path: path,
+            inode: data[:inode] || data["inode"],
+          )
+        else
+          # Legacy format: just the target path
+          new(target: data, path: path)
+        end
+      end
+
+      # Check if this is a symbolic link
+      def symlink?
+        false
+      end
+
+      # Check if this is a hard link
+      def hardlink?
+        true
+      end
+
+      # Get the link type as string
+      def link_type
+        "hardlink"
+      end
+
+      # Convert to hash representation
+      def to_h
+        {
+          type: :hardlink,
+          target: @target,
+          path: @path,
+          inode: @inode,
+        }
+      end
+
+      # String representation
+      def to_s
+        "#{@path} -> #{@target} (hard link)"
+      end
+
+      # Inspect representation
+      def inspect
+        "#<Omnizip::LinkHandler::HardLink target=#{@target.inspect} " \
+          "path=#{@path.inspect} inode=#{@inode}>"
+      end
+    end
+  end
+end