omnizip 0.3.1

data/lib/omnizip/formats/seven_zip.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "seven_zip/constants"
+require_relative "seven_zip/header"
+require_relative "seven_zip/parser"
+require_relative "seven_zip/reader"
+require_relative "seven_zip/writer"
+require_relative "seven_zip/coder_chain"
+require_relative "seven_zip/stream_decompressor"
+require_relative "seven_zip/stream_compressor"
+require_relative "seven_zip/file_collector"
+require_relative "seven_zip/header_writer"
+require_relative "seven_zip/split_archive_reader"
+require_relative "seven_zip/split_archive_writer"
+require_relative "../models/split_options"
+
+module Omnizip
+  module Formats
+    # .7z archive format support
+    # Provides read and write access to 7-Zip archives
+    #
+    # This module implements the .7z archive format specification,
+    # supporting:
+    # - Format signature and header validation
+    # - Archive structure parsing
+    # - File extraction
+    # - Archive creation
+    # - Split archives (multi-volume)
+    module SevenZip
+      # Create a new .7z archive
+      #
+      # @param path [String] Output path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :volume_size Volume size for split archives
+      # @option options [String] :password Password for header encryption
+      # @option options [Boolean] :encrypt_headers Encrypt archive headers
+      # @yield [writer] Block for adding files
+      # @yieldparam writer [Writer] Archive writer
+      def self.create(path, options = {})
+        writer = Writer.new(path, options)
+        yield writer if block_given?
+        writer.write
+        writer
+      end
+
+      # Create a split .7z archive
+      #
+      # @param path [String] Base path (e.g., "backup.7z.001")
+      # @param split_options [Models::SplitOptions] Split configuration
+      # @param options [Hash] Compression options
+      # @yield [writer] Block for adding files
+      # @yieldparam writer [SplitArchiveWriter] Archive writer
+      def self.create_split(path, split_options, options = {})
+        writer = SplitArchiveWriter.new(path, options, split_options)
+        yield writer if block_given?
+        writer.write
+        writer
+      end
+
+      # Open existing .7z archive
+      #
+      # @param path [String] Archive path
+      # @param options [Hash] Reader options
+      # @option options [String] :password Password for encrypted headers
+      # @yield [reader] Block for reading archive
+      # @yieldparam reader [Reader] Archive reader
+      # @return [Reader] Archive reader
+      def self.open(path, options = {})
+        reader = Reader.new(path, options)
+        reader.open
+
+        if block_given?
+          begin
+            yield reader
+          ensure
+            reader.split_reader&.close if reader.respond_to?(:split_reader)
+          end
+        end
+
+        reader
+      end
+
+      # Auto-register .7z format when loaded
+      def self.register!
+        require_relative "../format_registry"
+        FormatRegistry.register(".7z", Reader)
+      end
+    end
+  end
+end
+
+# Auto-register on load
+Omnizip::Formats::SevenZip.register!

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR format constants
+      module Constants
+        # TAR header size (POSIX ustar format)
+        HEADER_SIZE = 512
+
+        # Block size for TAR archives
+        BLOCK_SIZE = 512
+
+        # Type flags for TAR entries
+        TYPE_REGULAR = "0"        # Regular file
+        TYPE_HARD_LINK = "1"      # Hard link
+        TYPE_SYMLINK = "2"        # Symbolic link
+        TYPE_CHAR_DEVICE = "3"    # Character device
+        TYPE_BLOCK_DEVICE = "4"   # Block device
+        TYPE_DIRECTORY = "5"      # Directory
+        TYPE_FIFO = "6"           # FIFO
+        TYPE_CONTIGUOUS = "7"     # Contiguous file
+        TYPE_EXTENDED = "x"       # Extended header
+        TYPE_GLOBAL_EXTENDED = "g" # Global extended header
+        TYPE_GNU_LONGNAME = "L"   # GNU long name
+        TYPE_GNU_LONGLINK = "K"   # GNU long link
+
+        # POSIX ustar magic value
+        USTAR_MAGIC = "ustar"
+
+        # POSIX ustar version
+        USTAR_VERSION = "00"
+
+        # Maximum file size (8GB - 1 for base-8 12-byte field)
+        MAX_FILE_SIZE = (8**12) - 1
+
+        # Field positions in TAR header
+        NAME_OFFSET = 0
+        NAME_SIZE = 100
+        MODE_OFFSET = 100
+        MODE_SIZE = 8
+        UID_OFFSET = 108
+        UID_SIZE = 8
+        GID_OFFSET = 116
+        GID_SIZE = 8
+        SIZE_OFFSET = 124
+        SIZE_SIZE = 12
+        MTIME_OFFSET = 136
+        MTIME_SIZE = 12
+        CHECKSUM_OFFSET = 148
+        CHECKSUM_SIZE = 8
+        TYPEFLAG_OFFSET = 156
+        TYPEFLAG_SIZE = 1
+        LINKNAME_OFFSET = 157
+        LINKNAME_SIZE = 100
+        MAGIC_OFFSET = 257
+        MAGIC_SIZE = 6
+        VERSION_OFFSET = 263
+        VERSION_SIZE = 2
+        UNAME_OFFSET = 265
+        UNAME_SIZE = 32
+        GNAME_OFFSET = 297
+        GNAME_SIZE = 32
+        DEVMAJOR_OFFSET = 329
+        DEVMAJOR_SIZE = 8
+        DEVMINOR_OFFSET = 337
+        DEVMINOR_SIZE = 8
+        PREFIX_OFFSET = 345
+        PREFIX_SIZE = 155
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR entry model
+      #
+      # Represents a single entry (file, directory, link) in a TAR archive
+      class Entry
+        include Constants
+
+        attr_accessor :name, :mode, :uid, :gid, :size, :mtime, :typeflag,
+                      :linkname, :uname, :gname, :devmajor, :devminor, :prefix
+        attr_reader :data
+
+        # Initialize a new TAR entry
+        #
+        # @param name [String] Entry name/path
+        # @param options [Hash] Entry options
+        def initialize(name, options = {})
+          @name = name
+          @mode = options[:mode] || 0o644
+          @uid = options[:uid] || 0
+          @gid = options[:gid] || 0
+          @size = options[:size] || 0
+          @mtime = options[:mtime] || Time.now
+          @typeflag = options[:typeflag] || TYPE_REGULAR
+          @linkname = options[:linkname] || ""
+          @uname = options[:uname] || ""
+          @gname = options[:gname] || ""
+          @devmajor = options[:devmajor] || 0
+          @devminor = options[:devminor] || 0
+          @prefix = options[:prefix] || ""
+          @data = nil
+        end
+
+        # Set entry data
+        #
+        # @param data [String] Entry data
+        def data=(data)
+          @data = data
+          @size = data.bytesize if data
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean] true if directory
+        def directory?
+          @typeflag == TYPE_DIRECTORY
+        end
+
+        # Check if entry is a file
+        #
+        # @return [Boolean] true if regular file
+        def file?
+          @typeflag == TYPE_REGULAR || @typeflag.nil? || @typeflag.empty?
+        end
+
+        # Check if entry is a symbolic link
+        #
+        # @return [Boolean] true if symbolic link
+        def symlink?
+          @typeflag == TYPE_SYMLINK
+        end
+
+        # Get full entry name (prefix + name)
+        #
+        # @return [String] Full entry name
+        def full_name
+          if @prefix && !@prefix.empty?
+            File.join(@prefix, @name)
+          else
+            @name
+          end
+        end
+
+        # Calculate checksum for TAR header
+        #
+        # @param header [String] TAR header bytes
+        # @return [Integer] Checksum value
+        def self.calculate_checksum(header)
+          # Replace checksum field with spaces for calculation
+          checksum_header = header.dup
+          checksum_header[CHECKSUM_OFFSET, CHECKSUM_SIZE] = " " * CHECKSUM_SIZE
+
+          # Sum all bytes
+          checksum_header.bytes.sum
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "entry"
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR header parser (POSIX ustar format)
+      #
+      # Handles reading and writing 512-byte TAR headers
+      class Header
+        include Constants
+
+        # Parse a TAR header from binary data
+        #
+        # @param header_data [String] 512 bytes of header data
+        # @return [Entry, nil] Parsed entry or nil if end of archive
+        def self.parse(header_data)
+          return nil if header_data.nil? || header_data.bytesize < HEADER_SIZE
+          return nil if all_zeros?(header_data)
+
+          entry = Entry.new("")
+
+          # Extract fields from header
+          entry.name = extract_string(header_data, NAME_OFFSET, NAME_SIZE)
+          entry.mode = extract_octal(header_data, MODE_OFFSET, MODE_SIZE)
+          entry.uid = extract_octal(header_data, UID_OFFSET, UID_SIZE)
+          entry.gid = extract_octal(header_data, GID_OFFSET, GID_SIZE)
+          entry.size = extract_octal(header_data, SIZE_OFFSET, SIZE_SIZE)
+          entry.mtime = Time.at(
+            extract_octal(header_data, MTIME_OFFSET, MTIME_SIZE),
+          )
+          entry.typeflag = header_data[TYPEFLAG_OFFSET]
+          entry.linkname = extract_string(
+            header_data, LINKNAME_OFFSET, LINKNAME_SIZE
+          )
+
+          # Check for ustar format
+          magic = extract_string(header_data, MAGIC_OFFSET, MAGIC_SIZE)
+          if magic == USTAR_MAGIC
+            entry.uname = extract_string(header_data, UNAME_OFFSET, UNAME_SIZE)
+            entry.gname = extract_string(header_data, GNAME_OFFSET, GNAME_SIZE)
+            entry.devmajor = extract_octal(
+              header_data, DEVMAJOR_OFFSET, DEVMAJOR_SIZE
+            )
+            entry.devminor = extract_octal(
+              header_data, DEVMINOR_OFFSET, DEVMINOR_SIZE
+            )
+            entry.prefix = extract_string(
+              header_data, PREFIX_OFFSET, PREFIX_SIZE
+            )
+          end
+
+          # Verify checksum
+          checksum = extract_octal(
+            header_data, CHECKSUM_OFFSET, CHECKSUM_SIZE
+          )
+          calculated = Entry.calculate_checksum(header_data)
+          unless checksum == calculated
+            raise Error, "TAR header checksum mismatch"
+          end
+
+          entry
+        end
+
+        # Build a TAR header from an entry
+        #
+        # @param entry [Entry] Entry to build header for
+        # @return [String] 512 bytes of header data
+        def self.build(entry)
+          header = "\0" * HEADER_SIZE
+
+          # Write fields to header
+          write_string(header, entry.name, NAME_OFFSET, NAME_SIZE)
+          write_octal(header, entry.mode, MODE_OFFSET, MODE_SIZE)
+          write_octal(header, entry.uid, UID_OFFSET, UID_SIZE)
+          write_octal(header, entry.gid, GID_OFFSET, GID_SIZE)
+          write_octal(header, entry.size, SIZE_OFFSET, SIZE_SIZE)
+          write_octal(
+            header, entry.mtime.to_i, MTIME_OFFSET, MTIME_SIZE
+          )
+          header[TYPEFLAG_OFFSET] = entry.typeflag || TYPE_REGULAR
+          write_string(header, entry.linkname, LINKNAME_OFFSET, LINKNAME_SIZE)
+
+          # Write ustar magic and version
+          write_string(header, USTAR_MAGIC, MAGIC_OFFSET, MAGIC_SIZE)
+          write_string(header, USTAR_VERSION, VERSION_OFFSET, VERSION_SIZE)
+          write_string(header, entry.uname, UNAME_OFFSET, UNAME_SIZE)
+          write_string(header, entry.gname, GNAME_OFFSET, GNAME_SIZE)
+          write_octal(header, entry.devmajor, DEVMAJOR_OFFSET, DEVMAJOR_SIZE)
+          write_octal(header, entry.devminor, DEVMINOR_OFFSET, DEVMINOR_SIZE)
+          write_string(header, entry.prefix, PREFIX_OFFSET, PREFIX_SIZE)
+
+          # Calculate and write checksum
+          checksum = Entry.calculate_checksum(header)
+          write_octal(header, checksum, CHECKSUM_OFFSET, CHECKSUM_SIZE)
+
+          header
+        end
+
+        # Check if header data is all zeros (end of archive marker)
+        #
+        # @param data [String] Header data
+        # @return [Boolean] true if all zeros
+        def self.all_zeros?(data)
+          data.bytes.all?(&:zero?)
+        end
+
+        # Extract a null-terminated string from header
+        #
+        # @param header [String] Header data
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        # @return [String] Extracted string
+        def self.extract_string(header, offset, size)
+          field = header[offset, size]
+          return "" if field.nil?
+
+          # Find null terminator
+          null_pos = field.index("\0")
+          null_pos ? field[0...null_pos] : field
+        end
+
+        # Extract an octal number from header
+        #
+        # @param header [String] Header data
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        # @return [Integer] Extracted number
+        def self.extract_octal(header, offset, size)
+          field = extract_string(header, offset, size)
+          field.strip.to_i(8)
+        end
+
+        # Write a string to header
+        #
+        # @param header [String] Header data
+        # @param value [String] Value to write
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        def self.write_string(header, value, offset, size)
+          value = value.to_s
+          # Truncate if too long
+          value = value[0, size - 1] if value.bytesize >= size
+          header[offset, value.bytesize] = value
+        end
+
+        # Write an octal number to header
+        #
+        # @param header [String] Header data
+        # @param value [Integer] Value to write
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        def self.write_octal(header, value, offset, size)
+          # Format as octal with leading zeros
+          octal_str = format("%0#{size - 1}o", value.to_i)
+          # Truncate if too long
+          octal_str = octal_str[(-size + 1)..] if octal_str.bytesize >= size
+          header[offset, octal_str.bytesize] = octal_str
+        end
+
+        private_class_method :extract_string, :extract_octal
+        private_class_method :write_string, :write_octal, :all_zeros?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "header"
+require_relative "entry"
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR archive reader
+      #
+      # Reads and extracts TAR archives
+      class Reader
+        include Constants
+
+        attr_reader :file_path, :entries
+
+        # Initialize TAR reader
+        #
+        # @param file_path [String] Path to TAR archive
+        def initialize(file_path)
+          @file_path = file_path
+          @entries = []
+          @file = nil
+        end
+
+        # Read TAR archive and parse all entries
+        #
+        # @return [self] Returns self for method chaining
+        def read
+          File.open(@file_path, "rb") do |file|
+            @file = file
+            parse_entries
+          end
+          self
+        end
+
+        # Extract all entries to a directory
+        #
+        # @param output_dir [String] Output directory path
+        def extract_all(output_dir)
+          read unless @entries.any?
+
+          FileUtils.mkdir_p(output_dir)
+
+          @entries.each do |entry|
+            extract_entry(entry, output_dir)
+          end
+        end
+
+        # Extract a specific entry
+        #
+        # @param entry [Entry] Entry to extract
+        # @param output_dir [String] Output directory
+        def extract_entry(entry, output_dir)
+          full_path = File.join(output_dir, entry.full_name)
+
+          if entry.directory?
+            FileUtils.mkdir_p(full_path)
+          elsif entry.file?
+            FileUtils.mkdir_p(File.dirname(full_path))
+            File.binwrite(full_path, entry.data)
+            File.chmod(entry.mode, full_path) if entry.mode
+            File.utime(entry.mtime, entry.mtime, full_path) if entry.mtime
+          elsif entry.symlink?
+            FileUtils.mkdir_p(File.dirname(full_path))
+            File.symlink(entry.linkname, full_path)
+          end
+        end
+
+        # List all entries
+        #
+        # @return [Array<Entry>] List of entries
+        def list_entries
+          read unless @entries.any?
+          @entries
+        end
+
+        # Open TAR archive and yield reader
+        #
+        # @param file_path [String] Path to TAR archive
+        # @yield [Reader] Reader instance
+        def self.open(file_path)
+          reader = new(file_path)
+          reader.read
+          yield reader if block_given?
+          reader
+        end
+
+        private
+
+        # Parse all entries from TAR archive
+        def parse_entries
+          @entries = []
+
+          loop do
+            header_data = @file.read(HEADER_SIZE)
+            break if header_data.nil? || header_data.bytesize < HEADER_SIZE
+
+            entry = Header.parse(header_data)
+            break if entry.nil?
+
+            # Read entry data
+            if entry.size.positive?
+              entry.data = @file.read(entry.size)
+
+              # Skip to next block boundary
+              remainder = entry.size % BLOCK_SIZE
+              if remainder.positive?
+                padding = BLOCK_SIZE - remainder
+                @file.read(padding)
+              end
+            end
+
+            @entries << entry
+          end
+        end
+      end
+    end
+  end
+end