omnizip 0.3.1

data/lib/omnizip/io/buffered_input.rb

@@ -0,0 +1,146 @@
+# 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
+        @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,105 @@
+# 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
+        @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/stream_manager.rb

@@ -0,0 +1,115 @@
+# 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 && @source.respond_to?(:close)
+      end
+
+      # Check if source is at end.
+      #
+      # @return [Boolean] True if at EOF
+      def 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)
+        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/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

data/lib/omnizip/link_handler/symbolic_link.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module LinkHandler
+    # Model for symbolic links
+    class SymbolicLink
+      attr_reader :target, :path
+
+      # Unix permissions for symbolic links (0120777)
+      SYMLINK_PERMISSIONS = 0o120777
+
+      def initialize(target:, path: nil)
+        @target = target
+        @path = path
+      end
+
+      # Create the symbolic link on the filesystem
+      def create(link_path)
+        LinkHandler.create_symlink(@target, link_path)
+      end
+
+      # Get Unix permissions for symbolic links
+      def permissions
+        SYMLINK_PERMISSIONS
+      end
+
+      # Serialize for archive storage (returns the target path)
+      def serialize
+        @target
+      end
+
+      # Deserialize from archive storage
+      def self.deserialize(target_data, path: nil)
+        new(target: target_data, path: path)
+      end
+
+      # Check if this is a symbolic link
+      def symlink?
+        true
+      end
+
+      # Check if this is a hard link
+      def hardlink?
+        false
+      end
+
+      # Get the link type as string
+      def link_type
+        "symlink"
+      end
+
+      # Convert to hash representation
+      def to_h
+        {
+          type: :symlink,
+          target: @target,
+          path: @path,
+          permissions: permissions,
+        }
+      end
+
+      # String representation
+      def to_s
+        "#{@path} -> #{@target} (symlink)"
+      end
+
+      # Inspect representation
+      def inspect
+        "#<Omnizip::LinkHandler::SymbolicLink target=#{@target.inspect} " \
+          "path=#{@path.inspect}>"
+      end
+    end
+  end
+end

data/lib/omnizip/link_handler.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "link_handler/symbolic_link"
+require_relative "link_handler/hard_link"
+
+module Omnizip
+  # Handles symbolic and hard link operations with platform detection
+  module LinkHandler
+    class << self
+      # Check if the platform supports symbolic links
+      def supported?
+        !windows_platform?
+      end
+
+      # Check if symbolic links are supported
+      def symlink_supported?
+        File.respond_to?(:symlink) && supported?
+      end
+
+      # Check if hard links are supported
+      def hardlink_supported?
+        File.respond_to?(:link) && supported?
+      end
+
+      # Detect if a path is a symbolic link
+      def symlink?(path)
+        return false unless symlink_supported?
+
+        File.symlink?(path)
+      rescue StandardError
+        false
+      end
+
+      # Detect if a path is a hard link
+      def hardlink?(path)
+        return false unless hardlink_supported?
+        return false unless File.exist?(path)
+        return false if File.directory?(path)
+
+        stat = File.stat(path)
+        stat.nlink > 1
+      rescue StandardError
+        false
+      end
+
+      # Detect the type of link (or nil if not a link)
+      def detect_link(path)
+        return nil unless supported?
+        return :symlink if symlink?(path)
+        return :hardlink if hardlink?(path)
+
+        nil
+      end
+
+      # Create a symbolic link
+      def create_symlink(target, link_path)
+        unless symlink_supported?
+          raise Omnizip::Error,
+                "Symbolic links are not supported on #{RUBY_PLATFORM}"
+        end
+
+        FileUtils.mkdir_p(File.dirname(link_path))
+        File.symlink(target, link_path)
+      end
+
+      # Create a hard link
+      def create_hardlink(target, link_path)
+        unless hardlink_supported?
+          raise Omnizip::Error,
+                "Hard links are not supported on #{RUBY_PLATFORM}"
+        end
+
+        FileUtils.mkdir_p(File.dirname(link_path))
+        File.link(target, link_path)
+      end
+
+      # Read the target of a symbolic link
+      def read_link_target(link_path)
+        unless symlink_supported?
+          raise Omnizip::Error,
+                "Symbolic links are not supported on #{RUBY_PLATFORM}"
+        end
+
+        File.readlink(link_path)
+      end
+
+      # Get inode number for hard link tracking
+      def inode_number(path)
+        return nil unless hardlink_supported?
+        return nil unless File.exist?(path)
+
+        File.stat(path).ino
+      rescue StandardError
+        nil
+      end
+
+      # Create a SymbolicLink instance from a filesystem path
+      def symbolic_link_from_path(path)
+        return nil unless symlink?(path)
+
+        target = read_link_target(path)
+        SymbolicLink.new(target: target, path: path)
+      end
+
+      # Create a HardLink instance from a filesystem path
+      def hard_link_from_path(path, original_path)
+        return nil unless hardlink?(path)
+
+        HardLink.new(
+          target: original_path,
+          path: path,
+          inode: inode_number(path),
+        )
+      end
+
+      private
+
+      # Check if running on Windows platform
+      def windows_platform?
+        RUBY_PLATFORM.match?(/mswin|mingw|cygwin/)
+      end
+    end
+  end
+end