omnizip 0.3.1

data/lib/omnizip/formats/tar/writer.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "header"
+require_relative "entry"
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR archive writer
+      #
+      # Creates TAR archives
+      class Writer
+        include Constants
+
+        attr_reader :file_path
+
+        # Initialize TAR writer
+        #
+        # @param file_path [String] Path to output TAR archive
+        def initialize(file_path)
+          @file_path = file_path
+          @file = nil
+          @closed = false
+        end
+
+        # Add a file to the TAR archive
+        #
+        # @param entry_name [String] Name/path in archive
+        # @param source_path [String] Source file path
+        # @param options [Hash] Entry options
+        def add(entry_name, source_path = nil, options = {})
+          source_path ||= entry_name
+
+          unless File.exist?(source_path)
+            raise ArgumentError, "File not found: #{source_path}"
+          end
+
+          open_file unless @file
+
+          if File.directory?(source_path)
+            add_directory(entry_name, source_path, options)
+          elsif File.symlink?(source_path)
+            add_symlink(entry_name, source_path, options)
+          else
+            add_file(entry_name, source_path, options)
+          end
+        end
+
+        # Add a file entry
+        #
+        # @param entry_name [String] Name in archive
+        # @param source_path [String] Source file path
+        # @param options [Hash] Entry options
+        def add_file(entry_name, source_path, options = {})
+          open_file unless @file
+
+          stat = File.stat(source_path)
+          data = File.binread(source_path)
+
+          entry = Entry.new(entry_name, {
+                              mode: options[:mode] || (stat.mode & 0o777),
+                              uid: options[:uid] || stat.uid,
+                              gid: options[:gid] || stat.gid,
+                              size: data.bytesize,
+                              mtime: options[:mtime] || stat.mtime,
+                              typeflag: TYPE_REGULAR,
+                              uname: options[:uname] || "",
+                              gname: options[:gname] || "",
+                            })
+
+          write_entry(entry, data)
+        end
+
+        # Add a directory entry
+        #
+        # @param entry_name [String] Directory name in archive
+        # @param source_path [String] Source directory path (optional)
+        # @param options [Hash] Entry options
+        def add_directory(entry_name, source_path = nil, options = {})
+          open_file unless @file
+
+          # Ensure directory name ends with /
+          entry_name = "#{entry_name}/" unless entry_name.end_with?("/")
+
+          if source_path && File.exist?(source_path)
+            stat = File.stat(source_path)
+            mode = stat.mode & 0o777
+            uid = stat.uid
+            gid = stat.gid
+            mtime = stat.mtime
+          else
+            mode = 0o755
+            uid = 0
+            gid = 0
+            mtime = Time.now
+          end
+
+          entry = Entry.new(entry_name, {
+                              mode: options[:mode] || mode,
+                              uid: options[:uid] || uid,
+                              gid: options[:gid] || gid,
+                              size: 0,
+                              mtime: options[:mtime] || mtime,
+                              typeflag: TYPE_DIRECTORY,
+                              uname: options[:uname] || "",
+                              gname: options[:gname] || "",
+                            })
+
+          write_entry(entry, nil)
+        end
+
+        # Add a symbolic link entry
+        #
+        # @param entry_name [String] Link name in archive
+        # @param source_path [String] Source symlink path
+        # @param options [Hash] Entry options
+        def add_symlink(entry_name, source_path, options = {})
+          open_file unless @file
+
+          linkname = File.readlink(source_path)
+          stat = File.lstat(source_path)
+
+          entry = Entry.new(entry_name, {
+                              mode: options[:mode] || 0o777,
+                              uid: options[:uid] || stat.uid,
+                              gid: options[:gid] || stat.gid,
+                              size: 0,
+                              mtime: options[:mtime] || stat.mtime,
+                              typeflag: TYPE_SYMLINK,
+                              linkname: linkname,
+                              uname: options[:uname] || "",
+                              gname: options[:gname] || "",
+                            })
+
+          write_entry(entry, nil)
+        end
+
+        # Add raw entry data
+        #
+        # @param entry_name [String] Entry name
+        # @param data [String] Entry data
+        # @param options [Hash] Entry options
+        def add_data(entry_name, data, options = {})
+          open_file unless @file
+
+          entry = Entry.new(entry_name, {
+                              mode: options[:mode] || 0o644,
+                              uid: options[:uid] || 0,
+                              gid: options[:gid] || 0,
+                              size: data.bytesize,
+                              mtime: options[:mtime] || Time.now,
+                              typeflag: TYPE_REGULAR,
+                              uname: options[:uname] || "",
+                              gname: options[:gname] || "",
+                            })
+
+          write_entry(entry, data)
+        end
+
+        # Close the TAR archive
+        def close
+          return if @closed
+
+          if @file
+            # Write two zero blocks to mark end of archive
+            @file.write("\0" * BLOCK_SIZE * 2)
+            @file.close
+          end
+
+          @closed = true
+        end
+
+        # Create TAR archive with block syntax
+        #
+        # @param file_path [String] Path to output TAR archive
+        # @yield [Writer] Writer instance
+        def self.create(file_path)
+          writer = new(file_path)
+          yield writer if block_given?
+          writer.close
+          writer
+        end
+
+        private
+
+        # Open output file
+        def open_file
+          @file = File.open(@file_path, "wb")
+        end
+
+        # Write an entry to the archive
+        #
+        # @param entry [Entry] Entry to write
+        # @param data [String, nil] Entry data
+        def write_entry(entry, data)
+          # Write header
+          header = Header.build(entry)
+          @file.write(header)
+
+          # Write data if present
+          if data && !data.empty?
+            @file.write(data)
+
+            # Pad to block boundary
+            remainder = data.bytesize % BLOCK_SIZE
+            if remainder.positive?
+              padding = BLOCK_SIZE - remainder
+              @file.write("\0" * padding)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/tar.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "tar/constants"
+require_relative "tar/entry"
+require_relative "tar/header"
+require_relative "tar/reader"
+require_relative "tar/writer"
+
+module Omnizip
+  module Formats
+    # TAR archive format implementation
+    #
+    # TAR (Tape Archive) is a simple archive format that bundles files
+    # without compression. It's commonly used in combination with
+    # compression formats like GZIP (.tar.gz) or BZIP2 (.tar.bz2).
+    #
+    # This implementation supports POSIX ustar format with:
+    # - Regular files
+    # - Directories
+    # - Symbolic links
+    # - Hard links
+    # - Metadata preservation (permissions, timestamps, ownership)
+    module Tar
+      class << self
+        # Read a TAR archive
+        #
+        # @param file_path [String] Path to TAR archive
+        # @return [Reader] TAR reader instance
+        def read(file_path)
+          Reader.new(file_path).read
+        end
+
+        # Open a TAR archive with block syntax
+        #
+        # @param file_path [String] Path to TAR archive
+        # @yield [Reader] TAR reader instance
+        # @return [Reader] TAR reader instance
+        # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+        def open(file_path, &block)
+          Reader.open(file_path, &block)
+        end
+        # rubocop:enable Naming/BlockForwarding, Style/ArgumentsForwarding
+
+        # Create a TAR archive
+        #
+        # @param file_path [String] Path to output TAR archive
+        # @yield [Writer] TAR writer instance
+        # @return [Writer] TAR writer instance
+        # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+        def create(file_path, &block)
+          Writer.create(file_path, &block)
+        end
+        # rubocop:enable Naming/BlockForwarding, Style/ArgumentsForwarding
+
+        # Extract a TAR archive
+        #
+        # @param file_path [String] Path to TAR archive
+        # @param output_dir [String] Output directory
+        def extract(file_path, output_dir)
+          reader = read(file_path)
+          reader.extract_all(output_dir)
+        end
+
+        # List entries in a TAR archive
+        #
+        # @param file_path [String] Path to TAR archive
+        # @return [Array<Entry>] List of entries
+        def list(file_path)
+          reader = read(file_path)
+          reader.list_entries
+        end
+
+        # Register TAR format when loaded
+        def register!
+          require_relative "../format_registry"
+          FormatRegistry.register(".tar", Omnizip::Formats::Tar)
+        end
+      end
+    end
+  end
+end
+
+# Auto-register on load
+Omnizip::Formats::Tar.register!

data/lib/omnizip/formats/xz/reader.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require "stringio"
+require_relative "../xz_impl/stream_decoder"
+
+module Omnizip
+  module Formats
+    class Xz
+      # XZ format reader
+      #
+      # Reads and decompresses .xz files compatible with XZ Utils.
+      # Provides both low-level stream API and high-level convenience methods.
+      class Reader
+        # Initialize reader
+        #
+        # @param input [String, IO] File path or IO object
+        def initialize(input)
+          @input = if input.is_a?(String)
+                     File.open(input, "rb")
+                   elsif input.respond_to?(:read)
+                     input
+                   else
+                     raise ArgumentError,
+                           "Input must be a file path or IO object"
+                   end
+          @close_on_finish = input.is_a?(String)
+        end
+
+        # Read and decompress XZ data
+        #
+        # @return [String] Decompressed data
+        def read
+          XzFormat::StreamDecoder.decode(@input)
+        ensure
+          close if @close_on_finish
+        end
+
+        # Close the input stream if we opened it
+        def close
+          @input.close if @input.respond_to?(:close) && !@input.closed?
+        end
+
+        # Check if reader is open
+        #
+        # @return [Boolean] True if input is open
+        def closed?
+          @input.respond_to?(:closed?) ? @input.closed? : false
+        end
+
+        # Read in a streaming fashion (for large files)
+        #
+        # @yield [String] Chunks of decompressed data
+        # @return [String] Full decompressed data
+        def each_chunk(chunk_size = 64 * 1024)
+          # For now, just read everything and yield chunks
+          # TODO: Implement true streaming for memory efficiency
+          data = read
+          offset = 0
+          while offset < data.bytesize
+            chunk = data.byteslice(offset, chunk_size)
+            yield chunk
+            offset += chunk.bytesize
+          end
+          data
+        end
+      end
+
+      # Entry class for extract API compatibility
+      # XZ format is a single stream, so this is a simple wrapper
+      class Entry
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        # Read the decompressed data
+        #
+        # @return [String] Decompressed data
+        def read
+          @data
+        end
+
+        # Get data size
+        #
+        # @return [Integer] Size in bytes
+        def size
+          @data.bytesize
+        end
+
+        # Alias for compatibility
+        alias_method :bytesize, :size
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative "xz_impl/constants"
+require_relative "xz_impl/stream_encoder"
+require_relative "xz_impl/writer"
+require_relative "xz/reader"
+require_relative "../algorithms/lzma"
+
+module Omnizip
+  module Formats
+    # XZ compression format
+    # Creates .xz files compatible with XZ Utils
+    class Xz
+      class << self
+        # Create a .xz file from input data
+        # @param input [String, IO] Input data to compress
+        # @param output [String, IO] Output file path or IO object
+        # @param options [Hash] Compression options
+        # @option options [Integer] :dict_size Dictionary size (default: 8MB to match XZ Utils preset 6)
+        # @option options [Integer] :check Check type (default: CRC64)
+        def create(input, output = nil, options = {})
+          encoder = XzFormat::StreamEncoder.new(
+            check_type: options[:check] || XzConst::CHECK_CRC64,
+            dict_size: options[:dict_size] || (64 * 1024 * 1024),
+          )
+
+          compressed = encoder.encode(input)
+
+          if output
+            if output.respond_to?(:write)
+              output.write(compressed)
+            else
+              File.binwrite(output, compressed)
+            end
+          else
+            compressed
+          end
+        end
+
+        # Convenience method with block syntax
+        # @example
+        #   Xz.create_file('output.xz') do |xz|
+        #     xz.add_data('Hello, XZ!')
+        #   end
+        def create_file(path, options = {})
+          builder = Builder.new(options)
+          yield builder if block_given?
+
+          compressed = create(builder.data, nil, options)
+          File.binwrite(path, compressed)
+        end
+
+        # Decode XZ data (alias for decompress with no output)
+        # @param input [String, IO] Input XZ data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Decompress XZ, LZIP (.lz), or LZMA_Alone (.lzma) data
+        #
+        # This method automatically detects the format based on magic bytes and
+        # routes to the appropriate decoder:
+        # - XZ format (.xz): Container format with stream header/footer/index
+        # - LZIP format (.lz): Standalone format with "LZIP" magic and CRC32 footer
+        # - LZMA_Alone format (.lzma): Legacy standalone format with properties byte
+        #
+        # @param input [String, IO] Input data or file path
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options (reserved for future use)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, _options = {})
+          # Handle raw data string vs file path
+          data = if input.respond_to?(:read)
+                   # Already an IO object - read content
+                   if input.respond_to?(:size)
+                     # Seekable IO (File, etc.) - read without consuming
+                     original_pos = input.pos
+                     content = input.read
+                     input.seek(original_pos)
+                   else
+                     # Non-seekable IO - read and consume
+                     content = input.read
+                   end
+                   content
+                 elsif input.is_a?(String)
+                   # Could be file path or raw data
+                   # If string contains null byte, it's definitely data (not a path)
+                   # Also check if it's a valid file path first
+                   if !input.include?("\0") && File.exist?(input)
+                     File.binread(input)
+                   else
+                     input.b
+                   end
+                 else
+                   raise ArgumentError,
+                         "Input must be a String or IO object"
+                 end
+
+          # Detect format and decode
+          decompressed = decode_lzma_data(data)
+
+          if output
+            if output.respond_to?(:write)
+              output.write(decompressed)
+            else
+              File.binwrite(output, decompressed)
+            end
+            nil
+          else
+            decompressed
+          end
+        end
+
+        private
+
+        # Decode LZMA-based data by detecting format
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzma_data(data)
+          format = detect_lzma_format(data)
+
+          case format
+          when :lz
+            decode_lzip(data)
+          when :lzma_alone
+            decode_lzma_alone(data)
+          when :xz
+            decode_xz_stream(data)
+          else
+            raise FormatError, "Unknown LZMA format: cannot detect valid format"
+          end
+        end
+
+        # Detect LZMA format from magic bytes
+        # @param data [String] Input data
+        # @return [Symbol] Format type (:xz, :lz, :lzma_alone)
+        def detect_lzma_format(data)
+          return :unknown if data.nil? || data.bytesize < 4
+
+          first_bytes = data.byteslice(0, 6).bytes.to_a
+
+          # Check XZ magic: FD 37 7A 58 5A 00
+          # Reference: xz-file-format-1.2.1.txt Section 2.1.1.1
+          if first_bytes[0] == 0xFD && first_bytes[1] == 0x37 &&
+              first_bytes[2] == 0x7A && first_bytes[3] == 0x58 &&
+              first_bytes[4] == 0x5A && first_bytes[5].zero?
+            return :xz
+          end
+
+          # Check LZIP magic: 4C 5A 49 50 ("LZIP")
+          # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/lzip_decoder.c:106
+          if first_bytes[0] == 0x4C && first_bytes[1] == 0x5A &&
+              first_bytes[2] == 0x49 && first_bytes[3] == 0x50
+            return :lz
+          end
+
+          # Default to LZMA_Alone (legacy format, no magic bytes)
+          # The format starts with properties byte, dictionary size, and uncompressed size
+          # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/alone_decoder.c
+          :lzma_alone
+        end
+
+        # Decode LZIP format (.lz files)
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzip(data)
+          input = StringIO.new(data)
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(input)
+          decoder.decode_stream
+        rescue StandardError => e
+          raise FormatError, "Failed to decode LZIP format: #{e.message}"
+        end
+
+        # Decode LZMA_Alone format (.lzma files)
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzma_alone(data)
+          input = StringIO.new(data)
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(input)
+          decoder.decode_stream
+        rescue StandardError => e
+          raise FormatError, "Failed to decode LZMA_Alone format: #{e.message}"
+        end
+
+        # Decode XZ format stream
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_xz_stream(data)
+          input_io = StringIO.new(data.b)
+          reader = Reader.new(input_io)
+          reader.read
+        rescue StandardError => e
+          raise FormatError, "Failed to decode XZ format: #{e.message}"
+        end
+
+        # Alias for compatibility
+        alias decode decompress
+        alias extract decompress
+
+        # Entry method for archive-like interface
+        # @param input [String, IO] Input XZ data or file path
+        # @param options [Hash] Options (reserved)
+        # @yield [Entry] Yields entry (XZ has single data stream)
+        # @return [String, Entry] Decompressed data or Entry if no block given
+        def extract_entry(input, options = {})
+          data = decompress(input, nil, options)
+
+          entry = Entry.new(data)
+          if block_given?
+            yield entry
+          else
+            entry
+          end
+        end
+      end
+
+      # Builder class for convenient file creation
+      class Builder
+        attr_reader :data
+
+        def initialize(_options = {})
+          @data = String.new(encoding: Encoding::BINARY)
+        end
+
+        def add_data(content)
+          @data << content.to_s.dup.force_encoding(Encoding::BINARY)
+        end
+
+        def add_file(path)
+          content = File.binread(path)
+          add_data(content)
+        end
+      end
+    end
+  end
+end