omnizip 0.4.7-arm-linux

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,129 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  # Handles symbolic and hard link operations with platform detection
+  module LinkHandler
+    autoload :SymbolicLink, "omnizip/link_handler/symbolic_link"
+    autoload :HardLink, "omnizip/link_handler/hard_link"
+    class << self
+      # Check if the platform supports symbolic links
+      def supported?
+        !windows_platform?
+      end
+
+      # Check if symbolic links are supported on this platform.
+      # Delegates to Platform but also gates on LinkHandler#supported?
+      # (Windows is treated as unsupported here for historical
+      # compatibility — even if Windows Developer Mode would allow
+      # symlinks, callers should opt into that explicitly via Platform).
+      def symlink_supported?
+        supported? && Omnizip::Platform.supports_symlinks?
+      end
+
+      # Check if hard links are supported
+      def hardlink_supported?
+        supported? && Omnizip::Platform.supports_hardlinks?
+      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

data/lib/omnizip/metadata/archive_metadata.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Metadata
+    # Model for archive-level metadata
+    class ArchiveMetadata
+      attr_reader :archive
+
+      # Initialize archive metadata
+      # @param archive [Omnizip::Zip::File] The archive to manage metadata for
+      def initialize(archive)
+        @archive = archive
+        @modified = false
+      end
+
+      # Get archive comment
+      # @return [String] Archive comment
+      def comment
+        archive.comment
+      end
+
+      # Set archive comment
+      # @param value [String] New comment
+      def comment=(value)
+        archive.comment = value.to_s
+        @modified = true
+      end
+
+      # Get creation date (approximated from first entry)
+      # @return [Time, nil] Creation date or nil
+      def created_at
+        return nil if archive.entries.empty?
+
+        archive.entries.map(&:time).min
+      end
+
+      # Get modification date (from newest entry)
+      # @return [Time, nil] Modification date or nil
+      def modified_at
+        return nil if archive.entries.empty?
+
+        archive.entries.map(&:time).max
+      end
+
+      # Get total uncompressed size
+      # @return [Integer] Total uncompressed size in bytes
+      def total_size
+        archive.entries.sum(&:size)
+      end
+
+      # Get total compressed size
+      # @return [Integer] Total compressed size in bytes
+      def total_compressed_size
+        archive.entries.sum(&:compressed_size)
+      end
+
+      # Get compression ratio
+      # @return [Float] Compression ratio (0.0 to 1.0)
+      def compression_ratio
+        return 0.0 if total_size.zero?
+
+        ratio = 1.0 - (total_compressed_size.to_f / total_size)
+        # Clamp ratio between 0.0 and 1.0 (compressed size can exceed
+        # original size for small files or incompressible data)
+        [[ratio, 0.0].max, 1.0].min
+      end
+
+      # Get entry count
+      # @return [Integer] Number of entries
+      def entry_count
+        archive.entries.size
+      end
+
+      # Get file count (excluding directories)
+      # @return [Integer] Number of files
+      def file_count
+        archive.entries.count(&:file?)
+      end
+
+      # Get directory count
+      # @return [Integer] Number of directories
+      def directory_count
+        archive.entries.count(&:directory?)
+      end
+
+      # Check if metadata has been modified
+      # @return [Boolean] True if modified
+      def modified?
+        @modified
+      end
+
+      # Reset modified flag
+      def reset_modified
+        @modified = false
+      end
+
+      # Get all metadata as a hash
+      # @return [Hash] Metadata hash
+      def to_h
+        {
+          comment: comment,
+          created_at: created_at,
+          modified_at: modified_at,
+          total_size: total_size,
+          total_compressed_size: total_compressed_size,
+          compression_ratio: compression_ratio,
+          entry_count: entry_count,
+          file_count: file_count,
+          directory_count: directory_count,
+        }
+      end
+    end
+  end
+end

data/lib/omnizip/metadata/entry_metadata.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Metadata
+    # Model for file entry metadata
+    # Wraps CentralDirectoryHeader with a cleaner metadata API
+    class EntryMetadata
+      include Omnizip::Entry
+
+      attr_reader :entry
+
+      def entry_name = entry.name
+      def entry_directory? = entry.directory?
+      def entry_size = entry.size
+      def entry_mtime = entry.time
+
+      # Initialize metadata for an entry
+      # @param entry [Omnizip::Zip::Entry] The entry to manage metadata for
+      def initialize(entry)
+        @entry = entry
+        @modified = false
+      end
+
+      # Get entry comment
+      # @return [String] Entry comment
+      def comment
+        entry.comment
+      end
+
+      # Set entry comment
+      # @param value [String] New comment
+      def comment=(value)
+        entry.comment = value.to_s
+        @modified = true
+      end
+
+      # Get modification time
+      # @return [Time] Modification time
+      def mtime
+        entry.time
+      end
+
+      # Set modification time
+      # @param value [Time] New modification time
+      def mtime=(value)
+        unless value.is_a?(Time)
+          raise ArgumentError,
+                "mtime must be a Time object"
+        end
+
+        entry.header.last_mod_time = dos_time(value)
+        entry.header.last_mod_date = dos_date(value)
+        @modified = true
+      end
+
+      # Get Unix permissions
+      # @return [Integer] Unix permissions (e.g., 0644)
+      def unix_permissions
+        entry.unix_perms
+      end
+
+      # Set Unix permissions
+      # @param perms [Integer] Unix permissions (e.g., 0644, 0755)
+      def unix_permissions=(perms)
+        unless perms.is_a?(Integer)
+          raise ArgumentError,
+                "permissions must be an integer"
+        end
+        unless (0..0o777).cover?(perms)
+          raise ArgumentError,
+                "permissions out of range"
+        end
+
+        entry.unix_perms = perms
+        @modified = true
+      end
+
+      # Get external attributes
+      # @return [Integer] External attributes
+      def attributes
+        entry.header.external_attributes
+      end
+
+      # Set external attributes
+      # @param value [Integer, Symbol] External attributes or symbol like :readonly
+      def attributes=(value)
+        case value
+        when Integer
+          entry.header.external_attributes = value
+        when Symbol
+          set_attribute_flag(value)
+        else
+          raise ArgumentError, "attributes must be Integer or Symbol"
+        end
+        @modified = true
+      end
+
+      # Check if metadata has been modified
+      # @return [Boolean] True if modified
+      def modified?
+        @modified
+      end
+
+      # Reset modified flag
+      def reset_modified
+        @modified = false
+      end
+
+      # Get all metadata as a hash
+      # @return [Hash] Metadata hash
+      def to_h
+        {
+          name: entry.name,
+          comment: comment,
+          mtime: mtime,
+          unix_permissions: unix_permissions,
+          size: entry.size,
+          compressed_size: entry.compressed_size,
+          crc: entry.crc,
+          directory: entry.directory?,
+        }
+      end
+
+      private
+
+      # Set attribute flag
+      def set_attribute_flag(flag)
+        case flag
+        when :readonly
+          entry.header.external_attributes |= 0x01
+        when :hidden
+          entry.header.external_attributes |= 0x02
+        when :system
+          entry.header.external_attributes |= 0x04
+        when :archive
+          entry.header.external_attributes |= 0x20
+        else
+          raise ArgumentError, "Unknown attribute flag: #{flag}"
+        end
+      end
+
+      # Convert Time to DOS time format
+      def dos_time(time)
+        ((time.hour << 11) | (time.min << 5) | (time.sec / 2)) & 0xFFFF
+      end
+
+      # Convert Time to DOS date format
+      def dos_date(time)
+        (((time.year - 1980) << 9) | (time.month << 5) | time.day) & 0xFFFF
+      end
+    end
+  end
+end

data/lib/omnizip/metadata/metadata_editor.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Metadata
+    # Coordinates metadata editing operations
+    class MetadataEditor
+      attr_reader :archive, :validator
+
+      # Initialize metadata editor
+      # @param archive [Omnizip::Zip::File] Archive to edit
+      def initialize(archive)
+        @archive = archive
+        @validator = MetadataValidator.new
+        @changes = []
+      end
+
+      # Set timestamps for all entries
+      # @param time [Time] Time to set
+      # @param filter [Proc] Optional filter to select entries
+      def set_all_timestamps(time, &filter)
+        validator.validate_time(time)
+
+        entries = filter ? archive.entries.select(&filter) : archive.entries
+
+        entries.each do |entry|
+          next if entry.directory?
+
+          metadata = EntryMetadata.new(entry)
+          metadata.mtime = time
+          @changes << { entry: entry, field: :mtime, value: time }
+        end
+
+        self
+      end
+
+      # Normalize permissions (set sensible defaults)
+      # @param file_perms [Integer] Permissions for files (default: 0644)
+      # @param dir_perms [Integer] Permissions for directories (default: 0755)
+      def normalize_permissions(file_perms: 0o644, dir_perms: 0o755)
+        validator.validate_permissions(file_perms)
+        validator.validate_permissions(dir_perms)
+
+        archive.entries.each do |entry|
+          metadata = EntryMetadata.new(entry)
+          perms = entry.directory? ? dir_perms : file_perms
+          metadata.unix_permissions = perms
+          @changes << { entry: entry, field: :permissions, value: perms }
+        end
+
+        self
+      end
+
+      # Strip all comments from entries and archive
+      def strip_comments
+        archive.entries.each do |entry|
+          metadata = EntryMetadata.new(entry)
+          metadata.comment = ""
+          @changes << { entry: entry, field: :comment, value: "" }
+        end
+
+        archive.comment = ""
+        @changes << { entry: :archive, field: :comment, value: "" }
+
+        self
+      end
+
+      # Set comment for entries matching a pattern
+      # @param pattern [String, Regexp] Pattern to match
+      # @param comment [String] Comment to set
+      def set_comment_matching(pattern, comment)
+        validator.validate_comment(comment)
+
+        matching_entries = if pattern.is_a?(Regexp)
+                             archive.entries.select { |e| e.name =~ pattern }
+                           else
+                             archive.entries.select do |e|
+                               ::File.fnmatch(pattern, e.name)
+                             end
+                           end
+
+        matching_entries.each do |entry|
+          metadata = EntryMetadata.new(entry)
+          metadata.comment = comment
+          @changes << { entry: entry, field: :comment, value: comment }
+        end
+
+        self
+      end
+
+      # Set permissions for entries matching a pattern
+      # @param pattern [String, Regexp] Pattern to match
+      # @param perms [Integer] Permissions to set
+      def set_permissions_matching(pattern, perms)
+        validator.validate_permissions(perms)
+
+        matching_entries = if pattern.is_a?(Regexp)
+                             archive.entries.select { |e| e.name =~ pattern }
+                           else
+                             archive.entries.select do |e|
+                               ::File.fnmatch(pattern, e.name)
+                             end
+                           end
+
+        matching_entries.each do |entry|
+          next if entry.directory?
+
+          metadata = EntryMetadata.new(entry)
+          metadata.unix_permissions = perms
+          @changes << { entry: entry, field: :permissions, value: perms }
+        end
+
+        self
+      end
+
+      # Update timestamps to preserve relative ordering
+      # Useful for maintaining build timestamps while updating absolute times
+      # @param base_time [Time] Base time for earliest file
+      def preserve_relative_timestamps(base_time = Time.now)
+        validator.validate_time(base_time)
+
+        # Find earliest timestamp
+        earliest = archive.entries.map(&:time).min
+        return self unless earliest
+
+        # Calculate offset
+        offset = base_time.to_i - earliest.to_i
+
+        archive.entries.each do |entry|
+          next if entry.directory?
+
+          new_time = Time.at(entry.time.to_i + offset)
+          metadata = EntryMetadata.new(entry)
+          metadata.mtime = new_time
+          @changes << { entry: entry, field: :mtime, value: new_time }
+        end
+
+        self
+      end
+
+      # Get list of pending changes
+      # @return [Array<Hash>] List of changes
+      def pending_changes
+        @changes
+      end
+
+      # Check if there are pending changes
+      # @return [Boolean] True if there are changes
+      def modified?
+        !@changes.empty?
+      end
+
+      # Clear pending changes
+      def clear_changes
+        @changes = []
+        self
+      end
+
+      # Commit all changes to archive
+      # This marks the archive as modified and saves on close
+      def commit
+        # Changes are already applied to entries
+        # Just mark archive as modified
+        archive.modified! if modified?
+        @changes = []
+        self
+      end
+    end
+  end
+end

data/lib/omnizip/metadata/metadata_registry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Metadata
+    # Registry of supported metadata per archive format
+    class MetadataRegistry
+      @registry = {}
+
+      class << self
+        # Register metadata support for a format
+        # @param format [Symbol] Format name (e.g., :zip, :seven_zip)
+        # @param supported_fields [Array<Symbol>] Supported metadata fields
+        def register(format, supported_fields)
+          @registry[format] = supported_fields
+        end
+
+        # Check if a format supports a metadata field
+        # @param format [Symbol] Format name
+        # @param field [Symbol] Metadata field name
+        # @return [Boolean] True if supported
+        def supports?(format, field)
+          fields = @registry[format]
+          return false unless fields
+
+          fields.include?(field)
+        end
+
+        # Get all supported fields for a format
+        # @param format [Symbol] Format name
+        # @return [Array<Symbol>] List of supported fields
+        def supported_fields(format)
+          @registry[format] || []
+        end
+
+        # Get all registered formats
+        # @return [Array<Symbol>] List of formats
+        def formats
+          @registry.keys
+        end
+
+        # Reset registry (for testing)
+        def reset
+          @registry = {}
+        end
+      end
+    end
+
+    # Register ZIP format metadata support
+    MetadataRegistry.register(:zip, %i[
+                                comment
+                                mtime
+                                unix_permissions
+                                external_attributes
+                                filename
+                                extra_field
+                              ])
+
+    # Register 7z format metadata support: the readable fields the
+    # handler detail contract carries (name/size/directory always
+    # present; compressed_size when tracked, mtime/crc when stored).
+    # Editing is ZIP-only — the metadata command raises truthfully.
+    MetadataRegistry.register(:seven_zip, %i[
+                                name
+                                size
+                                directory
+                                compressed_size
+                                mtime
+                                crc
+                              ])
+  end
+end