omnizip 0.4.7-aarch64-linux

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR archive writer
+      #
+      # Creates TAR archives
+      class Writer
+        include Omnizip::Formats::Tar::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,74 @@
+# frozen_string_literal: true
+
+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
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/formats/tar/constants"
+      autoload :Entry, "omnizip/formats/tar/entry"
+      autoload :Header, "omnizip/formats/tar/header"
+      autoload :Reader, "omnizip/formats/tar/reader"
+      autoload :Writer, "omnizip/formats/tar/writer"
+
+      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-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+        def open(file_path, &block)
+          Reader.open(file_path, &block)
+        end
+
+        # 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-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+        def create(file_path, &block)
+          Writer.create(file_path, &block)
+        end
+
+        # 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
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xar/constants.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Xar
+      # XAR format constants
+      #
+      # XAR (eXtensible ARchive) format is used primarily on macOS
+      # for software distribution (pkg files, etc.)
+      #
+      # Format structure:
+      #   - Header (28 bytes)
+      #   - Compressed TOC (Table of Contents, XML)
+      #   - TOC Checksum
+      #   - Heap (file data)
+      module Constants
+        # XAR magic number: "xar!" in big-endian
+        MAGIC = 0x78617221
+        MAGIC_BYTES = "xar!".b
+
+        # Header size (bytes)
+        HEADER_SIZE = 28
+
+        # Extended header size (with custom checksum name)
+        HEADER_SIZE_EX = 28 + 36
+
+        # Format version
+        XAR_VERSION = 1
+
+        # Checksum algorithms
+        CKSUM_NONE   = 0
+        CKSUM_SHA1   = 1
+        CKSUM_MD5    = 2
+        CKSUM_OTHER  = 3 # Custom checksum (name in header)
+
+        # Checksum names mapping
+        CHECKSUM_NAMES = {
+          CKSUM_NONE => "none",
+          CKSUM_SHA1 => "sha1",
+          CKSUM_MD5 => "md5",
+        }.freeze
+
+        CHECKSUM_ALGORITHMS = {
+          "none" => CKSUM_NONE,
+          "sha1" => CKSUM_SHA1,
+          "md5" => CKSUM_MD5,
+          "sha224" => CKSUM_OTHER,
+          "sha256" => CKSUM_OTHER,
+          "sha384" => CKSUM_OTHER,
+          "sha512" => CKSUM_OTHER,
+        }.freeze
+
+        # Checksum sizes (bytes)
+        CHECKSUM_SIZES = {
+          "md5" => 16,
+          "sha1" => 20,
+          "sha224" => 28,
+          "sha256" => 32,
+          "sha384" => 48,
+          "sha512" => 64,
+        }.freeze
+
+        # Compression types (used in TOC XML)
+        COMPRESSION_NONE   = "none"
+        COMPRESSION_GZIP   = "gzip"
+        COMPRESSION_BZIP2  = "bzip2"
+        COMPRESSION_LZMA   = "lzma"
+        COMPRESSION_XZ     = "xz"
+
+        # Compression MIME types (as appear in TOC)
+        COMPRESSION_MIME_TYPES = {
+          COMPRESSION_NONE => "application/octet-stream",
+          COMPRESSION_GZIP => "application/x-gzip",
+          COMPRESSION_BZIP2 => "application/x-bzip2",
+          COMPRESSION_LZMA => "application/x-lzma",
+          COMPRESSION_XZ => "application/x-xz",
+        }.freeze
+
+        MIME_TYPE_TO_COMPRESSION = {
+          "application/octet-stream" => COMPRESSION_NONE,
+          "application/x-gzip" => COMPRESSION_GZIP,
+          "application/x-bzip2" => COMPRESSION_BZIP2,
+          "application/x-lzma" => COMPRESSION_LZMA,
+          "application/x-xz" => COMPRESSION_XZ,
+        }.freeze
+
+        # File types (in TOC XML)
+        TYPE_FILE      = "file"
+        TYPE_DIRECTORY = "directory"
+        TYPE_SYMLINK   = "symlink"
+        TYPE_HARDLINK  = "hardlink"
+        TYPE_FIFO      = "fifo"
+        TYPE_BLOCK     = "block"
+        TYPE_CHAR      = "character"
+        TYPE_SOCKET    = "socket"
+
+        # Header field offsets
+        HEADER_MAGIC_OFFSET              = 0
+        HEADER_SIZE_OFFSET               = 4
+        HEADER_VERSION_OFFSET            = 6
+        HEADER_TOC_COMPRESSED_OFFSET     = 8
+        HEADER_TOC_UNCOMPRESSED_OFFSET   = 16
+        HEADER_CKSUM_ALG_OFFSET          = 24
+
+        # Default options for XAR archives
+        DEFAULT_COMPRESSION     = COMPRESSION_GZIP
+        DEFAULT_TOC_CHECKSUM    = "sha1"
+        DEFAULT_FILE_CHECKSUM   = "sha1"
+        DEFAULT_COMPRESSION_LEVEL = 6
+
+        # TOC XML namespaces
+        TOC_XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>'
+
+        # Maximum path length
+        MAX_PATH_LENGTH = 1024
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xar/entry.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Xar
+      # XAR file entry model
+      #
+      # Represents a single file/directory/link in a XAR archive.
+      # Each entry has metadata and optional data.
+      class Entry
+        include Omnizip::Entry
+        include Omnizip::Formats::Xar::Constants
+
+        def entry_name = name
+        def entry_directory? = type == :directory
+        def entry_size = size
+        def entry_mtime = mtime
+
+        attr_accessor :id, :name, :type, :mode, :uid, :gid, :user, :group,
+                      :size, :ctime, :mtime, :atime,
+                      :data_offset, :data_length, :data_size, :data_encoding,
+                      :archived_checksum, :archived_checksum_style,
+                      :extracted_checksum, :extracted_checksum_style,
+                      :link_type, :link_target,
+                      :device_major, :device_minor,
+                      :ino, :nlink, :flags, :ea
+
+        attr_reader :data
+
+        # Extended attributes structure
+        class ExtendedAttribute
+          include Omnizip::Formats::Xar::Constants
+
+          attr_accessor :id, :name, :fstype, :data_offset, :data_length,
+                        :data_size, :data_encoding, :archived_checksum,
+                        :extracted_checksum
+
+          def initialize(name: nil)
+            @name = name
+            @data_offset = 0
+            @data_length = 0
+            @data_size = 0
+            @data_encoding = COMPRESSION_NONE
+          end
+        end
+
+        # Initialize entry
+        #
+        # @param name [String] Entry name/path
+        # @param options [Hash] Entry options
+        def initialize(name, options = {})
+          @id = options[:id]
+          @name = name
+          @type = options[:type] || TYPE_FILE
+          @mode = options[:mode] || 0o644
+          @uid = options[:uid] || 0
+          @gid = options[:gid] || 0
+          @user = options[:user] || ""
+          @group = options[:group] || ""
+          @size = options[:size] || 0
+          @ctime = options[:ctime]
+          @mtime = options[:mtime]
+          @atime = options[:atime]
+
+          # Data properties
+          @data_offset = options[:data_offset] || 0
+          @data_length = options[:data_length] || 0
+          @data_size = options[:data_size] || 0
+          @data_encoding = options[:data_encoding] || COMPRESSION_NONE
+
+          # Checksums
+          @archived_checksum = options[:archived_checksum]
+          @archived_checksum_style = options[:archived_checksum_style]
+          @extracted_checksum = options[:extracted_checksum]
+          @extracted_checksum_style = options[:extracted_checksum_style]
+
+          # Links
+          @link_type = options[:link_type]
+          @link_target = options[:link_target]
+
+          # Devices
+          @device_major = options[:device_major]
+          @device_minor = options[:device_minor]
+
+          # Other metadata
+          @ino = options[:ino]
+          @nlink = options[:nlink] || 1
+          @flags = options[:flags]
+          @ea = options[:ea] || [] # Extended attributes
+
+          @data = nil
+        end
+
+        # Set entry data
+        #
+        # @param data [String] Entry data
+        def data=(data)
+          @data = data
+          @data_size = data&.bytesize || 0
+          @size = @data_size
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean] true if directory
+        def directory?
+          @type == TYPE_DIRECTORY
+        end
+
+        # Check if entry is a regular file
+        #
+        # @return [Boolean] true if regular file
+        def file?
+          @type == TYPE_FILE
+        end
+
+        # Check if entry is a symbolic link
+        #
+        # @return [Boolean] true if symbolic link
+        def symlink?
+          @type == TYPE_SYMLINK
+        end
+
+        # Check if entry is a hard link
+        #
+        # @return [Boolean] true if hard link
+        def hardlink?
+          @type == TYPE_HARDLINK
+        end
+
+        # Check if entry is a device
+        #
+        # @return [Boolean] true if block or character device
+        def device?
+          @type == TYPE_BLOCK || @type == TYPE_CHAR
+        end
+
+        # Check if entry is a FIFO
+        #
+        # @return [Boolean] true if FIFO
+        def fifo?
+          @type == TYPE_FIFO
+        end
+
+        # Check if entry is a socket
+        #
+        # @return [Boolean] true if socket
+        def socket?
+          @type == TYPE_SOCKET
+        end
+
+        # Get file type from mode
+        #
+        # @return [String] XAR type string
+        def self.type_from_mode(mode)
+          case mode & 0o170000
+          when 0o040000 then TYPE_DIRECTORY
+          when 0o100000 then TYPE_FILE
+          when 0o120000 then TYPE_SYMLINK
+          when 0o060000 then TYPE_BLOCK
+          when 0o020000 then TYPE_CHAR
+          when 0o010000 then TYPE_FIFO
+          when 0o140000 then TYPE_SOCKET
+          else TYPE_FILE
+          end
+        end
+
+        # Convert entry to hash for TOC generation
+        #
+        # @return [Hash] Entry as hash
+        def to_h
+          hash = {
+            id: @id,
+            name: @name,
+            type: @type,
+          }
+
+          hash[:mode] = format("0%03o", @mode) if @mode
+          hash[:uid] = @uid if @uid
+          hash[:gid] = @gid if @gid
+          hash[:user] = @user unless @user.to_s.empty?
+          hash[:group] = @group unless @group.to_s.empty?
+          hash[:size] = @size if @size&.positive?
+
+          # Timestamps
+          hash[:ctime] = format_timestamp(@ctime) if @ctime
+          hash[:mtime] = format_timestamp(@mtime) if @mtime
+          hash[:atime] = format_timestamp(@atime) if @atime
+
+          # Data section
+          if @data_size&.positive? || file?
+            data_hash = {}
+            data_hash[:offset] = @data_offset
+            data_hash[:size] = @data_length if @data_length&.positive?
+            data_hash[:length] = @data_size if @data_size&.positive?
+
+            if @data_encoding && @data_encoding != COMPRESSION_NONE
+              data_hash[:encoding] =
+                COMPRESSION_MIME_TYPES[@data_encoding] || @data_encoding
+            end
+
+            if @archived_checksum
+              data_hash[:archived_checksum] =
+                @archived_checksum
+            end
+            if @archived_checksum_style
+              data_hash[:archived_checksum_style] =
+                @archived_checksum_style
+            end
+            if @extracted_checksum
+              data_hash[:extracted_checksum] =
+                @extracted_checksum
+            end
+            if @extracted_checksum_style
+              data_hash[:extracted_checksum_style] =
+                @extracted_checksum_style
+            end
+
+            hash[:data] = data_hash
+          end
+
+          # Links
+          if @link_target
+            hash[:link] = { type: @link_type, target: @link_target }
+          end
+
+          # Devices
+          if device?
+            device_hash = {}
+            device_hash[:major] = @device_major if @device_major
+            device_hash[:minor] = @device_minor if @device_minor
+            hash[:device] = device_hash
+          end
+
+          # Extended attributes
+          if @ea&.any?
+            hash[:ea] = @ea.map do |attr|
+              ea_hash = { name: attr.name }
+              ea_hash[:offset] = attr.data_offset
+              ea_hash[:size] = attr.data_length
+              ea_hash[:length] = attr.data_size
+              ea_hash
+            end
+          end
+
+          hash
+        end
+
+        private
+
+        # Format timestamp for TOC
+        #
+        # @param time [Time] Time object
+        # @return [String] Formatted timestamp
+        def format_timestamp(time)
+          case time
+          when Time
+            time.to_f.to_s
+          when Numeric
+            time.to_s
+          else
+            time.to_s
+          end
+        end
+      end
+    end
+  end
+end