omnizip 0.4.7-arm-linux

data/lib/omnizip/zip/entry.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Zip
+    # Rubyzip-compatible Entry class
+    # Wraps CentralDirectoryHeader with rubyzip API
+    class Entry
+      include Omnizip::Entry
+
+      attr_reader :header, :ftype, :filepath
+
+      def entry_name = name
+      def entry_directory? = directory?
+      def entry_size = size
+      def entry_mtime = time
+
+      # Create entry from CentralDirectoryHeader
+      def initialize(header, filepath: nil)
+        @header = header
+        @filepath = filepath
+        @ftype = header.directory? ? :directory : :file
+      end
+
+      # Entry name (path within archive)
+      def name
+        header.filename
+      end
+
+      # Uncompressed size
+      def size
+        header.uncompressed_size
+      end
+
+      # Compressed size
+      def compressed_size
+        header.compressed_size
+      end
+
+      # CRC32 checksum
+      def crc
+        header.crc32
+      end
+
+      # Compression method ID
+      def compression_method
+        header.compression_method
+      end
+
+      # Modification time
+      def time
+        dos_time_to_time(header.last_mod_date, header.last_mod_time)
+      end
+
+      # Is this a directory?
+      def directory?
+        @ftype == :directory
+      end
+      alias_method :is_directory, :directory?
+
+      # Is this a file?
+      def file?
+        @ftype == :file
+      end
+
+      # Is this a symbolic link?
+      def symlink?
+        false # Not supported yet
+      end
+
+      # Get comment
+      def comment
+        header.comment || ""
+      end
+
+      # Set comment
+      def comment=(value)
+        header.comment = value
+      end
+
+      # Get extra field
+      def extra
+        header.extra_field || ""
+      end
+
+      # Set extra field
+      def extra=(value)
+        header.extra_field = value
+      end
+
+      # Unix permissions
+      def unix_perms
+        header.unix_permissions
+      end
+
+      # Set Unix permissions
+      def unix_perms=(perms)
+        header.unix_permissions = perms
+      end
+
+      # Get metadata for this entry
+      # @return [Omnizip::Metadata::EntryMetadata] Entry metadata
+      def metadata
+        @metadata ||= Omnizip::Metadata::EntryMetadata.new(self)
+      end
+
+      # Save metadata changes
+      # Marks the entry as modified so changes are written on archive close
+      def save_metadata
+        # Changes are already applied to the header
+        # This is a convenience method for the API
+        metadata.reset_modified
+      end
+
+      # Extract this entry to a destination path
+      # Note: This requires access to the archive file
+      def extract(dest_path)
+        raise NotImplementedError,
+              "Entry#extract requires File context. Use Omnizip::Zip::File#extract instead"
+      end
+
+      # Get input stream for this entry
+      # Note: This requires access to the archive file
+      def get_input_stream
+        raise NotImplementedError,
+              "Entry#get_input_stream requires File context"
+      end
+
+      # String representation
+      def to_s
+        name
+      end
+
+      # Equality comparison
+      def ==(other)
+        return false unless other.is_a?(Entry)
+
+        name == other.name
+      end
+
+      private
+
+      # Convert DOS date/time to Ruby Time
+      def dos_time_to_time(dos_date, dos_time)
+        return Time.now if dos_date.zero? && dos_time.zero?
+
+        year = ((dos_date >> 9) & 0x7F) + 1980
+        month = (dos_date >> 5) & 0x0F
+        day = dos_date & 0x1F
+
+        hour = (dos_time >> 11) & 0x1F
+        min = (dos_time >> 5) & 0x3F
+        sec = (dos_time & 0x1F) * 2
+
+        Time.new(year, month, day, hour, min, sec)
+      rescue ArgumentError
+        Time.now
+      end
+    end
+  end
+end

data/lib/omnizip/zip/file.rb

@@ -0,0 +1,485 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "stringio"
+
+module Omnizip
+  module Zip
+    # Rubyzip-compatible File class
+    # Provides drop-in replacement for Zip::File from rubyzip
+    class File
+      include Enumerable
+
+      attr_reader :name, :entries, :comment
+
+      # Open a ZIP archive
+      # @param file_path [String] Path to ZIP file
+      # @param create [Boolean] Create file if it doesn't exist
+      # @param options [Hash] Additional options
+      # @yield [file] Block to execute with the opened archive
+      # @return [File] The opened archive (if no block given)
+      def self.open(file_path, create: false, **options)
+        file = new(file_path, create: create, **options)
+
+        if block_given?
+          begin
+            yield(file)
+          ensure
+            file.close
+          end
+        else
+          file
+        end
+      end
+
+      # Create a new archive from scratch
+      # @param file_path [String] Path to ZIP file
+      # @yield [file] Block to execute with the new archive
+      def self.create(file_path, &block)
+        open(file_path, create: true, &block)
+      end
+
+      # Initialize a ZIP file
+      # @param file_path [String] Path to ZIP file
+      # @param create [Boolean] Create file if it doesn't exist
+      def initialize(file_path, create: false, **options)
+        @name = file_path
+        @entries = []
+        @comment = ""
+        @create = create
+        @options = options
+        @modified = false
+        @reader = nil
+        @writer = nil
+        # Load existing archive if it exists
+        if ::File.exist?(file_path) && !create
+          load_archive
+        elsif create
+          # Will create on write/close
+          @modified = true
+        elsif !::File.exist?(file_path)
+          raise Errno::ENOENT, "No such file or directory - #{file_path}"
+        end
+      end
+
+      # Add a file to the archive
+      # @param entry_name [String] Name in the archive
+      # @param src_path [String, nil] Source file path (optional if block given)
+      # @yield Block that returns content to add
+      def add(entry_name, src_path = nil)
+        # Handle directory entries (ending with /)
+        if entry_name.end_with?("/") && !src_path && !block_given?
+          add_directory(entry_name)
+        elsif block_given?
+          data = yield
+          add_data(entry_name, data)
+        elsif src_path
+          add_file_from_path(entry_name, src_path)
+        else
+          raise ArgumentError, "Either src_path or block must be provided"
+        end
+
+        @modified = true
+        self
+      end
+
+      # Get entry by name
+      # @param entry_name [String] Name of the entry
+      # @return [Entry, nil] The entry or nil if not found
+      def get_entry(entry_name)
+        entries.find { |e| e.name == entry_name }
+      end
+      alias_method :find_entry, :get_entry
+
+      # Get input stream for an entry
+      # @param entry [Entry, String] Entry object or name
+      # @yield [stream] Block to read from the stream
+      # @return [String] Entry content (if no block given)
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding, Style/BlockDelimiters -- Ruby 3.0 compatibility
+      def get_input_stream(entry, &block)
+        entry = get_entry(entry) if entry.is_a?(String)
+        raise Errno::ENOENT, "Entry not found: #{entry}" unless entry
+
+        content = read_entry_data(entry)
+
+        if block
+          StringIO.open(content, "rb", &block)
+        else
+          content
+        end
+      end
+      alias_method :read, :get_input_stream
+
+      # Iterate over all entries
+      # @yield [entry] Block to execute for each entry
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+      def each(&block)
+        entries.each(&block)
+      end
+
+      # Extract an entry to a destination path
+      # @param entry [Entry, String] Entry object or name
+      # @param dest_path [String] Destination file path
+      def extract(entry, dest_path, &on_exists_proc)
+        entry = get_entry(entry) if entry.is_a?(String)
+        raise Errno::ENOENT, "Entry not found: #{entry}" unless entry
+
+        # Handle existing file
+        if ::File.exist?(dest_path)
+          if on_exists_proc
+            action = yield(entry, dest_path)
+            return if action == false
+          else
+            raise Errno::EEXIST, "Destination file already exists: #{dest_path}"
+          end
+        end
+
+        extract_entry_to_path(entry, dest_path)
+      end
+
+      # Remove an entry from the archive
+      # @param entry_name [String] Name of the entry to remove
+      def remove(entry_name)
+        entry = get_entry(entry_name)
+        @entries.delete(entry) if entry
+        @modified = true
+        @reader = nil
+        self
+      end
+
+      # Rename an entry
+      # @param entry_name [String] Current entry name
+      # @param new_name [String] New entry name
+      def rename(entry_name, new_name)
+        entry = get_entry(entry_name)
+        return unless entry
+
+        entry.header.filename = new_name
+        @modified = true
+        self
+      end
+
+      # Replace entry content
+      # @param entry_name [String] Entry name
+      # @param src_path [String, nil] Source file path
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+      def replace(entry_name, src_path = nil, &block)
+        remove(entry_name)
+        add(entry_name, src_path, &block)
+      end
+
+      # Get archive comment
+      def comment
+        @comment
+      end
+
+      # Set archive comment
+      def comment=(value)
+        @comment = value.to_s
+        @modified = true
+      end
+
+      # Get number of entries
+      def size
+        entries.size
+      end
+      alias_method :length, :size
+
+      # Mark this archive as having unsaved changes. The next +#commit+
+      # or +#close+ will write the archive to disk.
+      def modified!
+        @modified = true
+        self
+      end
+
+      # True if there are unsaved changes.
+      def modified?
+        @modified
+      end
+
+      # Check if archive contains an entry
+      # @param entry_name [String] Entry name to check
+      # @return [Boolean] True if entry exists
+      def include?(entry_name)
+        !get_entry(entry_name).nil?
+      end
+
+      # Get names of all entries
+      # @return [Array<String>] Array of entry names
+      def names
+        entries.map(&:name)
+      end
+
+      # Glob entries by pattern
+      # @param pattern [String] Glob pattern
+      # @return [Array<Entry>] Matching entries
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding, Style/BlockDelimiters -- Ruby 3.0 compatibility
+      def glob(pattern, &block)
+        matching = entries.select { |e| ::File.fnmatch(pattern, e.name) }
+
+        if block
+          matching.each(&block)
+        else
+          matching
+        end
+      end
+
+      # Extract files matching a pattern
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @param dest [String] Destination directory
+      # @param options [Hash] Extraction options
+      # @option options [Boolean] :preserve_paths Keep directory structure
+      # @option options [Boolean] :flatten Extract all to destination root
+      # @option options [Boolean] :overwrite Overwrite existing files
+      # @return [Array<String>] Paths of extracted files
+      def extract_matching(pattern, dest, options = {})
+        Omnizip::Extraction.extract_matching(self, pattern, dest, options)
+      end
+
+      # Extract files matching a pattern to memory
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Hash<String, String>] Hash of filename => content
+      def extract_matching_to_memory(pattern)
+        Omnizip::Extraction.extract_to_memory_matching(self, pattern)
+      end
+
+      # List files matching a pattern
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Array<Entry>] Matching entries
+      def list_matching(pattern)
+        Omnizip::Extraction.list_matching(self, pattern)
+      end
+
+      # Count files matching a pattern
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Integer] Number of matches
+      def count_matching(pattern)
+        Omnizip::Extraction.count_matching(self, pattern)
+      end
+
+      # Extract with a filter chain
+      # @param filter [Omnizip::Extraction::FilterChain] Filter chain
+      # @param dest [String] Destination directory
+      # @param options [Hash] Extraction options
+      # @return [Array<String>] Paths of extracted files
+      def extract_with_filter(filter, dest, options = {})
+        Omnizip::Extraction.extract_with_filter(self, filter, dest, options)
+      end
+
+      # Get archive metadata
+      # @return [Omnizip::Metadata::ArchiveMetadata] Archive metadata
+      def metadata
+        @metadata ||= Omnizip::Metadata::ArchiveMetadata.new(self)
+      end
+
+      # Save metadata changes
+      # Marks the archive as modified so changes are written on close
+      def save_metadata
+        @modified = true
+        metadata.reset_modified
+      end
+
+      # Commit changes to disk
+      def commit
+        write_archive if @modified
+        @modified = false
+        @reader = nil # Invalidate reader after writing
+      end
+
+      # Close the archive
+      def close
+        commit if @modified
+        @reader = nil
+        @writer = nil
+      end
+
+      private
+
+      # Load existing archive
+      def load_archive
+        @reader = Omnizip::Formats::Zip::Reader.new(@name)
+        @reader.read
+
+        @entries = @reader.entries.map do |header|
+          Entry.new(header, filepath: @name)
+        end
+      end
+
+      # Add file from filesystem path
+      def add_file_from_path(entry_name, src_path)
+        unless ::File.exist?(src_path)
+          raise Errno::ENOENT, "Source file not found: #{src_path}"
+        end
+
+        if ::File.directory?(src_path)
+          add_directory(entry_name)
+        else
+          data = ::File.binread(src_path)
+          stat = ::File.stat(src_path)
+          add_data(entry_name, data, stat: stat)
+        end
+      end
+
+      # Add data directly
+      def add_data(entry_name, data, stat: nil)
+        # Remove existing entry with same name
+        remove(entry_name)
+
+        # Create new header
+        header = create_header(entry_name, data, stat: stat)
+        entry = Entry.new(header, filepath: @name)
+        @entries << entry
+
+        # Invalidate reader cache since we modified entries
+        @reader = nil
+      end
+
+      # Add directory entry
+      def add_directory(entry_name)
+        entry_name = "#{entry_name}/" unless entry_name.end_with?("/")
+        header = create_header(entry_name, "", directory: true)
+        entry = Entry.new(header, filepath: @name)
+        @entries << entry
+      end
+
+      # Create a central directory header
+      def create_header(filename, data, stat: nil, directory: false)
+        now = Time.now
+        crc32 = if directory
+                  0
+                else
+                  Omnizip::Checksums::Crc32.new.tap do |c|
+                    c.update(data)
+                  end.value
+                end
+
+        external_attrs = if directory
+                           Omnizip::Formats::Zip::Constants::UNIX_DIR_PERMISSIONS |
+                             Omnizip::Formats::Zip::Constants::ATTR_DIRECTORY
+                         elsif stat
+                           (stat.mode & 0o777) << 16
+                         else
+                           Omnizip::Formats::Zip::Constants::UNIX_FILE_PERMISSIONS
+                         end
+
+        Omnizip::Formats::Zip::CentralDirectoryHeader.new(
+          version_made_by: Omnizip::Formats::Zip::Constants::VERSION_MADE_BY_UNIX |
+                          Omnizip::Formats::Zip::Constants::VERSION_DEFAULT,
+          version_needed: Omnizip::Formats::Zip::Constants::VERSION_DEFAULT,
+          flags: Omnizip::Formats::Zip::Constants::FLAG_UTF8,
+          compression_method: directory ? 0 : 8, # Store or Deflate
+          last_mod_time: dos_time(now),
+          last_mod_date: dos_date(now),
+          crc32: crc32,
+          compressed_size: 0, # Will be set during write
+          uncompressed_size: data.bytesize,
+          disk_number_start: 0,
+          internal_attributes: 0,
+          external_attributes: external_attrs,
+          local_header_offset: 0, # Will be set during write
+          filename: filename,
+          extra_field: "",
+          comment: "",
+        ).tap do |header|
+          header.cached_original_data = data
+        end
+      end
+
+      # Read entry data from archive
+      def read_entry_data(entry)
+        return "" if entry.directory?
+
+        # Check if we have cached data (for new entries not yet written)
+        cached_data = entry.header.cached_original_data
+        return cached_data if cached_data
+
+        # Otherwise read from file
+        unless @reader
+          @reader = Omnizip::Formats::Zip::Reader.new(@name)
+          @reader.read
+        end
+
+        ::File.open(@name, "rb") do |io|
+          # Find the entry in reader
+          reader_entry = @reader.entries.find { |e| e.filename == entry.name }
+          raise Errno::ENOENT, "Entry not found in archive: #{entry.name}" unless reader_entry
+
+          # Extract just the data
+          io.seek(reader_entry.local_header_offset, ::IO::SEEK_SET)
+
+          # Read and parse local file header
+          fixed_header = io.read(30)
+          return "" unless fixed_header && fixed_header.size == 30
+
+          _signature, _version, _flags, _method, _time, _date, _crc32,
+          _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
+
+          # Skip filename and extra field
+          io.read(filename_length + extra_length)
+
+          # Read compressed data
+          compressed_data = io.read(reader_entry.compressed_size)
+          return "" unless compressed_data
+
+          # Decompress
+          @reader.decompress(
+            compressed_data,
+            reader_entry.compression_method,
+            reader_entry.uncompressed_size,
+          )
+        end
+      end
+
+      # Extract entry to filesystem
+      def extract_entry_to_path(entry, dest_path)
+        if entry.directory?
+          FileUtils.mkdir_p(dest_path)
+        else
+          FileUtils.mkdir_p(::File.dirname(dest_path))
+          content = read_entry_data(entry)
+          ::File.binwrite(dest_path, content)
+
+          # Set permissions if Unix
+          if entry.unix_perms.positive?
+            ::File.chmod(entry.unix_perms & 0o777, dest_path)
+          end
+        end
+      end
+
+      # Write archive to disk
+      def write_archive
+        # Cache all entry data before writing (to avoid reading while writing)
+        entry_data = {}
+        entries.each do |entry|
+          next if entry.directory?
+
+          header = entry.header
+          cached = header.cached_original_data
+          entry_data[entry.name] = cached || read_entry_data(entry)
+        end
+
+        writer = Omnizip::Formats::Zip::Writer.new(@name)
+
+        entries.each do |entry|
+          if entry.directory?
+            writer.add_directory(entry.name)
+          else
+            writer.add_data(entry.name, entry_data[entry.name])
+          end
+        end
+
+        writer.write
+      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