top_secret 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d570b8ecd9cb5ab35f59dc688a6a13a749cebf1abfcbce36906f12d1d8452189
+  data.tar.gz: 8b5d639506a7ecd6bbb548e245db54384a2d16c0b47bbd564230c4140639c05d
+SHA512:
+  metadata.gz: fef5120cc93ac1772270816788ee9bd3a7141779f300a839ecb7d8d35d228c7539e33bb55cac1ff97d975b35251d46913020879d985dad75655de385a47b31ca
+  data.tar.gz: 5acc9bb4f77210d0ae804ee50472ec75952f12812892c6d304feb4209ee152a5d3a3740fe938d17dd47cb664945d90dc73ddfa1578b2c4f1400a1ef23d8e93bb

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-07-23
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,6 @@
+# Code of conduct
+
+By participating in this project, you agree to abide by the
+[thoughtbot code of conduct][1].
+
+[1]: https://thoughtbot.com/open-source-code-of-conduct

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Steve Polito and thoughtbot, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,402 @@
+# Top Secret
+
+Filter sensitive information from free text before sending it to external services or APIs, such as Chatbots.
+
+By default it filters the following:
+
+-   Credit cards
+-   Emails
+-   Phone numbers
+-   Social security numbers
+-   People's names
+-   Locations
+
+However, you can add your own [custom filters](#custom-filters).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add top_secret
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install top_secret
+```
+
+> [!IMPORTANT]
+> Top Secret depends on [MITIE Ruby][], which depends on [MITIE][].
+>
+> You'll need to download and extract [ner_model.dat][] first.
+
+By default, Top Secret assumes the file will live at the root of your project, but this can be configured.
+
+```ruby
+TopSecret.configure do |config|
+  config.model_path = "path/to/ner_model.dat"
+end
+```
+
+## Default Filters
+
+Top Secret ships with a set of filters to detect and redact the most common types of sensitive information.
+
+You can [override](#overriding-the-default-filters-1), [disable](#disabling-a-default-filter-1), or [add](#adding-new-default-filters) to this list as needed.
+
+By default, the following filters are enabled
+
+**`credit_card_filter`**
+
+Matches common credit card formats
+
+```ruby
+result = TopSecret::Text.filter("My card number is 4242-4242-4242-4242")
+result.output
+
+# => "My card number is [CREDIT_CARD_1]"
+```
+
+**`email_filter`**
+
+Matches email addresses
+
+```ruby
+result = TopSecret::Text.filter("Email me at ralph@thoughtbot.com")
+result.output
+
+# => "Email me at [EMAIL_1]"
+```
+
+**`phone_number_filter`**
+
+Matches phone numbers
+
+```ruby
+result = TopSecret::Text.filter("Call me at 555-555-5555")
+result.output
+
+# => "Call me at [PHONE_NUMBER_1]"
+```
+
+**`ssn_filter`**
+
+Matches U.S. Social Security numbers
+
+```ruby
+result = TopSecret::Text.filter("My SSN is 123-45-6789")
+result.output
+
+# => "My SSN is [SSN_1]"
+```
+
+**`people_filter`**
+
+Detects names of people (NER-based)
+
+```ruby
+result = TopSecret::Text.filter("Ralph is joining the meeting")
+result.output
+
+# => "[PERSON_1] is joining the meeting"
+```
+
+**`location_filter`**
+
+Detects location names (NER-based)
+
+```ruby
+result = TopSecret::Text.filter("Let's meet in Boston")
+result.output
+
+# => "Let's meet in [LOCATION_1]"
+```
+
+## Usage
+
+```ruby
+TopSecret::Text.filter("Ralph can be reached at ralph@thoughtbot.com")
+```
+
+This will return
+
+```ruby
+<TopSecret::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]"
+>
+```
+
+View the original text
+
+```ruby
+result.input
+
+# => "Ralph can be reached at ralph@thoughtbot.com"
+```
+
+View the filtered text
+
+```ruby
+result.output
+
+# => "[PERSON_1] can be reached at [EMAIL_1]"
+```
+
+View the mapping
+
+```ruby
+result.mapping
+
+# => {:EMAIL_1=>"ralph@thoughtbot.com", :PERSON_1=>"Ralph"}
+```
+
+### 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.
+
+```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: {
+  email_filter: regex_filter,
+  people_filter: ner_filter
+})
+```
+
+This will return
+
+```ruby
+<TopSecret::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]"
+>
+```
+
+#### Disabling a default filter
+
+```ruby
+TopSecret::Text.filter("Ralph can be reached at ralph@thoughtbot.com", filters: {
+  email_filter: nil,
+  people_filter: nil
+})
+```
+
+This will return
+
+```ruby
+<TopSecret::Result
+  @input="Ralph can be reached at ralph@thoughtbot.com",
+  @mapping={},
+  @output="Ralph can be reached at ralph@thoughtbot.com"
+>
+```
+
+### Custom Filters
+
+#### Adding new [Regex filters][]
+
+```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::Text.filter("Ralph's IP address is 192.168.1.1", filters: {
+  ip_address_filter: ip_address_filter
+})
+```
+
+This will return
+
+```ruby
+<TopSecret::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]"
+>
+```
+
+#### Adding new [NER filters][]
+
+Since [MITIE Ruby][] has an API for [training][train] a model, you're free to add new NER filters.
+
+```ruby
+language_filter = TopSecret::Filters::NER.new(
+  label: "LANGUAGE",
+  tag: :language,
+  min_confidence_score: 0.75
+)
+
+TopSecret::Text.filter("Ralph's favorite programming language is Ruby.", filters: {
+  language_filter: language_filter
+})
+```
+
+This will return
+
+```ruby
+<TopSecret::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]"
+>
+```
+
+## How Filters Work
+
+Top Secret uses two types of filters to detect and redact sensitive information:
+
+### `TopSecret::Filters::Regex`
+
+`Regex` filters use regular expressions to find patterns in text.
+They are useful for structured data like credit card numbers, emails, or IP addresses.
+
+```ruby
+regex_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.filter("Server IP: 192.168.1.1", filters: {
+  ip_address_filter: regex_filter
+})
+
+result.output
+# => "Server IP: [IP_ADDRESS_1]"
+```
+
+### `TopSecret::Filters::NER`
+
+`NER` (Named Entity Recognition) filters use the [MITIE][] library to detect entities like people, locations, and other categories based on trained language models.
+They are ideal for free-form text where patterns are less predictable.
+
+```ruby
+ner_filter = TopSecret::Filters::NER.new(
+  label: "PERSON",
+  tag: :person,
+  min_confidence_score: 0.25
+)
+
+result = TopSecret::Text.filter("Ralph and Ruby work at thoughtbot.", filters: {
+  people_filter: ner_filter
+})
+
+result.output
+# => "[PERSON_1] and [PERSON_2] work at thoughtbot."
+```
+
+`NER` filters match based on the tag you specify (`:person`, `:location`, etc.) and only include matches with a confidence score above `min_confidence_score`.
+
+#### Supported NER Tags
+
+By default, Top Secret only ships with `NER` filters for two entity types:
+
+-   `:person`
+-   `:location`
+
+If you need other tags you can [train your own MITIE model][train] and add custom NER filters:
+
+## Configuration
+
+### Overriding the model path
+
+```ruby
+TopSecret.configure do |config|
+  config.model_path = "path/to/ner_model.dat"
+end
+```
+
+### Overriding the confidence score
+
+```ruby
+TopSecret.configure do |config|
+  config.min_confidence_score = 0.75
+end
+```
+
+### Overriding the default filters
+
+```ruby
+TopSecret.configure do |config|
+  config.default_filters.email_filter = TopSecret::Filters::Regex.new(
+    label: "EMAIL_ADDRESS",
+    regex: /\b\w+\[at\]\w+\.\w+\b/
+  )
+end
+```
+
+### Disabling a default filter
+
+```ruby
+TopSecret.configure do |config|
+  config.default_filters.email_filter = nil
+end
+```
+
+### Adding new default filters
+
+```ruby
+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/
+  )
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+> [!IMPORTANT]
+> Top Secret depends on [MITIE Ruby][], which depends on [MITIE][].
+>
+> You'll need to download and extract [ner_model.dat][] first, and place it in the root of this project.
+
+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).
+
+## License
+
+Open source templates are Copyright (c) thoughtbot, inc.
+It contains free software that may be redistributed under the terms specified in the [LICENSE](https://github.com/thoughtbot/top_secret/blob/main/LICENSE.txt) file.
+
+## Code of Conduct
+
+Everyone interacting in the TopSecret project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/thoughtbot/top_secret/blob/main/CODE_OF_CONDUCT.md).
+
+<!-- START /templates/footer.md -->
+
+## About thoughtbot
+
+![thoughtbot](https://thoughtbot.com/thoughtbot-logo-for-readmes.svg)
+
+This repo is maintained and funded by thoughtbot, inc.
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+We love open source software!
+See [our other projects][community].
+We are [available for hire][hire].
+
+[community]: https://thoughtbot.com/community?utm_source=github
+[hire]: https://thoughtbot.com/hire-us?utm_source=github
+
+<!-- END /templates/footer.md -->
+
+[MITIE Ruby]: https://github.com/ankane/mitie-ruby
+[MITIE]: https://github.com/mit-nlp/MITIE
+[ner_model.dat]: https://github.com/mit-nlp/MITIE/releases/download/v0.4/MITIE-models-v0.2.tar.bz2
+[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

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/lib/top_secret/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TopSecret
+  # @return [Regexp] Matches credit card numbers
+  CREDIT_CARD_REGEX = /
+    \b[3456]\d{15}\b |
+    \b[3456]\d{3}(?:[\s+-]\d{4}){3}\b
+  /x
+
+  # @return [Regexp] Matches valid email addresses
+  EMAIL_REGEX = %r{
+    [a-zA-Z0-9.!\#$%&'*+/=?^_`{|}~-]+@
+    [a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
+    (?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*
+  }x
+
+  # @return [Regexp] Matches phone numbers with optional country code
+  PHONE_REGEX = /\b(?:\+\d{1,2}\s)?\(?\d{3}\)?[\s+.-]\d{3}[\s+.-]\d{4}\b/
+
+  # @return [Regexp] Matches Social Security Numbers in common formats
+  SSN_REGEX = /\b\d{3}[\s+-]\d{2}[\s+-]\d{4}\b/
+
+  # @return [Float] The minimum confidence score for NER filtering
+  MIN_CONFIDENCE_SCORE = 0.5
+end

data/lib/top_secret/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Error < StandardError; end
+end

data/lib/top_secret/filters/ner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TopSecret
+  module Filters
+    # Applies Named Entity Recognition (NER) filtering based on tag and confidence score.
+    class NER
+      # @return [String] The label applied to matching entities
+      attr_reader :label
+
+      # @param label [String] The label for redacted entities
+      # @param tag [Symbol, String] The NER tag to match (e.g., :person, :location)
+      # @param min_confidence_score [Float, nil] Minimum score required for a match (defaults to TopSecret.min_confidence_score)
+      def initialize(label:, tag:, min_confidence_score: nil)
+        @label = label
+        @tag = tag.upcase.to_s
+        @min_confidence_score = min_confidence_score || TopSecret.min_confidence_score
+      end
+
+      # Filters and extracts entity texts matching the tag and score threshold.
+      #
+      # @param entities [Array<Hash>] List of entity hashes with keys :tag, :score, and :text
+      # @return [Array<String>] Matched entity texts
+      def call(entities)
+        tags = entities.filter { _1.fetch(:tag) == tag && _1.fetch(:score) >= min_confidence_score }
+        tags.map { _1.fetch(:text) }
+      end
+
+      private
+
+      # @return [String] The expected tag (uppercased)
+      attr_reader :tag
+
+      # @return [Float] Minimum confidence score for matches
+      attr_reader :min_confidence_score
+    end
+  end
+end

data/lib/top_secret/filters/regex.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module TopSecret
+  module Filters
+    # Applies regex-based filtering to extract matching text from input.
+    class Regex
+      # @return [String] The label applied to matching content
+      attr_reader :label
+
+      # @param label [String] The label for redacted content
+      # @param regex [Regexp] The regular expression used to match content
+      def initialize(label:, regex:)
+        @label = label
+        @regex = regex
+      end
+
+      # Applies the regex to the input and returns all matches.
+      #
+      # @param input [String] The input text to scan
+      # @return [Array<String>] All matches found
+      def call(input)
+        input.scan(regex)
+      end
+
+      private
+
+      # @return [Regexp] The regular expression used for matching
+      # @private
+      attr_reader :regex
+    end
+  end
+end

data/lib/top_secret/result.rb

@@ -0,0 +1,24 @@
+# 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

data/lib/top_secret/text.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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)
+      @input = input
+      @output = input.dup
+      @mapping = {}
+
+      @model = Mitie::NER.new(TopSecret.model_path)
+      @doc = @model.doc(@output)
+      @entities = @doc.entities
+
+      @filters = 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
+    # @return [Result] The filtered result
+    def self.filter(input, filters: {})
+      new(input, filters:).filter
+    end
+
+    # 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
+    def filter
+      TopSecret.default_filters.merge(filters).compact.each_value do |filter|
+        values = case filter
+        when TopSecret::Filters::Regex
+          filter.call(input)
+        when TopSecret::Filters::NER
+          filter.call(entities)
+        else
+          raise Error, "Unsupported filter. Expected TopSecret::Filters::Regex or TopSecret::Filters::NER, but got #{filter.class}"
+        end
+        build_mapping(values, label: filter.label)
+      end
+
+      substitute_text
+
+      Result.new(input, output, mapping)
+    end
+
+    private
+
+    # @return [String] Original unredacted input text
+    attr_reader :input
+
+    # @return [String] Output with sensitive information redacted
+    attr_reader :output
+
+    # @return [Hash] Mapping from redaction labels to original values
+    attr_reader :mapping
+
+    # @return [Array<Hash>] Named entities extracted by MITIE
+    attr_reader :entities
+
+    # @return [Hash] Active filters used for redaction
+    attr_reader :filters
+
+    # Builds the mapping of label keys to matched values, indexed uniquely.
+    #
+    # @param values [Array<String>] Values matched by a filter
+    # @param label [String] Label identifying the filter type
+    # @return [void]
+    def build_mapping(values, label:)
+      values.uniq.each.with_index(1) do |value, index|
+        filter = "#{label}_#{index}"
+        mapping.merge!({filter.to_sym => value})
+      end
+    end
+
+    # Substitutes matched values in the output text with their label placeholders.
+    #
+    # @return [void]
+    def substitute_text
+      mapping.each do |filter, value|
+        output.gsub! value, "[#{filter}]"
+      end
+    end
+  end
+end

data/lib/top_secret/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TopSecret
+  VERSION = "0.1.0"
+end

data/lib/top_secret.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# dependencies
+require "active_support/configurable"
+require "active_support/ordered_options"
+require "mitie"
+
+# modules
+require_relative "top_secret/version"
+require_relative "top_secret/constants"
+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"
+
+# TopSecret filters sensitive information from free text before it's sent to external services or APIs, such as Chatbots.
+#
+# @!attribute [rw] model_path
+#   @return [String] the path to the MITIE NER model
+#
+# @!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
+module TopSecret
+  include ActiveSupport::Configurable
+
+  config_accessor :model_path, default: "ner_model.dat"
+  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)
+
+    options
+  end
+end

data/sig/top_secret.rbs

@@ -0,0 +1,4 @@
+module TopSecret
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: top_secret
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Steve Polito
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+  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
+- !ruby/object:Gem::Dependency
+  name: mitie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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.
+email:
+- stevepolito@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/top_secret.rb
+- lib/top_secret/constants.rb
+- lib/top_secret/error.rb
+- lib/top_secret/filters/ner.rb
+- lib/top_secret/filters/regex.rb
+- lib/top_secret/result.rb
+- lib/top_secret/text.rb
+- lib/top_secret/version.rb
+- sig/top_secret.rbs
+homepage: https://github.com/thoughtbot/top_secret
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/thoughtbot/top_secret
+  source_code_uri: https://github.com/thoughtbot/top_secret
+  changelog_uri: https://github.com/thoughtbot/top_secret/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Filter sensitive information from free text.
+test_files: []