top_secret 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ca966ae09c911bbffe556c5a4d043b5d57d344ec7169fa2fdd853b8daefe407
-  data.tar.gz: f2f931cbf81c0df4165b0431d6b680d8f1316454052e38d4e3bca903fab55459
+  metadata.gz: cef5c9c267dd71870fd244408a3f9a020d19978381810f99e7ed5defc67f12a7
+  data.tar.gz: ec20793792721a47371cc6a7cf3c687ad4284b9c9f1f9b14c57e002118c5532a
 SHA512:
-  metadata.gz: a77cf5529144525965ff471b2d12bd980f01e21b72714b04894e186120570e54828d1b2c08738d5c779a2e560e6f05a9642d43e4047e48c4aa3a7fe938c1bfb4
-  data.tar.gz: ba347a50b9cf63a88ea6f7b98e56e713330d38e5341a00a792eb180c965b23c9bf822cafa5d28aa832e9810f5da6455f6065d7af50a9257597bb5afbaf4a32ac
+  metadata.gz: 0eea9a1087e5082e245b73cdbb434543dbfcff277b6d58b7a89e463b1162215e0058f5190df3863a73fd32223fdf42fa65a253781193ea7e44ecc6b68c359e45
+  data.tar.gz: 6626056578ec3feecf27d843a994f782c144b363a6b7473e6e0be0fa80044c2283c329ae068c4f0f66af13f021743039864e13f220174489bd822e0c162872a7

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-09-19
+
+### Added
+
+-   Added `TopSecret::Text.scan` method for detecting sensitive information without redacting text
+-   Added `TopSecret::Text::ScanResult` class to hold scan operation results with `mapping` and `sensitive?` methods
+-   Added `TopSecret::Text::GlobalMapping` class to manage consistent labeling across multiple filtering operations
+-   Added factory methods to domain objects: `BatchResult.from_messages`, `Result.from_messages`, and `Result.with_global_labels`
+-   Added support for disabling NER filtering by setting `model_path` to `nil` for improved performance and deployment flexibility
+-   Added support for Rails 7.0 and newer
+-   Added `#safe?` predicate method as the logical opposite of `#sensitive?` for `BatchResult`, `Result` and `ScanResult` classes
+
+### Changed
+
+-   **BREAKING:** `TopSecret::Text.filter_all` now returns `TopSecret::Text::Result` objects instead of `TopSecret::Text::BatchResult::Item` objects for individual items
+-   Each item in `BatchResult#items` now includes an individual `mapping` attribute containing only the sensitive information found in that specific message
+-   `TopSecret::Text.filter_all` now only processes sensitive results when building global mappings, improving efficiency
+-   Refactored `TopSecret::Text.filter_all` to use domain objects with better separation of concerns and testability
+-   Improved performance by implementing lazy loading of MITIE model and document processing
+-   NER filtering now gracefully falls back when MITIE model is unavailable, continuing with regex-based filters only
+
+## [0.2.0] - 2025-08-18
+
+### Added
+
+-   Added `TopSecret::Text.filter_all` for batch processing multiple messages with globally consistent redaction labels
+-   Added `TopSecret::Text::BatchResult` class to hold results from batch operations
+-   Added `TopSecret::FilteredText` class for restoring filtered text by substituting placeholders with original values
+-   Added `TopSecret::FilteredText::Result` class to track restoration success and failures
+
+### Changed
+
+-   **BREAKING:** Moved `TopSecret::Result` to `TopSecret::Text::Result` and `TopSecret::BatchResult` to `TopSecret::Text::BatchResult` for better namespace organization
+-   **BREAKING:** Refactored configuration system to use individual filter accessors instead of nested `default_filters`
+-   Updated `TopSecret::Text.filter` to accept keyword arguments for filter overrides and `custom_filters` array
+-   Each default filter now has its own configuration accessor (e.g., `TopSecret.email_filter`, `TopSecret.people_filter`)
+
+### Migration Guide
+
+-   Replace `TopSecret::Result` with `TopSecret::Text::Result` and `TopSecret::BatchResult` with `TopSecret::Text::BatchResult`
+-   Replace `TopSecret.configure { |c| c.default_filters.email_filter = filter }` with `TopSecret.configure { |c| c.email_filter = filter }`
+-   Replace `TopSecret::Text.filter(text, filters: { email_filter: filter })` with `TopSecret::Text.filter(text, email_filter: filter)`
+-   For new filters, use `TopSecret::Text.filter(text, custom_filters: [filter])` instead of adding to `default_filters`
+
 ## [0.1.1] - 2025-08-08
 
 -   Ensure `TopSecret.min_confidence_score` is respected

data/CODEOWNERS

@@ -0,0 +1,15 @@
+# Lines starting with '#' are comments.
+# Each line is a file pattern followed by one or more owners.
+
+# More details are here: https://help.github.com/articles/about-codeowners/
+
+# The '*' pattern is global owners.
+
+# Order is important. The last matching pattern has the most precedence.
+# The folders are ordered as follows:
+
+# In each subsection folders are ordered first by depth, then alphabetically.
+# This should make it easy to add new rules without breaking existing ones.
+
+# Global rule:
+* @stevepolitodesign

data/README.md

@@ -1,6 +1,8 @@
 # Top Secret
 
-Filter sensitive information from free text before sending it to external services or APIs, such as Chatbots.
+[![Ruby](https://github.com/thoughtbot/top_secret/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/thoughtbot/top_secret/actions/workflows/main.yml)
+
+Filter sensitive information from free text before sending it to external services or APIs, such as chatbots and LLMs.
 
 By default it filters the following:
 
@@ -32,6 +34,13 @@ gem install top_secret
 >
 > You'll need to download and extract [ner_model.dat][] first.
 
+> [!TIP]
+> Due to its large size, you'll likely want to avoid committing [ner_model.dat][] into version control.
+>
+> You'll need to ensure the file exists in deployed environments. See relevant [discussion][discussions_60] for details.
+>
+> Alternatively, you can disable NER filtering entirely by setting `model_path` to `nil` if you only need regex-based filters (credit cards, emails, phone numbers, SSNs). This improves performance and eliminates the model file dependency.
+
 By default, Top Secret assumes the file will live at the root of your project, but this can be configured.
 
 ```ruby
@@ -123,7 +132,7 @@ TopSecret::Text.filter("Ralph can be reached at ralph@thoughtbot.com")
 This will return
 
 ```ruby
-<TopSecret::Result
+<TopSecret::Text::Result
   @input="Ralph can be reached at ralph@thoughtbot.com",
   @mapping={:EMAIL_1=>"ralph@thoughtbot.com", :PERSON_1=>"Ralph"},
   @output="[PERSON_1] can be reached at [EMAIL_1]"
@@ -154,26 +163,264 @@ result.mapping
 # => {:EMAIL_1=>"ralph@thoughtbot.com", :PERSON_1=>"Ralph"}
 ```
 
+Check if sensitive information was found
+
+```ruby
+result.sensitive?
+
+# => true
+
+result.safe?
+
+# => false
+```
+
+### Scanning for Sensitive Information
+
+Use `TopSecret::Text.scan` to detect sensitive information without redacting the text. This is useful when you only need to check if sensitive data exists or get a mapping of what was found:
+
+```ruby
+TopSecret::Text.scan("Ralph can be reached at ralph@thoughtbot.com")
+```
+
+This will return
+
+```ruby
+<TopSecret::Text::ScanResult
+  @mapping={:EMAIL_1=>"ralph@thoughtbot.com", :PERSON_1=>"Ralph"}
+>
+```
+
+Check if sensitive information was found
+
+```ruby
+result.sensitive?
+
+# => true
+
+result.safe?
+
+# => false
+```
+
+View the mapping of found sensitive information
+
+```ruby
+result.mapping
+
+# => {:EMAIL_1=>"ralph@thoughtbot.com", :PERSON_1=>"Ralph"}
+```
+
+The `scan` method accepts the same filter options as `filter`:
+
+```ruby
+# Override default filters
+email_filter =  TopSecret::Filters::Regex.new(
+  label: "EMAIL_ADDRESS",
+  regex: /\w+\[at\]\w+\.\w+/
+)
+result = TopSecret::Text.scan("Contact user[at]example.com", email_filter:)
+result.mapping
+# => {:EMAIL_ADDRESS_1=>"user[at]example.com"}
+
+# Disable specific filters
+result = TopSecret::Text.scan("Ralph works in Boston", people_filter: nil)
+result.mapping
+# => {:LOCATION_1=>"Boston"}
+
+# Add custom filters
+ip_filter = TopSecret::Filters::Regex.new(
+  label: "IP_ADDRESS",
+  regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
+)
+result = TopSecret::Text.scan("Server IP is 192.168.1.1", custom_filters: [ip_filter])
+result.mapping
+# => {:IP_ADDRESS_1=>"192.168.1.1"}
+```
+
+### Batch Processing
+
+When processing multiple messages, use `filter_all` to ensure consistent redaction labels across all messages:
+
+```ruby
+messages = [
+  "Contact ralph@thoughtbot.com for details",
+  "Email ralph@thoughtbot.com again if needed",
+  "Also CC ruby@thoughtbot.com on the thread"
+]
+
+result = TopSecret::Text.filter_all(messages)
+```
+
+This will return
+
+```ruby
+<TopSecret::Text::BatchResult
+  @mapping={:EMAIL_1=>"ralph@thoughtbot.com", :EMAIL_2=>"ruby@thoughtbot.com"},
+  @items=[
+    <TopSecret::Text::Result @input="Contact ralph@thoughtbot.com for details", @output="Contact [EMAIL_1] for details", @mapping={:EMAIL_1=>"ralph@thoughtbot.com"}>,
+    <TopSecret::Text::Result @input="Email ralph@thoughtbot.com again if needed", @output="Email [EMAIL_1] again if needed", @mapping={:EMAIL_1=>"ralph@thoughtbot.com"}>,
+    <TopSecret::Text::Result @input="Also CC ruby@thoughtbot.com on the thread", @output="Also CC [EMAIL_2] on the thread", @mapping={:EMAIL_2=>"ruby@thoughtbot.com"}>
+  ]
+>
+```
+
+Access the global mapping
+
+```ruby
+result.mapping
+
+# => {:EMAIL_1=>"ralph@thoughtbot.com", :EMAIL_2=>"ruby@thoughtbot.com"}
+```
+
+Access individual items
+
+```ruby
+result.items[0].input
+# => "Contact ralph@thoughtbot.com for details"
+
+result.items[0].output
+# => "Contact [EMAIL_1] for details"
+
+result.items[0].mapping
+# => {:EMAIL_1=>"ralph@thoughtbot.com"}
+
+result.items[0].sensitive?
+# => true
+
+result.items[0].safe?
+# => false
+```
+
+The key benefit is that identical values receive the same labels across all messages - notice how `ralph@thoughtbot.com` becomes `[EMAIL_1]` in both the first and second messages.
+
+Each item also maintains its own mapping containing only the sensitive information found in that specific message, while the batch result provides a global mapping of all sensitive information across all messages.
+
+### Restoring Filtered Text
+
+When external services (like LLMs) return responses containing filter placeholders, use `TopSecret::FilteredText.restore` to substitute them back with original values:
+
+```ruby
+# Filter messages before sending to LLM
+messages = ["Contact ralph@thoughtbot.com for details"]
+batch_result = TopSecret::Text.filter_all(messages)
+
+# Send filtered text to LLM: "Contact [EMAIL_1] for details"
+# LLM responds with: "I'll email [EMAIL_1] about this request"
+llm_response = "I'll email [EMAIL_1] about this request"
+
+# Restore the original values
+restore_result = TopSecret::FilteredText.restore(llm_response, mapping: batch_result.mapping)
+```
+
+This will return
+
+```ruby
+<TopSecret::FilteredText::Result
+  @output="I'll email ralph@thoughtbot.com about this request",
+  @restored=["[EMAIL_1]"],
+  @unrestored=[]
+>
+```
+
+Access the restored text
+
+```ruby
+restore_result.output
+# => "I'll email ralph@thoughtbot.com about this request"
+```
+
+Track which placeholders were restored
+
+```ruby
+restore_result.restored
+# => ["[EMAIL_1]"]
+
+restore_result.unrestored
+# => []
+```
+
+The restoration process tracks both successful and failed placeholder substitutions, allowing you to handle cases where the LLM response contains placeholders not found in your mapping.
+
+### Working with LLMs
+
+When sending filtered information to LLMs, they'll likely need to be instructed on how to handle those filters. Otherwise, we risk them not being returned in the response, which would break the restoration process.
+
+Here's a recommended approach:
+
+```ruby
+instructions = <<~TEXT
+  I'm going to send filtered information to you in the form of free text.
+  If you need to refer to the filtered information in a response, just reference it by the filter.
+TEXT
+```
+
+Complete example:
+
+```ruby
+require "openai"
+require "top_secret"
+
+openai = OpenAI::Client.new(
+  api_key: Rails.application.credentials.openai.api_key!
+)
+
+original_messages = [
+  "Ralph lives in Boston.",
+  "You can reach them at ralph@thoughtbot.com or 877-976-2687"
+]
+
+# Filter all messages
+result = TopSecret::Text.filter_all(original_messages)
+filtered_messages = result.items.map(&:output)
+
+user_messages = filtered_messages.map { {role: "user", content: it} }
+
+# Instruct LLM how to handle filtered messages
+instructions = <<~TEXT
+  I'm going to send filtered information to you in the form of free text.
+  If you need to refer to the filtered information in a response, just reference it by the filter.
+TEXT
+
+messages = [
+  {role: "system", content: instructions},
+  *user_messages
+]
+
+chat_completion = openai.chat.completions.create(messages:, model: :"gpt-5")
+response = chat_completion.choices.last.message.content
+
+# Restore the response from the mapping
+mapping = result.mapping
+restored_response = TopSecret::FilteredText.restore(response, mapping:).output
+
+puts(restored_response)
+```
+
 ### Advanced Examples
 
 #### Overriding the default filters
 
 When overriding or [disabling](#disabling-a-default-filter-1) a [default filter](#default-filters), you must map to the correct key.
 
+> [!IMPORTANT]
+> Invalid filter keys will raise an `ArgumentError`. Only the following keys are valid:
+> `credit_card_filter`, `email_filter`, `phone_number_filter`, `ssn_filter`, `people_filter`, `location_filter`
+
 ```ruby
 regex_filter = TopSecret::Filters::Regex.new(label: "EMAIL_ADDRESS", regex: /\b\w+\[at\]\w+\.\w+\b/)
 ner_filter = TopSecret::Filters::NER.new(label: "NAME", tag: :person, min_confidence_score: 0.25)
 
-TopSecret::Text.filter("Ralph can be reached at ralph[at]thoughtbot.com", filters: {
+TopSecret::Text.filter("Ralph can be reached at ralph[at]thoughtbot.com",
   email_filter: regex_filter,
   people_filter: ner_filter
-})
+)
 ```
 
 This will return
 
 ```ruby
-<TopSecret::Result
+<TopSecret::Text::Result
   @input="Ralph can be reached at ralph[at]thoughtbot.com",
   @mapping={:EMAIL_ADDRESS_1=>"ralph[at]thoughtbot.com", :NAME_1=>"Ralph", :NAME_2=>"ralph["},
   @output="[NAME_1] can be reached at [EMAIL_ADDRESS_1]"
@@ -183,22 +430,29 @@ This will return
 #### Disabling a default filter
 
 ```ruby
-TopSecret::Text.filter("Ralph can be reached at ralph@thoughtbot.com", filters: {
+TopSecret::Text.filter("Ralph can be reached at ralph@thoughtbot.com",
   email_filter: nil,
   people_filter: nil
-})
+)
 ```
 
 This will return
 
 ```ruby
-<TopSecret::Result
+<TopSecret::Text::Result
   @input="Ralph can be reached at ralph@thoughtbot.com",
   @mapping={},
   @output="Ralph can be reached at ralph@thoughtbot.com"
 >
 ```
 
+#### Error handling for invalid filter keys
+
+```ruby
+# This will raise ArgumentError: Unknown key: :invalid_filter. Valid keys are: ...
+TopSecret::Text.filter("some text", invalid_filter: some_filter)
+```
+
 ### Custom Filters
 
 #### Adding new [Regex filters][]
@@ -209,15 +463,15 @@ ip_address_filter = TopSecret::Filters::Regex.new(
   regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
 )
 
-TopSecret::Text.filter("Ralph's IP address is 192.168.1.1", filters: {
-  ip_address_filter: ip_address_filter
-})
+TopSecret::Text.filter("Ralph's IP address is 192.168.1.1",
+  custom_filters: [ip_address_filter]
+)
 ```
 
 This will return
 
 ```ruby
-<TopSecret::Result
+<TopSecret::Text::Result
   @input="Ralph's IP address is 192.168.1.1",
   @mapping={:PERSON_1=>"Ralph", :IP_ADDRESS_1=>"192.168.1.1"},
   @output="[PERSON_1]'s IP address is [IP_ADDRESS_1]"
@@ -235,15 +489,15 @@ language_filter = TopSecret::Filters::NER.new(
   min_confidence_score: 0.75
 )
 
-TopSecret::Text.filter("Ralph's favorite programming language is Ruby.", filters: {
-  language_filter: language_filter
-})
+TopSecret::Text.filter("Ralph's favorite programming language is Ruby.",
+  custom_filters: [language_filter]
+)
 ```
 
 This will return
 
 ```ruby
-<TopSecret::Result
+<TopSecret::Text::Result
   @input="Ralph's favorite programming language is Ruby.",
   @mapping={:PERSON_1=>"Ralph", :LANGUAGE_1=>"Ruby"},
   @output="[PERSON_1]'s favorite programming language is [LANGUAGE_1]"
@@ -265,9 +519,9 @@ regex_filter = TopSecret::Filters::Regex.new(
   regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
 )
 
-result = TopSecret::Text.filter("Server IP: 192.168.1.1", filters: {
-  ip_address_filter: regex_filter
-})
+result = TopSecret::Text.filter("Server IP: 192.168.1.1",
+  custom_filters: [regex_filter]
+)
 
 result.output
 # => "Server IP: [IP_ADDRESS_1]"
@@ -285,9 +539,9 @@ ner_filter = TopSecret::Filters::NER.new(
   min_confidence_score: 0.25
 )
 
-result = TopSecret::Text.filter("Ralph and Ruby work at thoughtbot.", filters: {
+result = TopSecret::Text.filter("Ralph and Ruby work at thoughtbot.",
   people_filter: ner_filter
-})
+)
 
 result.output
 # => "[PERSON_1] and [PERSON_2] work at thoughtbot."
@@ -314,6 +568,22 @@ TopSecret.configure do |config|
 end
 ```
 
+### Disabling NER filtering
+
+For improved performance or when the MITIE model file cannot be deployed, you can disable NER-based filtering entirely. This will disable people and location detection but retain all regex-based filters (credit cards, emails, phone numbers, SSNs):
+
+```ruby
+TopSecret.configure do |config|
+  config.model_path = nil
+end
+```
+
+This is useful in environments where:
+
+-   The model file cannot be deployed due to size constraints
+-   You only need regex-based filtering
+-   You want to optimize for performance over NER capabilities
+
 ### Overriding the confidence score
 
 ```ruby
@@ -326,7 +596,7 @@ end
 
 ```ruby
 TopSecret.configure do |config|
-  config.default_filters.email_filter = TopSecret::Filters::Regex.new(
+  config.email_filter = TopSecret::Filters::Regex.new(
     label: "EMAIL_ADDRESS",
     regex: /\b\w+\[at\]\w+\.\w+\b/
   )
@@ -337,18 +607,20 @@ end
 
 ```ruby
 TopSecret.configure do |config|
-  config.default_filters.email_filter = nil
+  config.email_filter = nil
 end
 ```
 
-### Adding new default filters
+### Adding custom filters globally
 
 ```ruby
+ip_address_filter = TopSecret::Filters::Regex.new(
+  label: "IP_ADDRESS",
+  regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
+)
+
 TopSecret.configure do |config|
-  config.default_filters.ip_address_filter = TopSecret::Filters::Regex.new(
-    label: "IP_ADDRESS",
-    regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/
-  )
+  config.custom_filters << ip_address_filter
 end
 ```
 
@@ -361,11 +633,26 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 >
 > You'll need to download and extract [ner_model.dat][] first, and place it in the root of this project.
 
+### Performance Benchmarks
+
+Run `bin/benchmark` to test performance and catch regressions:
+
+```bash
+bin/benchmark  # CI-optimized benchmark with pass/fail thresholds
+```
+
+> [!NOTE]
+> When adding new public methods to the API, ensure they are included in the benchmark script to catch performance regressions.
+
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [https://github.com/thoughtbot/top_secret](https://github.com/thoughtbot/top_secret). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/thoughtbot/top_secret/blob/main/CODE_OF_CONDUCT.md).
+[Bug reports](https://github.com/thoughtbot/top_secret/issues/new?template=bug_report.md) and [pull requests](https://github.com/thoughtbot/top_secret/pulls) are welcome on GitHub at [https://github.com/thoughtbot/top_secret](https://github.com/thoughtbot/top_secret).
+
+Please create a [new discussion](https://github.com/thoughtbot/top_secret/discussions/new?category=ideas) if you want to share ideas for new features.
+
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/thoughtbot/top_secret/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -400,3 +687,4 @@ We are [available for hire][hire].
 [train]: https://github.com/ankane/mitie-ruby?tab=readme-ov-file#training
 [Regex filters]: https://github.com/thoughtbot/top_secret/blob/main/lib/top_secret/filters/regex.rb
 [NER filters]: https://github.com/thoughtbot/top_secret/blob/main/lib/top_secret/filters/ner.rb
+[discussions_60]: https://github.com/thoughtbot/top_secret/discussions/60

data/lib/top_secret/constants.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module TopSecret
+  # @return [String] The path to the NER model file
+  MODEL_PATH = "ner_model.dat"
+
   # @return [Regexp] Matches credit card numbers
   CREDIT_CARD_REGEX = /
     \b[3456]\d{15}\b |

data/lib/top_secret/filtered_text/result.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class FilteredText
+    # Result object returned by FilteredText restoration operations.
+    #
+    # Contains the restored text along with tracking information about which
+    # placeholders were successfully restored and which remain unrestored.
+    class Result
+      # @return [String] The text with placeholders restored to original values
+      attr_reader :output
+
+      # @return [Array<String>] Array of placeholder strings that could not be restored
+      attr_reader :unrestored
+
+      # @return [Array<String>] Array of placeholder strings that were successfully restored
+      attr_reader :restored
+
+      # @param output [String] The restored text
+      # @param unrestored [Array<String>] Placeholders that could not be restored
+      # @param restored [Array<String>] Placeholders that were successfully restored
+      def initialize(output, unrestored, restored)
+        @output = output
+        @unrestored = unrestored
+        @restored = restored
+      end
+    end
+  end
+end

data/lib/top_secret/filtered_text.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "filtered_text/result"
+
+module TopSecret
+  # Restores filtered text by substituting placeholders with original values.
+  #
+  # This class is used to reverse the filtering process, typically when processing
+  # responses from external services like LLMs that may contain filtered placeholders.
+  class FilteredText
+    # @return [String] The text being processed for restoration
+    attr_reader :output
+
+    # @param filtered_text [String] Text containing filter placeholders like [EMAIL_1]
+    # @param mapping [Hash] Hash mapping filter symbols to original values
+    def initialize(filtered_text, mapping:)
+      @mapping = mapping
+      @output = filtered_text.dup
+    end
+
+    # Convenience method to restore filtered text in one call
+    #
+    # @param filtered_text [String] Text containing filter placeholders
+    # @param mapping [Hash] Hash mapping filter symbols to original values
+    # @return [Result] Contains restored text and tracking information
+    #
+    # @example Basic restoration
+    #   mapping = {EMAIL_1: "john@example.com"}
+    #   result = TopSecret::FilteredText.restore("Contact [EMAIL_1]", mapping: mapping)
+    #   result.output # => "Contact john@example.com"
+    #   result.restored # => ["[EMAIL_1]"]
+    #   result.unrestored # => []
+    def self.restore(filtered_text, mapping:)
+      new(filtered_text, mapping:).restore
+    end
+
+    # Performs the restoration process
+    #
+    # Substitutes all found placeholders with their mapped values and tracks
+    # which placeholders were successfully restored vs those that remain unrestored.
+    #
+    # @return [Result] Contains the restored text and tracking arrays
+    def restore
+      restored = []
+
+      mapping.each do |filter, value|
+        placeholder = build_placeholder(filter)
+
+        if output.include? placeholder
+          restored << placeholder
+          output.gsub! placeholder, value
+        end
+      end
+
+      unrestored = output.scan(/\[\w*_\d\]/)
+
+      Result.new(output, unrestored, restored)
+    end
+
+    private
+
+    # @return [Hash] Mapping from filter symbols to original values
+    attr_reader :mapping
+
+    # Builds a placeholder string from a filter symbol
+    #
+    # @param filter [Symbol] The filter symbol (e.g., :EMAIL_1)
+    # @return [String] The placeholder string (e.g., "[EMAIL_1]")
+    def build_placeholder(filter)
+      "[#{filter}]"
+    end
+  end
+end

data/lib/top_secret/mapping.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TopSecret
+  module Mapping
+    # @return [Boolean] Whether sensitive information was found
+    def sensitive?
+      mapping.any?
+    end
+
+    # @return [Boolean] Whether sensitive information was not found
+    def safe?
+      !sensitive?
+    end
+  end
+end

data/lib/top_secret/null_model.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module TopSecret
+  # A null object implementation that provides a no-op interface compatible with Mitie::NER.
+  # Used when NER filtering is disabled (model_path is nil) to eliminate conditional checks
+  # throughout the codebase.
+  #
+  # @example
+  #   model = TopSecret::NullModel.new
+  #   doc = model.doc("some text")
+  #   doc.entities # => []
+  class NullModel
+    # A null document implementation that provides an empty entities array.
+    # Used as the return value from NullModel#doc to maintain interface compatibility.
+    class NullDoc
+      # Returns an empty array of entities.
+      #
+      # @return [Array] Always returns an empty array
+      def entities
+        []
+      end
+    end
+
+    # Creates a null document that returns empty entities.
+    #
+    # @param input [String] The input text (ignored)
+    # @return [NullDoc] A document-like object with empty entities
+    def doc(input)
+      NullDoc.new
+    end
+  end
+end

data/lib/top_secret/text/batch_result.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Text
+    # Holds the result of a batch redaction operation on multiple messages.
+    # Contains a global mapping that ensures consistent labeling across all messages
+    # and a collection of individual input/output pairs.
+    class BatchResult # TODO Rename to FilterBatchResult
+      include Mapping
+
+      # @return [Hash] Global mapping of redaction labels to original values across all messages
+      attr_reader :mapping
+
+      # @return [Array<Item>] Array of input/output pairs for each processed message
+      attr_reader :items
+
+      # Creates a new BatchResult instance
+      #
+      # @param mapping [Hash] Global mapping of redaction labels to original values
+      # @param items [Array<Item>] Array of input/output pairs
+      def initialize(mapping: {}, items: [])
+        @mapping = mapping
+        @items = items
+      end
+
+      # Creates a BatchResult from multiple messages with consistent global labeling
+      #
+      # @param messages [Array<String>] Array of text messages to filter
+      # @param custom_filters [Array] Additional custom filters to apply
+      # @param filters [Hash] Optional filters to override defaults (only valid filter keys accepted)
+      # @return [BatchResult] Contains global mapping and array of Result objects with individual mappings
+      # @raise [ArgumentError] If invalid filter keys are provided
+      def self.from_messages(messages, custom_filters: [], **filters)
+        individual_results = TopSecret::Text::Result.from_messages(messages, custom_filters:, **filters)
+        mapping = TopSecret::Text::GlobalMapping.from_results(individual_results)
+        items = TopSecret::Text::Result.with_global_labels(individual_results, mapping)
+
+        Text::BatchResult.new(mapping:, items:)
+      end
+    end
+  end
+end

data/lib/top_secret/text/global_mapping.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Text
+    # Manages consistent labeling across multiple filtering operations by ensuring
+    # identical sensitive values receive the same redaction labels globally.
+    class GlobalMapping
+      # Creates a global mapping from individual filter results
+      #
+      # @param individual_results [Array<Result>] Array of individual filter results
+      # @return [Hash] Inverted mapping from filter labels to original values
+      def self.from_results(individual_results)
+        new.build_from_results(individual_results)
+      end
+
+      # Creates a new GlobalMapping instance
+      def initialize
+        @mapping = {}
+        @label_counters = {}
+      end
+
+      # Builds the global mapping by processing all individual results
+      #
+      # @param individual_results [Array<Result>] Array of individual filter results
+      # @return [Hash] Inverted mapping from filter labels to original values
+      def build_from_results(individual_results)
+        individual_results.each { |result| process_result(result) if result.sensitive? }
+
+        mapping.invert
+      end
+
+      private
+
+      attr_reader :mapping
+      attr_reader :label_counters
+
+      # Processes a single result, adding new values to the global mapping
+      #
+      # @param result [Result] Individual filter result to process
+      def process_result(result)
+        result.mapping.each do |individual_key, value|
+          next if mapping.key?(value)
+
+          mapping[value] = generate_global_key(individual_key)
+        end
+      end
+
+      # Generates a consistent global key for a given individual key
+      #
+      # @param individual_key [Symbol] The individual key from a filter result
+      # @return [Symbol] The global key with consistent numbering
+      def generate_global_key(individual_key)
+        # TODO: This assumes labels are formatted consistently.
+        # We need to account for the following for the case where a label could begin with an "_"
+        label_type = individual_key.to_s.rpartition("_").first
+
+        label_counters[label_type] ||= 0
+        label_counters[label_type] += 1
+        :"#{label_type}_#{label_counters[label_type]}"
+      end
+    end
+  end
+end

data/lib/top_secret/text/result.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Text
+    # Holds the result of a redaction operation.
+    class Result # TODO: Rename to FilterResult
+      include Mapping
+
+      # @return [String] The original unredacted input
+      attr_reader :input
+
+      # @return [String] The redacted output
+      attr_reader :output
+
+      # @return [Hash] Mapping of redacted labels to matched values
+      attr_reader :mapping
+
+      # @param input [String] The original text
+      # @param output [String] The redacted text
+      # @param mapping [Hash] Map of labels to matched values
+      def initialize(input, output, mapping)
+        @input = input
+        @output = output
+        @mapping = mapping
+      end
+
+      # Filters multiple messages individually using a shared model for performance
+      #
+      # @param messages [Array<String>] Array of text messages to filter
+      # @param custom_filters [Array] Additional custom filters to apply
+      # @param filters [Hash] Optional filters to override defaults (only valid filter keys accepted)
+      # @return [Array<Result>] Array of individual Result objects for each message
+      # @raise [ArgumentError] If invalid filter keys are provided
+      def self.from_messages(messages, custom_filters: [], **filters)
+        shared_model = TopSecret.model_path ? Mitie::NER.new(TopSecret.model_path) : nil
+
+        messages.map do |message|
+          TopSecret::Text.new(message, filters:, custom_filters:, model: shared_model).filter
+        end
+      end
+
+      # Creates Result objects with globally consistent labels applied to text
+      #
+      # @param individual_results [Array<Result>] Array of individual filter results
+      # @param global_mapping [Hash] Global mapping from filter labels to original values
+      # @return [Array<Result>] Array of Result objects with globally consistent redaction and individual mappings
+      def self.with_global_labels(individual_results, global_mapping)
+        individual_results.map do |result|
+          output = global_mapping.reduce(result.input.dup) do |text, (filter, value)|
+            text.gsub(value, "[#{filter}]")
+          end
+          filter_keys = output.scan(/\[([^\]]+)\]/).flatten.map(&:to_sym)
+          mapping = global_mapping.slice(*filter_keys)
+          new(result.input, output, mapping)
+        end
+      end
+    end
+  end
+end

data/lib/top_secret/text/scan_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Text
+    # Holds the result of a scan operation.
+    class ScanResult
+      include Mapping
+
+      # @return [Hash] Mapping of redacted labels to matched values
+      attr_reader :mapping
+
+      # @param mapping [Hash] Map of labels to matched values
+      def initialize(mapping)
+        @mapping = mapping
+      end
+    end
+  end
+end

data/lib/top_secret/text.rb

@@ -1,37 +1,116 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash/keys"
+require_relative "null_model"
+require_relative "text/result"
+require_relative "text/batch_result"
+require_relative "text/scan_result"
+require_relative "text/global_mapping"
+
 module TopSecret
   # Processes text to identify and redact sensitive information using configured filters.
   class Text
     # @param input [String] The original text to be filtered
     # @param filters [Hash, nil] Optional set of filters to override the defaults
-    def initialize(input, filters: TopSecret.default_filters)
+    # @param custom_filters [Array] Additional custom filters to apply
+    # @param model [Mitie::NER, nil] Optional pre-loaded MITIE model for performance
+    def initialize(input, custom_filters: [], filters: {}, model: nil)
       @input = input
       @output = input.dup
       @mapping = {}
 
-      @model = Mitie::NER.new(TopSecret.model_path)
-      @doc = @model.doc(@output)
-      @entities = @doc.entities
+      @model = model || default_model
 
       @filters = filters
+      @custom_filters = custom_filters
     end
 
     # Convenience method to create an instance and filter input
     #
     # @param input [String] The text to filter
-    # @param filters [Hash] Optional filters to override defaults
+    # @param filters [Hash] Optional filters to override defaults (only valid filter keys accepted)
+    # @param custom_filters [Array] Additional custom filters to apply
     # @return [Result] The filtered result
-    def self.filter(input, filters: {})
-      new(input, filters:).filter
+    # @raise [ArgumentError] If invalid filter keys are provided
+    def self.filter(input, custom_filters: [], **filters)
+      new(input, filters:, custom_filters:).filter
     end
 
-    # Applies configured filters to the input, redacting matches and building a mapping.
+    # Filters multiple messages with globally consistent redaction labels
     #
-    # @return [Result] Contains original input, redacted output, and mapping of labels to values
+    # Processes a collection of messages and ensures that identical sensitive values
+    # receive the same redaction labels across all messages. This is useful when
+    # processing conversation threads or document collections where consistency matters.
+    #
+    # @param messages [Array<String>] Array of text messages to filter
+    # @param custom_filters [Array] Additional custom filters to apply
+    # @param filters [Hash] Optional filters to override defaults (only valid filter keys accepted)
+    # @return [BatchResult] Contains global mapping and array of Result objects with individual mappings
+    # @raise [ArgumentError] If invalid filter keys are provided
+    #
+    # @example Basic usage
+    #   messages = ["Contact john@test.com", "Email john@test.com again"]
+    #   result = TopSecret::Text.filter_all(messages)
+    #   result.items[0].output # => "Contact [EMAIL_1]"
+    #   result.items[1].output # => "Email [EMAIL_1] again"
+    #   result.items[0].mapping # => { EMAIL_1: "john@test.com" }
+    #   result.mapping # => { EMAIL_1: "john@test.com" }
+    #
+    # @example With custom filters
+    #   ip_filter = TopSecret::Filters::Regex.new(label: "IP", regex: /\d+\.\d+\.\d+\.\d+/)
+    #   result = TopSecret::Text.filter_all(messages, custom_filters: [ip_filter])
+    def self.filter_all(messages, custom_filters: [], **filters)
+      Text::BatchResult.from_messages(messages, custom_filters:, **filters)
+    end
+
+    # Convenience method to scan input text for sensitive information without redacting it
+    #
+    # This method detects sensitive information using configured filters but does not modify
+    # the original text. Use this when you only need to check if sensitive data exists or
+    # get a mapping of what was found.
+    #
+    # @param input [String] The text to scan for sensitive information
+    # @param filters [Hash] Optional filters to override defaults (only valid filter keys accepted)
+    # @param custom_filters [Array] Additional custom filters to apply
+    # @return [ScanResult] Contains mapping of found sensitive information and sensitive? flag
+    # @raise [ArgumentError] If invalid filter keys are provided
+    #
+    # @example Basic scanning
+    #   result = TopSecret::Text.scan("Contact john@example.com")
+    #   result.sensitive? # => true
+    #   result.mapping    # => {:EMAIL_1=>"john@example.com"}
+    #
+    # @example With custom filters
+    #   ip_filter = TopSecret::Filters::Regex.new(label: "IP", regex: /\d+\.\d+\.\d+\.\d+/)
+    #   result = TopSecret::Text.scan("Server IP: 192.168.1.1", custom_filters: [ip_filter])
+    #   result.mapping # => {:IP_1=>"192.168.1.1"}
+    #
+    # @example Overriding default filters
+    #   custom_email = TopSecret::Filters::Regex.new(label: "EMAIL_ADDR", regex: /\w+@\w+/)
+    #   result = TopSecret::Text.scan("user@test.com", email_filter: custom_email)
+    #   result.mapping # => {:EMAIL_ADDR_1=>"user@test.com"}
+    def self.scan(input, custom_filters: [], **filters)
+      new(input, filters:, custom_filters:).scan
+    end
+
+    # Scans the input text for sensitive information using configured filters
+    #
+    # This method applies all active filters to detect sensitive information but does not
+    # redact the original text. It builds a mapping of found values and returns whether
+    # any sensitive information was detected.
+    #
+    # @return [ScanResult] Contains mapping of found sensitive information and sensitive? flag
     # @raise [Error] If an unsupported filter is encountered
-    def filter
-      TopSecret.default_filters.merge(filters).compact.each_value do |filter|
+    # @raise [ArgumentError] If invalid filter keys are provided
+    def scan
+      @doc ||= model.doc(@output) if model
+      @entities ||= doc.entities if model
+
+      validate_filters!
+
+      all_filters.each do |filter|
+        next if filter.nil?
+
         values = case filter
         when TopSecret::Filters::Regex
           filter.call(input)
@@ -43,9 +122,20 @@ module TopSecret
         build_mapping(values, label: filter.label)
       end
 
-      substitute_text
+      ScanResult.new(mapping)
+    end
 
-      Result.new(input, output, mapping)
+    # Applies configured filters to the input, redacting matches and building a mapping.
+    #
+    # @return [Result] Contains original input, redacted output, and mapping of labels to values
+    # @raise [Error] If an unsupported filter is encountered
+    # @raise [ArgumentError] If invalid filter keys are provided
+    def filter
+      scan_result = scan
+
+      substitute_text if scan_result.sensitive?
+
+      Text::Result.new(input, output, scan_result.mapping)
     end
 
     private
@@ -59,12 +149,21 @@ module TopSecret
     # @return [Hash] Mapping from redaction labels to original values
     attr_reader :mapping
 
+    # @return [Object] The NER model (typically Mitie::NER or a test double)
+    attr_reader :model
+
+    # @return [Object] The document created from the output text (typically Mitie::Document or a test double)
+    attr_reader :doc
+
     # @return [Array<Hash>] Named entities extracted by MITIE
     attr_reader :entities
 
     # @return [Hash] Active filters used for redaction
     attr_reader :filters
 
+    # @return [Array] Custom filters to apply
+    attr_reader :custom_filters
+
     # Builds the mapping of label keys to matched values, indexed uniquely.
     #
     # @param values [Array<String>] Values matched by a filter
@@ -85,5 +184,55 @@ module TopSecret
         output.gsub! value, "[#{filter}]"
       end
     end
+
+    # Collects all filters to apply: default filters with overrides plus custom filters
+    #
+    # @return [Array] Array of filter objects to apply
+    def all_filters
+      merged_filters.values.compact + TopSecret.custom_filters + custom_filters
+    end
+
+    # Merges default filters with user-provided filter overrides
+    #
+    # @return [Hash] Hash containing default filters with any user overrides applied
+    # @private
+    def merged_filters
+      default_filters.merge(filters)
+    end
+
+    # Validates that all provided filter keys are recognized
+    #
+    # @return [void]
+    # @raise [ArgumentError] If invalid filter keys are provided
+    def validate_filters!
+      merged_filters.assert_valid_keys(*default_filters.keys)
+    end
+
+    # Returns the default filters configuration hash
+    #
+    # @return [Hash] Hash containing all configured default filters, keyed by filter name
+    # @private
+    def default_filters
+      {
+        credit_card_filter: TopSecret.credit_card_filter,
+        email_filter: TopSecret.email_filter,
+        phone_number_filter: TopSecret.phone_number_filter,
+        ssn_filter: TopSecret.ssn_filter,
+        people_filter: TopSecret.people_filter,
+        location_filter: TopSecret.location_filter
+      }
+    end
+
+    # Creates the default model based on configuration.
+    # Returns a MITIE NER model if a model path is configured, otherwise returns a null model.
+    #
+    # @return [Mitie::NER, NullModel] The model instance to use for NER processing
+    def default_model
+      if TopSecret.model_path
+        Mitie::NER.new(TopSecret.model_path)
+      else
+        NullModel.new
+      end
+    end
   end
 end

data/lib/top_secret/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module TopSecret
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
+  MINIMUM_RAILS_VERSION = ">= 7.0.8"
+  MAXIMUM_RAILS_VERSION = "< 9"
 end

data/lib/top_secret.rb

@@ -8,13 +8,14 @@ require "mitie"
 # modules
 require_relative "top_secret/version"
 require_relative "top_secret/constants"
+require_relative "top_secret/mapping"
 require_relative "top_secret/filters/ner"
 require_relative "top_secret/filters/regex"
 require_relative "top_secret/error"
-require_relative "top_secret/result"
 require_relative "top_secret/text"
+require_relative "top_secret/filtered_text"
 
-# TopSecret filters sensitive information from free text before it's sent to external services or APIs, such as Chatbots.
+# TopSecret filters sensitive information from free text before it's sent to external services or APIs, such as chatbots and LLMs.
 #
 # @!attribute [rw] model_path
 #   @return [String] the path to the MITIE NER model
@@ -22,23 +23,38 @@ require_relative "top_secret/text"
 # @!attribute [rw] min_confidence_score
 #   @return [Float] the minimum confidence score required for NER matches
 #
-# @!attribute [rw] default_filters
-#   @return [ActiveSupport::OrderedOptions] a set of default filters used to identify sensitive data
+# @!attribute [rw] custom_filters
+#   @return [Array] array of custom filters that can be configured
+#
+# @!attribute [rw] credit_card_filter
+#   @return [TopSecret::Filters::Regex] filter for credit card numbers
+#
+# @!attribute [rw] email_filter
+#   @return [TopSecret::Filters::Regex] filter for email addresses
+#
+# @!attribute [rw] phone_number_filter
+#   @return [TopSecret::Filters::Regex] filter for phone numbers
+#
+# @!attribute [rw] ssn_filter
+#   @return [TopSecret::Filters::Regex] filter for social security numbers
+#
+# @!attribute [rw] people_filter
+#   @return [TopSecret::Filters::NER] filter for person names
+#
+# @!attribute [rw] location_filter
+#   @return [TopSecret::Filters::NER] filter for location names
 module TopSecret
   include ActiveSupport::Configurable
 
-  config_accessor :model_path, default: "ner_model.dat"
+  config_accessor :model_path, default: MODEL_PATH
   config_accessor :min_confidence_score, default: MIN_CONFIDENCE_SCORE
 
-  config_accessor :default_filters do
-    options = ActiveSupport::OrderedOptions.new
-    options.credit_card_filter = TopSecret::Filters::Regex.new(label: "CREDIT_CARD", regex: CREDIT_CARD_REGEX)
-    options.email_filter = TopSecret::Filters::Regex.new(label: "EMAIL", regex: EMAIL_REGEX)
-    options.phone_number_filter = TopSecret::Filters::Regex.new(label: "PHONE_NUMBER", regex: PHONE_REGEX)
-    options.ssn_filter = TopSecret::Filters::Regex.new(label: "SSN", regex: SSN_REGEX)
-    options.people_filter = TopSecret::Filters::NER.new(label: "PERSON", tag: :person)
-    options.location_filter = TopSecret::Filters::NER.new(label: "LOCATION", tag: :location)
+  config_accessor :custom_filters, default: []
 
-    options
-  end
+  config_accessor :credit_card_filter, default: TopSecret::Filters::Regex.new(label: "CREDIT_CARD", regex: CREDIT_CARD_REGEX)
+  config_accessor :email_filter, default: TopSecret::Filters::Regex.new(label: "EMAIL", regex: EMAIL_REGEX)
+  config_accessor :phone_number_filter, default: TopSecret::Filters::Regex.new(label: "PHONE_NUMBER", regex: PHONE_REGEX)
+  config_accessor :ssn_filter, default: TopSecret::Filters::Regex.new(label: "SSN", regex: SSN_REGEX)
+  config_accessor :people_filter, default: TopSecret::Filters::NER.new(label: "PERSON", tag: :person)
+  config_accessor :location_filter, default: TopSecret::Filters::NER.new(label: "LOCATION", tag: :location)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: top_secret
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Steve Polito
@@ -13,22 +13,22 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '8.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 7.0.8
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '8.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 7.0.8
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: mitie
   requirement: !ruby/object:Gem::Requirement
@@ -44,7 +44,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.2
 description: Filter sensitive information from free text before sending it to external
-  services or APIs, such as Chatbots.
+  services or APIs, such as chatbots and LLMs.
 email:
 - stevepolito@hey.com
 executables: []
@@ -52,6 +52,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CODEOWNERS
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
@@ -59,10 +60,17 @@ files:
 - lib/top_secret.rb
 - lib/top_secret/constants.rb
 - lib/top_secret/error.rb
+- lib/top_secret/filtered_text.rb
+- lib/top_secret/filtered_text/result.rb
 - lib/top_secret/filters/ner.rb
 - lib/top_secret/filters/regex.rb
-- lib/top_secret/result.rb
+- lib/top_secret/mapping.rb
+- lib/top_secret/null_model.rb
 - lib/top_secret/text.rb
+- lib/top_secret/text/batch_result.rb
+- lib/top_secret/text/global_mapping.rb
+- lib/top_secret/text/result.rb
+- lib/top_secret/text/scan_result.rb
 - lib/top_secret/version.rb
 - sig/top_secret.rbs
 homepage: https://github.com/thoughtbot/top_secret

data/lib/top_secret/result.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module TopSecret
-  # Holds the result of a redaction operation.
-  class Result
-    # @return [String] The original unredacted input
-    attr_reader :input
-
-    # @return [String] The redacted output
-    attr_reader :output
-
-    # @return [Hash] Mapping of redacted labels to matched values
-    attr_reader :mapping
-
-    # @param input [String] The original text
-    # @param output [String] The redacted text
-    # @param mapping [Hash] Map of labels to matched values
-    def initialize(input, output, mapping)
-      @input = input
-      @output = output
-      @mapping = mapping
-    end
-  end
-end