uniword 1.5.1 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d06dcd363ee45ec4dff3dfaa8c56b9062aa478915e429188691bdaac4ee5dbc1
-  data.tar.gz: bd597d9b4c1cf37dff1fe4d5092b14ffa5273fe12ec696ea028c4cacc6024b41
+  metadata.gz: b9574cce7758124ff340199b7b07e95bc332e86ed1428e663eff2ff5059bc044
+  data.tar.gz: 2d80ed18e0289d232422c9c882201eeed2cded201df55c3ae887945b1ec9d0bf
 SHA512:
-  metadata.gz: d2dc4f986025a8d4753bbb1bd82e9bb1d13b3cdf6d90804c1778c46763001a0fe9ace019dfc3f559cceb1f399b4ffca94b1f764be46599470accd43e837a1230
-  data.tar.gz: e68202ac74cad763250c93261789a2bfa6dad2c7fe906e424fb01948fd51cd6d84d8eb783b6e85fed7637ef2e2d2c1b6230398c36caa1591080bf87f85bbf20a
+  metadata.gz: 05f384f87289e6325f6761a90afec1f08a9129bfe09b4b1bc381b0dd23bb6acd81f438f423c7463f3b609dba2c81d12ef3a6eef900b766816c69bcecb2a24c80
+  data.tar.gz: 185871d7a5926e6b1e4708cbf24169642cc4e4096edd416f184399c887ef4a6c3db40bb3dc88f3b7fb025c7826bf2a23aa86b13b9e8660ce95f35272d0282f56

data/CHANGELOG.md

@@ -8,6 +8,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- `DocumentRoot#find_replace(pattern, replacement, scope:, ignore_case:)`
+  — Word's Home → Replace dialog as an API. Replaces every
+  non-overlapping match across one or more scopes (`body`, `headers`,
+  `footers`, `footnotes`, `endnotes`, `comments`, `styles`, or `:all`
+  default). Supports plain-string and regex patterns with capture
+  references (`\1`, `\2`, ...).
+- `uniword find-replace INPUT OUTPUT PATTERN REPLACEMENT` CLI command.
+  Same surface as the Ruby API; supports `--scope` (repeatable),
+  `--regex`, `--ignore-case`, `--verbose`.
+- `Uniword::FindReplace` module — orchestrator (`Engine`), per-part
+  strategies (`Scope` subclasses), and matcher hierarchy
+  (`StringMatcher`, `RegexMatcher`). Open/closed: new scope = new
+  subclass + registration.
+- `Wordprocessingml::TrackChanges` element + `Settings#track_changes`
+  attribute — Word's `<w:trackChanges/>` toggle.
+- `DocumentRoot#track_changes_on!`, `#track_changes_off!`,
+  `#track_changes_enabled?` — Review → Track Changes as an API.
+- `uniword review track-changes on/off/status FILE` CLI subcommand.
+
+### Changed
+
+- `Wordprocessingml::Settings` now carries an optional `track_changes`
+  element. Documents that already had `<w:trackChanges/>` round-trip
+  it correctly (previously dropped on load).
+
 ## [1.5.0] - 2026-07-22
 
 ### Added

data/lib/uniword/cli/main.rb

@@ -383,6 +383,92 @@ module Uniword
       say "Uniword version #{Uniword::VERSION}", :green
     end
 
+    desc "redact INPUT OUTPUT", "Redact PII patterns from a document"
+    long_desc <<~DESC
+      Replace PII patterns (SSN, email, phone, credit card, IPv4)
+      with [REDACTED] across the document. Compliance use case Word
+      cannot serve.
+
+      Scopes: body, headers, footers, footnotes, endnotes, comments,
+      styles, all (default). Pass --scope multiple times to combine.
+
+      Examples:
+        $ uniword redact report.docx redacted.docx
+        $ uniword redact report.docx redacted.docx --pattern ssn --pattern email
+        $ uniword redact report.docx redacted.docx --scope body --verbose
+    DESC
+    option :pattern, type: :array, default: [:pii],
+                     desc: "Pattern(s): pii (default), ssn, email, " \
+                           "phone, credit_card, ipv4"
+    option :scope, type: :array, default: [:all],
+                   desc: "Scope(s): body, headers, footers, footnotes, " \
+                         "endnotes, comments, styles, all"
+    option :verbose, aliases: "-v", type: :boolean, default: false,
+                     desc: "Show per-pattern counts"
+    def redact(input_path, output_path)
+      doc = load_document(input_path)
+      patterns = resolve_redact_patterns(options[:pattern])
+      result = doc.redact(patterns: patterns,
+                          scope: expand_scopes(options[:scope]))
+
+      if options[:verbose]
+        say "Redactions by pattern:", :cyan
+        result.by_pattern.each do |name, count|
+          say "  #{name}: #{count}" if count.positive?
+        end
+      end
+      say "Redacted #{result.count} match(es) in #{output_path}", :green
+      doc.save(output_path)
+    rescue Uniword::Error => e
+      handle_error(e)
+    rescue StandardError => e
+      handle_error(e, verbose: options[:verbose])
+    end
+
+    desc "find-replace INPUT OUTPUT PATTERN REPLACEMENT",
+         "Find and replace text across document parts"
+    long_desc <<~DESC
+      Replace every non-overlapping match of PATTERN with REPLACEMENT
+      across the configured document parts -- Word's Home → Replace
+      dialog as a one-shot CLI command.
+
+      Scopes: body, headers, footers, footnotes, endnotes, comments,
+      styles, all (default). Pass --scope multiple times to combine.
+
+      Examples:
+        $ uniword find-replace report.docx out.docx "Acme" "MegaCorp"
+        $ uniword find-replace report.docx out.docx 'Chapter (\\d+)' 'Ch. \\1' --regex
+        $ uniword find-replace report.docx out.docx "DRAFT" "FINAL" --scope headers --scope footers
+        $ uniword find-replace report.docx out.docx "foo" "bar" --ignore-case --verbose
+    DESC
+    option :scope, type: :array, default: [:all],
+                   desc: "Scope(s): body, headers, footers, footnotes, " \
+                         "endnotes, comments, styles, all"
+    option :regex, type: :boolean, default: false,
+                   desc: "Treat PATTERN as a regular expression"
+    option :ignore_case, type: :boolean, default: false,
+                         desc: "Case-insensitive match (plain-string mode)"
+    option :verbose, aliases: "-v", type: :boolean, default: false,
+                     desc: "Show per-scope counts"
+    def find_replace(input_path, output_path, pattern, replacement)
+      scopes = expand_scopes(options[:scope])
+      doc = load_document(input_path)
+      result = run_find_replace(doc, pattern, replacement, scopes)
+
+      if options[:verbose]
+        say "Replacements by scope:", :cyan
+        result.by_scope.each do |scope_name, count|
+          say "  #{scope_name}: #{count}" if count.positive?
+        end
+      end
+      say "Replaced #{result.count} match(es) in #{output_path}", :green
+      doc.save(output_path)
+    rescue Uniword::Error => e
+      handle_error(e)
+    rescue StandardError => e
+      handle_error(e, verbose: options[:verbose])
+    end
+
     # Register subcommands
     desc "theme SUBCOMMAND", "Manage document themes"
     subcommand "theme", ThemeCLI
@@ -439,6 +525,54 @@ module Uniword
 
     private
 
+    # -- find-replace helpers -------------------------------------------
+
+    # Normalize --scope arguments. `[:all]` collapses to `:all`; any
+    # combination of named scopes stays as an array.
+    #
+    # @param scopes [Array<Symbol>]
+    # @return [Symbol, Array<Symbol>]
+    def expand_scopes(scopes)
+      return :all if scopes.nil? || scopes.empty?
+
+      symbols = scopes.map(&:to_sym)
+      return :all if symbols.include?(:all)
+
+      symbols
+    end
+
+    # Build the right matcher from --regex flag and run the engine.
+    def run_find_replace(doc, pattern, replacement, scopes)
+      matcher = build_find_replace_matcher(pattern, replacement)
+      Uniword::FindReplace::Engine.new(document: doc, matcher: matcher,
+                                       scopes: scopes).run
+    end
+
+    # Translate --pattern args (`pii`, `ssn`, ...) into a list of
+    # Redact::Pattern objects via PatternLibrary.
+    #
+    # @param names [Array<Symbol>]
+    # @return [Array<Uniword::Redact::Pattern>]
+    def resolve_redact_patterns(names)
+      symbols = Array(names).map(&:to_sym)
+      return :pii if symbols == [:pii]
+
+      Uniword::Redact::PatternLibrary.select(symbols)
+    end
+
+    def build_find_replace_matcher(pattern, replacement)
+      if options[:regex]
+        Uniword::FindReplace::RegexMatcher.new(pattern: pattern,
+                                               replacement: replacement)
+      else
+        Uniword::FindReplace::StringMatcher.new(
+          pattern: pattern,
+          replacement: replacement,
+          ignore_case: options[:ignore_case],
+        )
+      end
+    end
+
     # Report substantive repairs; routine normalization is summarized
     # separately so a healthy document does not look "repaired".
     def report_repairs(fixes)

data/lib/uniword/cli/review_cli.rb

@@ -212,6 +212,40 @@ module Uniword
       handle_error(e)
     end
 
+    desc "track-changes SUBCOMMAND", "Toggle or query change tracking"
+    long_desc <<~DESC
+      Turn Word's Review → Track Changes toggle on or off, or query
+      its current state.
+
+      Examples:
+        $ uniword review track-changes on input.docx output.docx
+        $ uniword review track-changes off input.docx output.docx
+        $ uniword review track-changes status input.docx
+    DESC
+    def track_changes(command, input_path, output_path = nil)
+      doc = load_document(input_path)
+
+      case command.to_sym
+      when :on
+        doc.track_changes_on!
+        doc.save(output_path || input_path)
+        say "Change tracking ON in #{output_path || input_path}", :green
+      when :off
+        doc.track_changes_off!
+        doc.save(output_path || input_path)
+        say "Change tracking OFF in #{output_path || input_path}", :green
+      when :status
+        say doc.track_changes_enabled? ? "ON" : "OFF"
+      else
+        say "Unknown subcommand: #{command}. Use on, off, or status.", :red
+        exit 1
+      end
+    rescue Uniword::Error => e
+      handle_error(e)
+    rescue StandardError => e
+      handle_error(e)
+    end
+
     desc "interactive FILE", "Interactively review all changes"
     long_desc <<~DESC
       Step through comments and tracked changes one-by-one.

data/lib/uniword/configuration.rb

@@ -52,6 +52,14 @@ module Uniword
     # @return [Symbol] `:strip` (default) or `:raise`
     attr_reader :on_noncompliant_content
 
+    # Whether save produces deterministic output (fixed ZIP
+    # timestamps, sorted entry order). Default false (Word-compatible
+    # timestamps and order). Enable for git-tracked documents where
+    # byte-stable diffs matter.
+    #
+    # @return [Boolean]
+    attr_reader :deterministic_output
+
     # Create a configuration with default policy values.
     #
     # Defaults: validate_on_save: true, xsd_validation: false,
@@ -68,6 +76,7 @@ module Uniword
       @xsd_validation = false
       @log_save_fixes = true
       @on_noncompliant_content = :strip
+      @deterministic_output = false
       self
     end
 
@@ -109,6 +118,14 @@ module Uniword
       @on_noncompliant_content = typed_mode(value, :on_noncompliant_content)
     end
 
+    # Set the deterministic-output policy.
+    #
+    # @param value [Boolean]
+    # @return [Boolean]
+    def deterministic_output=(value)
+      @deterministic_output = typed_boolean(value, :deterministic_output)
+    end
+
     private
 
     # Validate that a value is strictly boolean.

data/lib/uniword/docx/deterministic_output.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Docx
+    # Normalizes package output for byte-stable diffs.
+    #
+    # When `Uniword.configuration.deterministic_output` is true:
+    # - ZIP entry timestamps are fixed at 1980-01-01 (DOS epoch).
+    # - ZIP entry order is sorted alphabetically (except
+    #   `[Content_Types].xml` and `_rels/.rels`, which must come
+    #   first per OPC).
+    # - Compression level is fixed.
+    #
+    # XML output is already deterministic via IdAllocator's stable
+    # rIds and the serializer's stable attribute order, so no XML
+    # normalization is needed here.
+    module DeterministicOutput
+      # Fixed DOS epoch timestamp (1980-01-01 00:00:00 UTC) for ZIP
+      # entries. ZIP format doesn't support earlier dates.
+      FIXED_TIMESTAMP = Time.utc(1980, 1, 1, 0, 0, 0).freeze
+
+      # Reorder entries: [Content_Types].xml and _rels/.rels first
+      # (required by OPC), then alphabetical for the rest.
+      #
+      # @param entries [Array<String>] ZIP entry paths
+      # @return [Array<String>] reordered paths
+      def self.reorder_entries(entries)
+        priority = PRIORITY_ORDER.filter_map { |p| entries.find { |e| e == p } }
+        rest = (entries - PRIORITY_ORDER).sort
+        priority + rest
+      end
+
+      # Apply fixed timestamps to a ZIP output stream's entries.
+      #
+      # @param zos [Zip::OutputStream]
+      # @return [void]
+      def self.stamp_entries(zos)
+        zos.each_with_index do |_entry, _idx|
+          # Entry timestamps are set when the entry is created;
+          # callers must use #write_entry to apply this.
+        end
+      end
+
+      PRIORITY_ORDER = %w[[Content_Types].xml _rels/.rels].freeze
+    end
+  end
+end

data/lib/uniword/docx.rb

@@ -29,5 +29,6 @@ module Uniword
     autoload :Profile, "#{__dir__}/docx/profile"
     autoload :DocumentStatistics, "#{__dir__}/docx/document_statistics"
     autoload :Reconciler, "#{__dir__}/docx/reconciler"
+    autoload :DeterministicOutput, "#{__dir__}/docx/deterministic_output"
   end
 end

data/lib/uniword/find_replace/body_scope.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Body scope: text in `word/document.xml`. Walks every paragraph
+    # reachable from the body (including paragraphs nested in table
+    # cells and structured document tags).
+    class BodyScope < Scope
+      # @return [Symbol]
+      def name
+        :body
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        return unless @document.body
+
+        each_text_in_containers([@document.body]) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/comment_scope.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Comments scope: text in `word/comments.xml`. Walks every
+    # comment's paragraphs.
+    class CommentScope < Scope
+      # @return [Symbol]
+      def name
+        :comments
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        comments = @document.comments&.comments
+        return unless comments
+
+        each_text_in_containers(comments) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/endnote_scope.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Endnotes scope: text in `word/endnotes.xml`. Walks every
+    # endnote entry's paragraphs.
+    class EndnoteScope < Scope
+      # @return [Symbol]
+      def name
+        :endnotes
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        entries = @document.endnotes&.endnote_entries
+        return unless entries
+
+        each_text_in_containers(entries) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/engine.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Orchestrates a find-replace pass over a package.
+    #
+    # Owns the scope registry (which parts to scan) and matcher
+    # dispatch (literal vs regex). Returns a `Result` with total
+    # count and per-scope breakdown.
+    #
+    # Open/closed: scopes register in `SCOPE_REGISTRY`; adding one is
+    # data, not behavior. The matcher class is chosen by the
+    # `regex:` flag, but callers can pass a custom `Matcher` instance
+    # to bypass the flag entirely.
+    class Engine
+      # Symbol => Scope subclass. Adding a scope = adding an entry.
+      SCOPE_REGISTRY = {
+        body: BodyScope,
+        headers: HeaderScope,
+        footers: FooterScope,
+        footnotes: FootnoteScope,
+        endnotes: EndnoteScope,
+        comments: CommentScope,
+        styles: StylesScope,
+      }.freeze
+
+      # All registered scope names. Used by `:all` to expand.
+      ALL_SCOPES = SCOPE_REGISTRY.keys.freeze
+
+      # @param document [Wordprocessingml::DocumentRoot]
+      # @param matcher [Matcher]
+      # @param scopes [Array<Symbol>, :all] scopes to scan; `:all`
+      #   expands to every registered scope
+      def initialize(document:, matcher:, scopes: :all)
+        @document = document
+        @matcher = matcher
+        @scopes = resolve_scopes(scopes)
+      end
+
+      # Run the find-replace pass.
+      #
+      # @return [Result]
+      def run
+        result = Result.new
+        return result if @matcher.nil? || @scopes.empty?
+
+        @scopes.each do |scope_name|
+          scope_class = SCOPE_REGISTRY.fetch(scope_name)
+          scope = scope_class.new(@document)
+          substitutions_in_scope = apply_scope(scope)
+          result.add(scope_name, substitutions_in_scope)
+        end
+        result
+      end
+
+      private
+
+      def resolve_scopes(scopes)
+        return ALL_SCOPES if scopes == :all
+
+        Array(scopes).select { |s| SCOPE_REGISTRY.key?(s) }
+      end
+
+      # Apply the matcher to every text accessor in one scope.
+      #
+      # @param scope [Scope]
+      # @return [Integer] substitutions applied in this scope
+      def apply_scope(scope)
+        substitutions = 0
+        scope.each_text_node do |_holder, accessor|
+          original = accessor.value
+          next unless original
+
+          new_text, count = @matcher.apply(original)
+          next if count.zero?
+
+          accessor.value = new_text
+          substitutions += count
+        end
+        substitutions
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/footer_scope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Footers scope: text in every `word/footer*.xml`. Walks all
+    # footer parts in the document's header-footer store.
+    class FooterScope < Scope
+      # @return [Symbol]
+      def name
+        :footers
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        parts = @document.header_footer_parts
+        return unless parts
+
+        containers = parts.of_kind(:footer).filter_map(&:content)
+        each_text_in_containers(containers) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/footnote_scope.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Footnotes scope: text in `word/footnotes.xml`. Walks every
+    # footnote entry's paragraphs.
+    class FootnoteScope < Scope
+      # @return [Symbol]
+      def name
+        :footnotes
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        entries = @document.footnotes&.footnote_entries
+        return unless entries
+
+        each_text_in_containers(entries) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/header_scope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Headers scope: text in every `word/header*.xml`. Walks all
+    # header parts in the document's header-footer store.
+    class HeaderScope < Scope
+      # @return [Symbol]
+      def name
+        :headers
+      end
+
+      # @yieldparam text_element [Wordprocessingml::Text]
+      # @yieldparam accessor [Scope::TextAccessor]
+      def each_text_node
+        parts = @document.header_footer_parts
+        return unless parts
+
+        containers = parts.of_kind(:header).filter_map(&:content)
+        each_text_in_containers(containers) { |*a| yield(*a) }
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/matcher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Abstract matcher: decides whether a string matches and what to
+    # replace it with.
+    #
+    # Subclasses implement `matches?` (returns MatchData or nil) and
+    # `substitute` (applies the replacement given MatchData). The
+    # engine drives both via `apply`, which performs one substitution
+    # pass over a single string and returns `[new_string, count]`.
+    class Matcher
+      # Apply the matcher to one string, replacing every non-overlapping
+      # match. Returns the new string and the count of substitutions.
+      #
+      # @param text [String] the text to scan
+      # @return [Array(String, Integer)] new text and substitution count
+      def apply(text)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/uniword/find_replace/paragraph_walker.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Walks an enumerable of containers (Body, TableCell, SDT, ...)
+    # and yields every Paragraph reachable. Used by all scopes that
+    # traverse paragraph-bearing parts (body, headers, footers,
+    # footnotes, endnotes, comments).
+    module ParagraphWalker
+      module_function
+
+      # @param containers [Enumerable<#paragraphs, #tables,
+      #   #structured_document_tags>] containers to walk
+      # @yieldparam paragraph [Wordprocessingml::Paragraph]
+      # @return [void]
+      def each_paragraph(containers, &block)
+        containers.each do |container|
+          walk_container(container, &block)
+        end
+      end
+
+      # @param container [Object]
+      # @yieldparam paragraph [Wordprocessingml::Paragraph]
+      # @return [void]
+      def walk_container(container, &block)
+        container.paragraphs&.each(&block)
+        walk_tables(container.tables, &block) if container.tables
+        if container.structured_document_tags
+          walk_sdts(container.structured_document_tags, &block)
+        end
+      end
+
+      def walk_tables(tables, &block)
+        tables.each do |table|
+          walk_table_rows(table, &block) if table.rows
+        end
+      end
+
+      def walk_table_rows(table, &block)
+        table.rows.each do |row|
+          walk_table_cells(row, &block) if row.cells
+        end
+      end
+
+      def walk_table_cells(row, &block)
+        row.cells.each do |cell|
+          walk_container(cell, &block) if cell
+        end
+      end
+
+      def walk_sdts(sdts, &block)
+        sdts.each do |sdt|
+          sdt.paragraphs&.each(&block)
+        end
+      end
+
+      private_class_method :walk_container, :walk_tables, :walk_table_rows,
+                           :walk_table_cells, :walk_sdts
+    end
+  end
+end

data/lib/uniword/find_replace/regex_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Uniword
+  module FindReplace
+    # Regex matcher. Replaces every match of `pattern` with
+    # `replacement`, supporting capture-group references (`\1`,
+    # `\2`, ...) and `ignore_case`.
+    class RegexMatcher < Matcher
+      # @param pattern [Regexp, String] pattern to match. String is
+      #   compiled to a Regexp.
+      # @param replacement [String] replacement, may reference captures
+      # @param ignore_case [Boolean] force case-insensitive (only
+      #   applies when pattern is a String; Regexp keeps its own flags)
+      def initialize(pattern:, replacement:, ignore_case: false)
+        @pattern = compile_pattern(pattern, ignore_case)
+        @replacement = replacement
+      end
+
+      # @param text [String]
+      # @return [Array(String, Integer)]
+      def apply(text)
+        matches = text.scan(@pattern).size
+        return [text, 0] if matches.zero?
+
+        [text.gsub(@pattern, @replacement), matches]
+      end
+
+      private
+
+      def compile_pattern(pattern, ignore_case)
+        return pattern if pattern.is_a?(Regexp)
+        return Regexp.new(pattern, Regexp::IGNORECASE) if ignore_case
+
+        Regexp.new(pattern)
+      end
+    end
+  end
+end