omnizip 0.3.1

data/lib/omnizip/extraction/filter_chain.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "pattern_matcher"
+
+module Omnizip
+  module Extraction
+    # Combines multiple pattern matchers with AND/OR logic
+    #
+    # Supports include and exclude patterns, allowing complex
+    # filtering scenarios like "all .rb files except in test/".
+    class FilterChain
+      attr_reader :include_patterns, :exclude_patterns,
+                  :include_predicates, :exclude_predicates
+
+      # Initialize a new filter chain
+      def initialize
+        @include_patterns = []
+        @exclude_patterns = []
+        @include_predicates = []
+        @exclude_predicates = []
+      end
+
+      # Add an include pattern
+      #
+      # @param pattern [String, Regexp, Proc] Pattern to include
+      # @return [self]
+      def include_pattern(pattern)
+        @include_patterns << PatternMatcher.new(pattern)
+        self
+      end
+
+      # Add an exclude pattern
+      #
+      # @param pattern [String, Regexp, Proc] Pattern to exclude
+      # @return [self]
+      def exclude_pattern(pattern)
+        @exclude_patterns << PatternMatcher.new(pattern)
+        self
+      end
+
+      # Add an include predicate
+      #
+      # @yield [entry] Entry to test
+      # @yieldreturn [Boolean] Whether to include entry
+      # @return [self]
+      def include(&predicate)
+        @include_predicates << predicate if predicate
+        self
+      end
+
+      # Add an exclude predicate
+      #
+      # @yield [entry] Entry to test
+      # @yieldreturn [Boolean] Whether to exclude entry
+      # @return [self]
+      def exclude(&predicate)
+        @exclude_predicates << predicate if predicate
+        self
+      end
+
+      # Check if an entry matches the filter chain
+      #
+      # Logic:
+      # - If no includes, everything passes (except excludes)
+      # - If includes exist, entry must match at least one include
+      # - Entry must not match any exclude
+      #
+      # @param entry [Object] Entry to check (filename or entry object)
+      # @param filename [String, nil] Explicit filename (if entry is object)
+      # @return [Boolean]
+      def match?(entry, filename: nil)
+        name = filename || extract_filename(entry)
+
+        # Check excludes first (faster to reject)
+        return false if excluded?(entry, name)
+
+        # Check includes
+        included?(entry, name)
+      end
+
+      # Filter an array of entries
+      #
+      # @param entries [Array] Entries to filter
+      # @return [Array] Matching entries
+      def filter(entries)
+        entries.select { |entry| match?(entry) }
+      end
+
+      # Check if chain has any conditions
+      #
+      # @return [Boolean]
+      def any?
+        !@include_patterns.empty? ||
+          !@exclude_patterns.empty? ||
+          !@include_predicates.empty? ||
+          !@exclude_predicates.empty?
+      end
+
+      # Get count of all conditions
+      #
+      # @return [Integer]
+      def count
+        @include_patterns.size +
+          @exclude_patterns.size +
+          @include_predicates.size +
+          @exclude_predicates.size
+      end
+
+      private
+
+      # Check if entry is included
+      #
+      # @param entry [Object] Entry to check
+      # @param filename [String] Filename
+      # @return [Boolean]
+      def included?(entry, filename)
+        # If no include patterns/predicates, include by default
+        has_includes = !@include_patterns.empty? ||
+          !@include_predicates.empty?
+        return true unless has_includes
+
+        # Check if matches any include pattern
+        pattern_match = @include_patterns.any? do |matcher|
+          matcher.match?(filename)
+        end
+
+        # Check if matches any include predicate
+        predicate_match = @include_predicates.any? do |predicate|
+          predicate.call(entry)
+        end
+
+        pattern_match || predicate_match
+      end
+
+      # Check if entry is excluded
+      #
+      # @param entry [Object] Entry to check
+      # @param filename [String] Filename
+      # @return [Boolean]
+      def excluded?(entry, filename)
+        # Check if matches any exclude pattern
+        pattern_match = @exclude_patterns.any? do |matcher|
+          matcher.match?(filename)
+        end
+
+        # Check if matches any exclude predicate
+        predicate_match = @exclude_predicates.any? do |predicate|
+          predicate.call(entry)
+        end
+
+        pattern_match || predicate_match
+      end
+
+      # Extract filename from entry object
+      #
+      # @param entry [Object] Entry object or string
+      # @return [String]
+      def extract_filename(entry)
+        case entry
+        when String
+          entry
+        else
+          # Try common filename methods
+          if entry.respond_to?(:name)
+            entry.name
+          elsif entry.respond_to?(:path)
+            entry.path
+          elsif entry.respond_to?(:filename)
+            entry.filename
+          else
+            entry.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/extraction/glob_pattern.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Extraction
+    # Implements glob pattern matching for file paths
+    #
+    # Supports:
+    # - * - Match any characters except /
+    # - ** - Match any characters including /
+    # - ? - Match single character
+    # - [abc] - Character class
+    # - [!abc] - Negated character class
+    # - {a,b,c} - Alternation (brace expansion)
+    class GlobPattern
+      attr_reader :pattern
+
+      # Initialize a new glob pattern
+      #
+      # @param pattern [String] Glob pattern string
+      def initialize(pattern)
+        @pattern = pattern.to_s
+        @regex = compile_pattern
+      end
+
+      # Check if a filename matches the pattern
+      #
+      # @param filename [String] Filename to check
+      # @return [Boolean]
+      def match?(filename)
+        @regex.match?(filename.to_s)
+      end
+
+      # Convert pattern to string
+      #
+      # @return [String]
+      def to_s
+        @pattern
+      end
+
+      private
+
+      # Compile glob pattern to regex
+      #
+      # @return [Regexp]
+      def compile_pattern
+        # Convert glob to regex (handles braces internally)
+        regex_pattern = glob_to_regex(@pattern)
+
+        # Compile with case-insensitive flag on case-insensitive filesystems
+        Regexp.new("\\A#{regex_pattern}\\z", case_sensitive? ? 0 : Regexp::IGNORECASE)
+      end
+
+      # Convert glob pattern to regex
+      #
+      # @param pattern [String] Glob pattern
+      # @return [String] Regex pattern
+      def glob_to_regex(pattern)
+        result = +""
+        i = 0
+
+        while i < pattern.length
+          char = pattern[i]
+
+          case char
+          when "*"
+            if pattern[i + 1] == "*"
+              # ** matches everything including /
+              result << ".*"
+              i += 1
+              # Skip following / if present (**/foo)
+              i += 1 if pattern[i + 1] == "/"
+            else
+              # * matches everything except /
+              result << "[^/]*"
+            end
+          when "?"
+            # ? matches single character except /
+            result << "[^/]"
+          when "["
+            # Character class
+            j = i + 1
+            j += 1 while j < pattern.length && pattern[j] != "]"
+            if j < pattern.length
+              class_content = pattern[(i + 1)...j]
+              result << if class_content.start_with?("!")
+                          # Negated class [!abc]
+                          "[^#{Regexp.escape(class_content[1..])}]"
+                        else
+                          # Normal class [abc]
+                          "[#{Regexp.escape(class_content)}]"
+                        end
+              i = j
+            else
+              # Unclosed bracket, treat as literal
+              result << Regexp.escape(char)
+            end
+          when "{"
+            # Brace expansion {a,b,c}
+            j = i + 1
+            j += 1 while j < pattern.length && pattern[j] != "}"
+            if j < pattern.length
+              alternatives = pattern[(i + 1)...j].split(",")
+              # Convert each alternative recursively
+              alt_patterns = alternatives.map { |alt| glob_to_regex(alt) }
+              result << "(?:#{alt_patterns.join('|')})"
+              i = j
+            else
+              # Unclosed brace, treat as literal
+              result << Regexp.escape(char)
+            end
+          when "/"
+            # Directory separator
+            result << "/"
+          else
+            # Literal character
+            result << Regexp.escape(char)
+          end
+
+          i += 1
+        end
+
+        result
+      end
+
+      # Check if filesystem is case-sensitive
+      #
+      # @return [Boolean]
+      def case_sensitive?
+        # On macOS and Windows, filesystems are typically case-insensitive
+        # On Linux, they're typically case-sensitive
+        case RUBY_PLATFORM
+        when /darwin/, /mswin/, /mingw/, /cygwin/
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/extraction/pattern_matcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "glob_pattern"
+require_relative "regex_pattern"
+require_relative "predicate_pattern"
+
+module Omnizip
+  module Extraction
+    # Coordinates pattern matching across different pattern types
+    #
+    # Automatically detects pattern type and delegates to appropriate
+    # pattern implementation (glob, regex, or predicate).
+    class PatternMatcher
+      # Initialize a new pattern matcher
+      #
+      # @param pattern [String, Regexp, Proc, Object] Pattern to match
+      def initialize(pattern)
+        @pattern = build_pattern(pattern)
+      end
+
+      # Check if a filename matches the pattern
+      #
+      # @param filename [String] Filename to check
+      # @return [Boolean]
+      def match?(filename)
+        @pattern.match?(filename)
+      end
+
+      # Match against multiple filenames
+      #
+      # @param filenames [Array<String>] Filenames to check
+      # @return [Array<String>] Matching filenames
+      def match_all(filenames)
+        filenames.select { |filename| match?(filename) }
+      end
+
+      # Get the underlying pattern object
+      #
+      # @return [GlobPattern, RegexPattern, PredicatePattern]
+      attr_reader :pattern
+
+      # Convert pattern to string
+      #
+      # @return [String]
+      def to_s
+        @pattern.to_s
+      end
+
+      private
+
+      # Build appropriate pattern object from input
+      #
+      # @param pattern [Object] Input pattern
+      # @return [GlobPattern, RegexPattern, PredicatePattern]
+      def build_pattern(pattern)
+        case pattern
+        when Regexp
+          RegexPattern.new(pattern)
+        when Proc
+          PredicatePattern.new("custom predicate", &pattern)
+        when GlobPattern, RegexPattern, PredicatePattern
+          pattern
+        else
+          # Assume string glob pattern
+          GlobPattern.new(pattern.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/extraction/predicate_pattern.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Extraction
+    # Implements custom predicate pattern matching for archive entries
+    #
+    # Allows using arbitrary Ruby blocks to determine if an entry matches.
+    class PredicatePattern
+      attr_reader :predicate, :description
+
+      # Initialize a new predicate pattern
+      #
+      # @param description [String] Human-readable description
+      # @param predicate [Proc] Block that tests entries
+      # @yield [entry] Entry to test
+      # @yieldreturn [Boolean] Whether entry matches
+      def initialize(description = "custom predicate", &predicate)
+        raise ArgumentError, "Block required" unless predicate
+
+        @description = description
+        @predicate = predicate
+      end
+
+      # Check if an entry matches the predicate
+      #
+      # @param entry [Object] Entry to check (can be filename or entry object)
+      # @return [Boolean]
+      def match?(entry)
+        @predicate.call(entry)
+      rescue StandardError => e
+        # If predicate raises error, treat as non-match
+        warn "Predicate error for #{entry}: #{e.message}"
+        false
+      end
+
+      # Convert pattern to string
+      #
+      # @return [String]
+      def to_s
+        @description
+      end
+
+      # Call the predicate directly
+      #
+      # @param entry [Object] Entry to check
+      # @return [Boolean]
+      def call(entry)
+        match?(entry)
+      end
+    end
+  end
+end

data/lib/omnizip/extraction/regex_pattern.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Extraction
+    # Implements regex pattern matching for file paths
+    #
+    # Wraps Ruby Regexp objects to provide consistent interface
+    # with other pattern types.
+    class RegexPattern
+      attr_reader :pattern
+
+      # Initialize a new regex pattern
+      #
+      # @param pattern [Regexp, String] Regex pattern
+      def initialize(pattern)
+        @pattern = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern)
+      end
+
+      # Check if a filename matches the pattern
+      #
+      # @param filename [String] Filename to check
+      # @return [Boolean]
+      def match?(filename)
+        @pattern.match?(filename.to_s)
+      end
+
+      # Get match data for a filename
+      #
+      # @param filename [String] Filename to check
+      # @return [MatchData, nil]
+      def match(filename)
+        @pattern.match(filename.to_s)
+      end
+
+      # Convert pattern to string
+      #
+      # @return [String]
+      def to_s
+        @pattern.source
+      end
+
+      # Get the underlying regex
+      #
+      # @return [Regexp]
+      def to_regexp
+        @pattern
+      end
+    end
+  end
+end