omnizip 0.4.7-x86_64-linux

data/lib/omnizip/extraction/selective_extractor.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Extraction
+    # Coordinates selective extraction from archives
+    #
+    # Extracts only files matching specified patterns, efficiently
+    # skipping non-matched files without decompression.
+    class SelectiveExtractor
+      attr_reader :archive, :filter
+
+      # Initialize a new selective extractor
+      #
+      # @param archive [Object] Archive to extract from
+      # @param filter [FilterChain, PatternMatcher, Object] Filter to apply
+      def initialize(archive, filter = nil)
+        @archive = archive
+        @filter = normalize_filter(filter)
+      end
+
+      # Extract matching files to destination
+      #
+      # @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 root
+      # @option options [Boolean] :overwrite Overwrite existing files
+      # @option options [Progress::ProgressTracker] :progress Progress tracker
+      # @return [Array<String>] Paths of extracted files
+      def extract(dest, options = {})
+        FileUtils.mkdir_p(dest)
+        extracted = []
+
+        # Directory entries carry no content to extract
+        entries_to_extract = list_matches.reject do |entry|
+          entry_filename(entry).end_with?("/")
+        end
+        total = entries_to_extract.size
+        current = 0
+
+        entries_to_extract.each do |entry|
+          dest_path = build_dest_path(entry, dest, options)
+          extract_entry(entry, dest_path, options)
+          extracted << dest_path
+
+          # Update progress if tracker provided
+          current += 1
+          update_progress(options[:progress], current, total, entry)
+        end
+
+        extracted
+      end
+
+      # Extract matching files to memory
+      #
+      # @return [Hash<String, String>] Hash of filename => content
+      def extract_to_memory
+        result = {}
+
+        list_matches.each do |entry|
+          filename = entry_filename(entry)
+          content = read_entry_content(entry)
+          result[filename] = content
+        end
+
+        result
+      end
+
+      # List matching entries without extracting
+      #
+      # @return [Array] Matching entries
+      def list_matches
+        return list_all if @filter.nil?
+
+        list_all.select do |entry|
+          filter_matches?(entry)
+        end
+      end
+
+      # Count matching entries
+      #
+      # @return [Integer]
+      def count_matches
+        list_matches.size
+      end
+
+      # Get match result with statistics
+      #
+      # @return [Models::MatchResult]
+      def match_result
+        all_entries = list_all
+        matches = if @filter
+                    all_entries.select { |entry| filter_matches?(entry) }
+                  else
+                    all_entries
+                  end
+
+        Models::MatchResult.new(
+          @filter&.to_s || "all",
+          matches: matches,
+          total_scanned: all_entries.size,
+        )
+      end
+
+      private
+
+      # Normalize filter to FilterChain or PatternMatcher
+      #
+      # @param filter [Object] Input filter
+      # @return [FilterChain, PatternMatcher, nil]
+      def normalize_filter(filter)
+        case filter
+        when FilterChain, PatternMatcher
+          filter
+        when nil
+          nil
+        else
+          PatternMatcher.new(filter)
+        end
+      end
+
+      # List all entries in archive
+      #
+      # @return [Array] All entries
+      def list_all
+        # allowed: public API takes any archive object, including foreign ones
+        if @archive.respond_to?(:entries)
+          @archive.entries
+        # allowed: public API takes any Enumerable archive
+        elsif @archive.respond_to?(:each)
+          @archive.to_a
+        else
+          raise Error, "Archive does not support listing entries"
+        end
+      end
+
+      # Extract a single entry
+      #
+      # @param entry [Object] Entry to extract
+      # @param dest_path [String] Destination path
+      # @param options [Hash] Options
+      def extract_entry(entry, dest_path, options)
+        return if File.exist?(dest_path) && !options[:overwrite]
+
+        # Create parent directory
+        FileUtils.mkdir_p(File.dirname(dest_path))
+
+        # Extract content
+        content = read_entry_content(entry)
+        File.binwrite(dest_path, content)
+      end
+
+      # Read content from an entry
+      #
+      # @param entry [Object] Entry to read
+      # @return [String] Entry content
+      def read_entry_content(entry)
+        # allowed: entries come from a caller-supplied archive
+        if entry.respond_to?(:read)
+          entry.read
+        # allowed: rubyzip-style entries expose get_input_stream, not read
+        elsif entry.respond_to?(:get_input_stream)
+          entry.get_input_stream.read
+        # allowed: some archives read entry content from the archive
+        elsif @archive.respond_to?(:read)
+          @archive.read(entry_filename(entry))
+        else
+          raise Error, "Cannot read entry content"
+        end
+      end
+
+      # Build destination path for an entry
+      #
+      # @param entry [Object] Entry
+      # @param dest [String] Destination directory
+      # @param options [Hash] Options
+      # @return [String] Full destination path
+      def build_dest_path(entry, dest, options)
+        filename = entry_filename(entry)
+
+        if options[:flatten]
+          # Extract to root, use basename only
+          File.join(dest, File.basename(filename))
+        elsif options[:preserve_paths] != false
+          # Preserve directory structure (default)
+          File.join(dest, filename)
+        else
+          # Use basename
+          File.join(dest, File.basename(filename))
+        end
+      end
+
+      # Get filename from entry
+      #
+      # @param entry [#entry_name, #name] Entry (legacy Omnizip::Entry,
+      #   Archive::Entry from a reader session, or compatible)
+      # @return [String] Filename
+      def entry_filename(entry)
+        # allowed: entries come from a caller-supplied archive
+        if entry.respond_to?(:entry_name)
+          entry.entry_name
+        # allowed: reader-session entries expose name, not entry_name
+        elsif entry.respond_to?(:name)
+          entry.name
+        else
+          entry.to_s
+        end
+      end
+
+      # Update progress tracker
+      #
+      # @param tracker [Progress::ProgressTracker, nil] Progress tracker
+      # @param current [Integer] Current count
+      # @param total [Integer] Total count
+      # @param entry [Object] Current entry
+      def update_progress(tracker, current, total, entry)
+        return unless tracker
+
+        tracker.update(
+          current_bytes: current,
+          total_bytes: total,
+          current_file: entry_filename(entry),
+        )
+      end
+
+      # Check if entry matches the filter
+      #
+      # @param entry [Object] Entry to check
+      # @return [Boolean]
+      def filter_matches?(entry)
+        filename = entry_filename(entry)
+
+        case @filter
+        when FilterChain
+          @filter.match?(entry, filename: filename)
+        when PatternMatcher
+          @filter.match?(filename)
+        else
+          # For other pattern types, try match? with filename
+          @filter.match?(filename)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/extraction.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Provides selective extraction capabilities for archives
+  #
+  # Supports extracting files matching glob patterns, regex patterns,
+  # or custom predicates without extracting the entire archive.
+  module Extraction
+    # Nested classes - autoloaded
+    autoload :PatternMatcher, "omnizip/extraction/pattern_matcher"
+    autoload :FilterChain, "omnizip/extraction/filter_chain"
+    autoload :SelectiveExtractor, "omnizip/extraction/selective_extractor"
+    autoload :GlobPattern, "omnizip/extraction/glob_pattern"
+    autoload :RegexPattern, "omnizip/extraction/regex_pattern"
+    autoload :PredicatePattern, "omnizip/extraction/predicate_pattern"
+
+    # Cross-namespace dependencies - autoloaded
+    autoload :MatchResult, "omnizip/models/match_result"
+
+    class << self
+      # Extract files matching a pattern from an archive
+      #
+      # @param archive [Object] Archive to extract from
+      # @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(archive, pattern, dest, options = {})
+        filter = build_filter(pattern)
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.extract(dest, options)
+      end
+
+      # Extract files matching a pattern to memory
+      #
+      # @param archive [Object] Archive to extract from
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Hash<String, String>] Hash of filename => content
+      def extract_to_memory_matching(archive, pattern)
+        filter = build_filter(pattern)
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.extract_to_memory
+      end
+
+      # List files matching a pattern without extracting
+      #
+      # @param archive [Object] Archive to list from
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Array] Matching entries
+      def list_matching(archive, pattern)
+        filter = build_filter(pattern)
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.list_matches
+      end
+
+      # Count files matching a pattern
+      #
+      # @param archive [Object] Archive to count in
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Integer] Number of matches
+      def count_matching(archive, pattern)
+        filter = build_filter(pattern)
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.count_matches
+      end
+
+      # Extract with a filter chain
+      #
+      # @param archive [Object] Archive to extract from
+      # @param filter [FilterChain] Filter chain to apply
+      # @param dest [String] Destination directory
+      # @param options [Hash] Extraction options
+      # @return [Array<String>] Paths of extracted files
+      def extract_with_filter(archive, filter, dest, options = {})
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.extract(dest, options)
+      end
+
+      # Get match result with statistics
+      #
+      # @param archive [Object] Archive to analyze
+      # @param pattern [String, Regexp, Array] Pattern(s) to match
+      # @return [Models::MatchResult] Match result with statistics
+      def match_result(archive, pattern)
+        filter = build_filter(pattern)
+        extractor = SelectiveExtractor.new(archive, filter)
+        extractor.match_result
+      end
+
+      private
+
+      # Build filter from pattern(s)
+      #
+      # @param pattern [Object] Pattern or array of patterns
+      # @return [PatternMatcher, FilterChain]
+      def build_filter(pattern)
+        case pattern
+        when Array
+          # Multiple patterns - combine with OR logic
+          filter = FilterChain.new
+          pattern.each { |p| filter.include_pattern(p) }
+          filter
+        when FilterChain
+          pattern
+        else
+          # Single pattern
+          PatternMatcher.new(pattern)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/file_type/mime_classifier.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module FileType
+    # Centralized MIME type classification for file type detection
+    #
+    # This class provides methods to classify MIME types into categories
+    # and determine appropriate compression profiles based on file type.
+    class MimeClassifier
+      # Text-based MIME types
+      TEXT_TYPES = %w[
+        text/plain
+        text/html
+        text/css
+        text/javascript
+        text/xml
+        text/csv
+        text/markdown
+        application/json
+        application/xml
+        application/javascript
+        application/ecmascript
+        application/x-httpd-php
+        application/x-sh
+        application/x-csh
+        application/x-perl
+        application/x-python
+        application/x-ruby
+        application/x-sql
+        application/sql
+      ].freeze
+
+      # Archive MIME types
+      ARCHIVE_TYPES = %w[
+        application/zip
+        application/x-7z-compressed
+        application/x-rar-compressed
+        application/x-tar
+        application/gzip
+        application/x-gzip
+        application/x-bzip2
+        application/x-xz
+        application/x-lzip
+        application/x-lzma
+        application/x-compress
+        application/zstd
+        application/x-archive
+        application/x-iso9660-image
+      ].freeze
+
+      # Executable MIME types
+      EXECUTABLE_TYPES = %w[
+        application/x-executable
+        application/x-mach-binary
+        application/x-elf
+        application/x-sharedlib
+        application/x-msdownload
+        application/x-dosexec
+        application/vnd.microsoft.portable-executable
+      ].freeze
+
+      # Binary/unknown MIME types (treated as binary data)
+      BINARY_TYPES = %w[
+        application/octet-stream
+      ].freeze
+
+      # Media MIME types (images, audio, video)
+      MEDIA_TYPES = [
+        /\Aimage\//,
+        /\Aaudio\//,
+        /\Avideo\//,
+        "application/pdf",
+      ].freeze
+
+      class << self
+        # Check if the MIME type is text-based
+        #
+        # @param mime_type [String] The MIME type to check
+        # @return [Boolean] true if text-based
+        def text?(mime_type)
+          return false unless mime_type
+
+          TEXT_TYPES.include?(mime_type) || mime_type.start_with?("text/")
+        end
+
+        # Check if the MIME type is an archive
+        #
+        # @param mime_type [String] The MIME type to check
+        # @return [Boolean] true if archive
+        def archive?(mime_type)
+          return false unless mime_type
+
+          ARCHIVE_TYPES.include?(mime_type)
+        end
+
+        # Check if the MIME type is executable
+        #
+        # @param mime_type [String] The MIME type to check
+        # @return [Boolean] true if executable
+        def executable?(mime_type)
+          return false unless mime_type
+
+          EXECUTABLE_TYPES.include?(mime_type) || BINARY_TYPES.include?(mime_type)
+        end
+
+        # Check if the MIME type is media (image/audio/video)
+        #
+        # @param mime_type [String] The MIME type to check
+        # @return [Boolean] true if media
+        def media?(mime_type)
+          return false unless mime_type
+
+          MEDIA_TYPES.any? do |pattern|
+            case pattern
+            when String
+              mime_type == pattern
+            when Regexp
+              pattern.match?(mime_type)
+            end
+          end
+        end
+
+        # Determine the recommended profile category for a MIME type
+        #
+        # @param mime_type [String] The MIME type to classify
+        # @return [Symbol] The recommended profile category
+        #   (:text, :binary, :archive, :balanced)
+        def profile_category(mime_type)
+          return :balanced unless mime_type
+
+          if text?(mime_type)
+            :text
+          elsif executable?(mime_type)
+            :binary
+          elsif archive?(mime_type) || media?(mime_type)
+            :archive
+          else
+            :balanced
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/file_type.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "marcel"
+require "stringio"
+
+module Omnizip
+  # File type detection module using Marcel for MIME type detection
+  #
+  # Provides MIME type detection using the Marcel library:
+  # - Path-based detection (examines file extension and content)
+  # - Data-based detection (analyzes binary data)
+  # - Stream-based detection (reads from IO streams)
+  #
+  # @example Detect file type from path
+  #   mime_type = Omnizip::FileType.detect('app.exe')
+  #   # => 'application/x-executable'
+  #
+  # @example Detect from binary data
+  #   mime_type = Omnizip::FileType.detect_data(File.binread('image.png'))
+  #   # => 'image/png'
+  #
+  # @example Detect from IO stream with filename hint
+  #   File.open('document.pdf', 'rb') do |file|
+  #     mime_type = Omnizip::FileType.detect_stream(file, filename: 'document.pdf')
+  #     # => 'application/pdf'
+  #   end
+  module FileType
+    autoload :MimeClassifier, "omnizip/file_type/mime_classifier"
+    class << self
+      # Detect MIME type from file path
+      #
+      # Uses Marcel to detect the MIME type by examining both the file
+      # extension and file content. This is the most accurate detection
+      # method when you have a file path.
+      #
+      # @param path [String, Pathname] File path
+      # @return [String, nil] MIME type string or nil if detection fails
+      #
+      # @example
+      #   FileType.detect('document.pdf')
+      #   # => 'application/pdf'
+      def detect(path)
+        return nil unless path
+        return nil unless File.exist?(path)
+
+        Marcel::MimeType.for(Pathname.new(path))
+      rescue StandardError
+        nil
+      end
+
+      # Detect MIME type from binary data
+      #
+      # Uses Marcel to analyze binary data for MIME type detection.
+      # Optionally accepts a filename hint for better accuracy.
+      #
+      # @param data [String] Binary data
+      # @param filename [String, nil] Optional filename hint
+      # @return [String, nil] MIME type string or nil if detection fails
+      #
+      # @example Without filename hint
+      #   data = File.binread('image.png')
+      #   FileType.detect_data(data)
+      #   # => 'image/png'
+      #
+      # @example With filename hint
+      #   FileType.detect_data(data, filename: 'image.png')
+      #   # => 'image/png'
+      def detect_data(data, filename: nil)
+        return nil unless data
+        return nil if data.empty?
+
+        io = StringIO.new(data)
+        io.set_encoding(Encoding::BINARY)
+
+        Marcel::MimeType.for(io, name: filename)
+      rescue StandardError
+        nil
+      end
+
+      # Detect MIME type from IO stream
+      #
+      # Uses Marcel to analyze an IO stream for MIME type detection.
+      # Optionally accepts a filename hint for better accuracy.
+      # The stream position is preserved.
+      #
+      # @param io [IO] IO stream
+      # @param filename [String, nil] Optional filename hint
+      # @return [String, nil] MIME type string or nil if detection fails
+      #
+      # @example
+      #   File.open('document.pdf', 'rb') do |file|
+      #     FileType.detect_stream(file, filename: 'document.pdf')
+      #     # => 'application/pdf'
+      #   end
+      def detect_stream(io, filename: nil)
+        return nil unless io
+
+        # Save current position
+        # allowed: caller-supplied IO; only saved when the stream tracks one
+        original_pos = io.pos if io.respond_to?(:pos)
+
+        mime_type = Marcel::MimeType.for(io, name: filename)
+
+        # Restore position
+        # allowed: caller-supplied IO capability probe
+        io.seek(original_pos) if original_pos && io.respond_to?(:seek)
+
+        mime_type
+      rescue StandardError
+        # Attempt to restore position even on error
+        # allowed: caller-supplied IO capability probe
+        io.seek(original_pos) if original_pos && io.respond_to?(:seek)
+        nil
+      end
+    end
+  end
+end