top_secret 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cef5c9c267dd71870fd244408a3f9a020d19978381810f99e7ed5defc67f12a7
-  data.tar.gz: ec20793792721a47371cc6a7cf3c687ad4284b9c9f1f9b14c57e002118c5532a
+  metadata.gz: e4bff6502396266520ec0ff99e2f413fd70301aa44c7a113e23d231466072860
+  data.tar.gz: 3fdd3c37f08538cce48f49cd90faa85717d8d06b5701ecbb763c353e08ad3060
 SHA512:
-  metadata.gz: 0eea9a1087e5082e245b73cdbb434543dbfcff277b6d58b7a89e463b1162215e0058f5190df3863a73fd32223fdf42fa65a253781193ea7e44ecc6b68c359e45
-  data.tar.gz: 6626056578ec3feecf27d843a994f782c144b363a6b7473e6e0be0fa80044c2283c329ae068c4f0f66af13f021743039864e13f220174489bd822e0c162872a7
+  metadata.gz: 7630a299ea11ef420819088aa4edc1d4c12314f286b0ecc9fe4eecaa4f6392306856de65489bc6b8c609275dd044a406d172b58fcf04b9d7fa537890131f653c
+  data.tar.gz: 9c21a7ca0c5138da5132b002c4cb4e34d6824cc27b148a253bc1e9f01efdcd3152e8362455d909c42cf26eb0be5a58c695f26918cdc8d4222dcccd9ffdd660b2

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 ## [Unreleased]
 
+## [1.0.0] - 2026-03-25
+
+### Added
+
+-   Added category methods to `Result` for querying specific types of sensitive information (e.g., `emails`, `emails?`, `email_mapping`)
+-   Category methods are automatically generated for all default filter types and custom labels
+-   Category methods always return empty arrays/hashes when no data of that type is found, ensuring they're safe to call without checking
+-   Custom labels are matched exactly — `EMAIL_ADDRESS` methods are distinct from default `EMAIL` methods
+-   Added `categories` method to `Result` for listing category types that have matches in the mapping
+
+### Changed
+
+-   **BREAKING:** Added strict label validation for custom filters. Labels must now start and end with letters and contain only alphabetic characters and single underscores (no consecutive underscores, digits, or special characters). Previously malformed labels will now raise `Error::MalformedLabel`.
+-   Replaced `ActiveSupport::Configurable` with `mattr_accessor` for upcoming `Configurable` deprecation in Rails 8.2.
+
+### Migration Guide
+
+If you have custom filters with malformed labels, update them to meet the new requirements:
+
+```ruby
+# Before (invalid)
+TopSecret::Filters::Regex.new(label: "EMAIL_ADDRESS_1", regex: /.../)
+TopSecret::Filters::Regex.new(label: "_EMAIL", regex: /.../)
+TopSecret::Filters::Regex.new(label: "EMAIL1", regex: /.../)
+
+# After (valid)
+TopSecret::Filters::Regex.new(label: "EMAIL_ADDRESS", regex: /.../)
+TopSecret::Filters::Regex.new(label: "EMAIL", regex: /.../)
+TopSecret::Filters::Regex.new(label: "EMAIL", regex: /.../)
+```
+
+Note: The `_N` suffix is appended automatically by the system during mapping.
+
+## [0.4.0] - 2025-10-31
+
+### Added
+
+-   Added automatic caching of MITIE NER model to improve performance by avoiding expensive reinitialization
+-   Added `TopSecret::Text.clear_model_cache!` method to clear the cached model when needed
+
 ## [0.3.0] - 2025-09-19
 
 ### Added

data/README.md

@@ -35,9 +35,7 @@ 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.
+> Due to its large size, you'll likely want to avoid committing [ner_model.dat][] into version control. See the [Production](#production) section for details on using [Trove][] to deploy the model file.
 >
 > 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.
 
@@ -175,6 +173,104 @@ result.safe?
 # => false
 ```
 
+### Category Methods
+
+Query the result for specific types of sensitive information using category methods:
+
+```ruby
+result = TopSecret::Text.filter("Ralph can be reached at ralph@example.com or 555-1234")
+
+# Check if emails were found
+result.emails?
+# => true
+
+# Get all emails
+result.emails
+# => ["ralph@example.com"]
+
+# Get email mapping
+result.email_mapping
+# => {:EMAIL_1=>"ralph@example.com"}
+
+# Similarly for other types
+result.people?         # => true
+result.people          # => ["Ralph"]
+result.person_mapping  # => {:PERSON_1=>"Ralph"}
+
+result.phone_numbers?         # => true
+result.phone_numbers          # => ["555-1234"]
+result.phone_number_mapping   # => {:PHONE_NUMBER_1=>"555-1234"}
+```
+
+Available category methods for all default filters:
+
+- `emails`, `emails?`, `email_mapping`
+- `credit_cards`, `credit_cards?`, `credit_card_mapping`
+- `phone_numbers`, `phone_numbers?`, `phone_number_mapping`
+- `ssns`, `ssns?`, `ssn_mapping`
+- `people`, `people?`, `person_mapping`
+- `locations`, `locations?`, `location_mapping`
+
+Use `categories` to see which types were found in the result:
+
+```ruby
+result = TopSecret::Text.filter("Ralph can be reached at ralph@example.com")
+
+result.categories
+# => [:email, :person]
+```
+
+These methods are always available and return empty arrays/hashes when no sensitive information of that type is found:
+
+```ruby
+result = TopSecret::Text.filter("No sensitive data here")
+
+result.emails?         # => false
+result.emails          # => []
+result.email_mapping   # => {}
+```
+
+When using custom labels, methods are generated based on the label name. Each label is matched exactly — a custom label like `EMAIL_ADDRESS` produces its own set of methods, separate from the default `EMAIL` methods:
+
+```ruby
+result = TopSecret::Text.filter(
+  "user[at]example.com",
+  email_filter: TopSecret::Filters::Regex.new(
+    label: "EMAIL_ADDRESS",
+    regex: /\w+\[at\]\w+\.\w+/
+  )
+)
+
+# Methods are derived from the custom label (EMAIL_ADDRESS)
+result.email_addresses          # => ["user[at]example.com"]
+result.email_addresses?         # => true
+result.email_address_mapping    # => {:EMAIL_ADDRESS_1=>"user[at]example.com"}
+
+# Default email methods only match the default EMAIL label, not EMAIL_ADDRESS
+result.emails                   # => []
+result.email_mapping            # => {}
+
+# If the custom label matches the default, both refer to the same data
+result = TopSecret::Text.filter(
+  "user[at]example.com",
+  email_filter: TopSecret::Filters::Regex.new(
+    label: "EMAIL",
+    regex: /\w+\[at\]\w+\.\w+/
+  )
+)
+
+result.emails                   # => ["user[at]example.com"]
+result.email_mapping            # => {:EMAIL_1=>"user[at]example.com"}
+```
+
+When a custom label ends in `_MAPPING` (e.g., `NETWORK_MAPPING`), the mapping method appends `_mapping` to the pluralized form to keep the naming pattern consistent:
+
+```ruby
+result.network_mappings          # => ["10.0.1.0/24 -> 192.168.1.0/24"]
+result.network_mappings?         # => true
+result.network_mappings_mapping  # => {:NETWORK_MAPPING_1=>"10.0.1.0/24 -> 192.168.1.0/24"}
+```
+
 ### 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:
@@ -455,6 +551,20 @@ TopSecret::Text.filter("some text", invalid_filter: some_filter)
 
 ### Custom Filters
 
+> [!IMPORTANT]
+> Custom filter labels must follow these rules:
+>
+> -   Start with a letter (a-z, A-Z)
+> -   End with a letter (a-z, A-Z)
+> -   Contain only letters and single underscores (no consecutive underscores)
+> -   Cannot contain digits or special characters
+>
+> Valid examples: `EMAIL`, `IP_ADDRESS`, `CREDIT_CARD`
+>
+> Invalid examples: `_EMAIL` (starts with underscore), `EMAIL_` (ends with underscore), `EMAIL1` (ends with digit), `EMAIL__ADDRESS` (consecutive underscores)
+>
+> The system automatically appends `_N` where N is the sequence number (e.g., `EMAIL_ADDRESS` becomes `EMAIL_ADDRESS_1`, `EMAIL_ADDRESS_2`, etc.)
+
 #### Adding new [Regex filters][]
 
 ```ruby
@@ -568,6 +678,16 @@ TopSecret.configure do |config|
 end
 ```
 
+### Model caching
+
+The MITIE NER model is automatically cached after the first initialization to avoid expensive reloading. All `TopSecret::Text` instances share the same cached model, significantly improving performance.
+
+If you need to clear the cache (e.g., after changing the model path), use:
+
+```ruby
+TopSecret::Text.clear_model_cache!
+```
+
 ### 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):
@@ -624,6 +744,39 @@ TopSecret.configure do |config|
 end
 ```
 
+## Production
+
+### Deploying the Model File
+
+Due to the large size of `ner_model.dat`, you'll want to avoid committing it to version control. Use [Trove][] to handle deploying the model file in production:
+
+```ruby
+# Rakefile
+Rake::Task["assets:precompile"].enhance do
+  Trove.pull
+end
+```
+
+This ensures the model file is downloaded during deployment.
+
+### Eager-Loading the Model
+
+To avoid cold-start performance issues, consider eager-loading the model after initialization. This must happen after initialization because the `.dat` file needs to exist first:
+
+```ruby
+# config/application.rb
+
+config.after_initialize do
+  if TopSecret.model_path && File.exist?(TopSecret.model_path)
+    TopSecret::Text.shared_model
+  end
+end
+```
+
+This pre-loads the MITIE model into the shared cache, ensuring the first request doesn't incur the model loading overhead.
+
+[Trove]: https://github.com/ankane/trove
+
 ## 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.

data/lib/top_secret/category.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module TopSecret
+  # Represents a category of sensitive information (e.g., email, person, credit_card).
+  #
+  # Each category derives a set of method names from its type and can resolve
+  # those methods against a mapping to return filtered results.
+  #
+  # @example
+  #   category = TopSecret::Category.new(:email)
+  #   category.plural          # => :emails
+  #   category.predicate       # => :emails?
+  #   category.mapping_method  # => :email_mapping
+  class Category
+    MAPPING_SUFFIX = "_mapping"
+
+    # @return [String] the category type (e.g., "email", "credit_card")
+    attr_reader :type
+
+    # Builds categories from a mapping's keys and a list of filters.
+    #
+    # @param mapping [Hash] the label-to-value mapping (e.g., +{EMAIL_1: "ralph@example.com"}+)
+    # @param filters [Array<TopSecret::Filters::Regex, TopSecret::Filters::NER>] active filters
+    # @return [Array<Category>] unique categories derived from the mapping and filters
+    def self.from(mapping:, filters:)
+      types_from_mapping = mapping.keys.map { |key| type_from_key(key).downcase }
+
+      types_from_filters = filters.map { |filter| filter.label.downcase }
+
+      (types_from_mapping + types_from_filters).uniq.map { |type| new(type) }
+    end
+
+    # Extracts the label type from a key symbol.
+    #
+    # @param key [Symbol] a label key (e.g., :EMAIL_1, :CREDIT_CARD_2)
+    # @return [String] the label type (e.g., "EMAIL", "CREDIT_CARD")
+    def self.type_from_key(key)
+      key.to_s.rpartition(TopSecret::LABEL_DELIMITER).first
+    end
+
+    # @param type [String, Symbol] the category type
+    def initialize(type)
+      @type = type.to_s
+    end
+
+    # Whether this category recognizes the given method name.
+    #
+    # @param method_name [Symbol] the method name to check
+    # @return [Boolean]
+    def respond_to_method?(method_name)
+      method_names.include?(method_name)
+    end
+
+    # @return [Symbol] the pluralized type (e.g., +:emails+)
+    def plural
+      @type.pluralize.to_sym
+    end
+
+    # @return [Symbol] the predicate method name (e.g., +:emails?+)
+    def predicate
+      :"#{plural}?"
+    end
+
+    # @return [Symbol] the mapping method name (e.g., +:email_mapping+)
+    def mapping_method
+      if @type.end_with?(MAPPING_SUFFIX)
+        :"#{@type.pluralize}#{MAPPING_SUFFIX}"
+      else
+        :"#{@type}#{MAPPING_SUFFIX}"
+      end
+    end
+
+    # @return [Symbol] the mapping predicate method name (e.g., +:email_mapping?+)
+    def mapping_predicate
+      :"#{mapping_method}?"
+    end
+
+    # Whether the mapping contains any keys belonging to this category.
+    #
+    # @param mapping [Hash] the label-to-value mapping
+    # @return [Boolean]
+    def matches?(mapping)
+      mapping.any? { |key, _| key.to_s.match?(key_pattern) }
+    end
+
+    # Resolves a method name against the mapping, returning the appropriate result.
+    #
+    # @param method_name [Symbol] one of {#plural}, {#predicate}, {#mapping_method}, or {#mapping_predicate}
+    # @param mapping [Hash] the label-to-value mapping
+    # @return [Hash, Array, Boolean] filtered mapping, values, or boolean depending on the method
+    # @raise [ArgumentError] if the method name is not recognized
+    def resolve(method_name, mapping)
+      filtered = filter_mapping(mapping)
+
+      case method_name
+      when mapping_method then filtered
+      when plural then filtered.values
+      when predicate, mapping_predicate then filtered.any?
+      else
+        raise ArgumentError, "#{method_name} is not a recognized method for category '#{@type}'"
+      end
+    end
+
+    private
+
+    def method_names
+      @method_names ||= Set[plural, predicate, mapping_method, mapping_predicate].freeze
+    end
+
+    def key_pattern
+      @key_pattern ||= /\A#{Regexp.escape(@type.upcase)}#{Regexp.escape(TopSecret::LABEL_DELIMITER)}\d+\z/
+    end
+
+    def filter_mapping(mapping)
+      mapping.select { |key, _| key.to_s.match?(key_pattern) }
+    end
+  end
+end

data/lib/top_secret/constants.rb

@@ -25,4 +25,7 @@ module TopSecret
 
   # @return [Float] The minimum confidence score for NER filtering
   MIN_CONFIDENCE_SCORE = 0.5
+
+  # @return [String] The delimiter used in label names
+  LABEL_DELIMITER = "_"
 end

data/lib/top_secret/error.rb

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

data/lib/top_secret/mapping.rb

@@ -1,6 +1,34 @@
 # frozen_string_literal: true
 
 module TopSecret
+  # Provides dynamic category methods for querying sensitive information by type.
+  #
+  # This module automatically generates methods for accessing sensitive information
+  # organized by category (emails, credit cards, people, etc.). Methods are available
+  # for all default filter types and any custom labels used in the mapping.
+  #
+  # @example Querying emails
+  #   result = TopSecret::Text.filter("Contact ralph@example.com")
+  #   result.emails?         # => true
+  #   result.emails          # => ["ralph@example.com"]
+  #   result.email_mapping   # => {:EMAIL_1=>"ralph@example.com"}
+  #
+  # @example With no matches
+  #   result = TopSecret::Text.filter("No sensitive data")
+  #   result.emails?         # => false
+  #   result.emails          # => []
+  #   result.email_mapping   # => {}
+  #
+  # @example Custom labels
+  #   result = TopSecret::Text.filter(
+  #     "user[at]example.com",
+  #     email_filter: TopSecret::Filters::Regex.new(
+  #       label: "EMAIL_ADDRESS",
+  #       regex: /\w+\[at\]\w+\.\w+/
+  #     )
+  #   )
+  #   result.email_addresses          # => ["user[at]example.com"]
+  #   result.email_address_mapping    # => {:EMAIL_ADDRESS_1=>"user[at]example.com"}
   module Mapping
     # @return [Boolean] Whether sensitive information was found
     def sensitive?
@@ -11,5 +39,49 @@ module TopSecret
     def safe?
       !sensitive?
     end
+
+    def method_missing(method_name, *args, &block)
+      category = category_for(method_name)
+
+      if category
+        result = category.resolve(method_name, mapping)
+        define_singleton_method(method_name) { result }
+        result
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      category_for(method_name) || super
+    end
+
+    # Returns categories that have matches in the mapping.
+    #
+    # @return [Array<Symbol>] List of categories with matches
+    def categories
+      @categories ||= category_objects.select { |c| c.matches?(mapping) }.map { |c| c.type.to_sym }
+    end
+
+    private
+
+    def category_objects
+      @category_objects ||= Category.from(mapping:, filters: default_filters)
+    end
+
+    def category_for(method_name)
+      category_objects.find { |c| c.respond_to_method?(method_name) }
+    end
+
+    def default_filters
+      @default_filters ||= [
+        TopSecret.credit_card_filter,
+        TopSecret.email_filter,
+        TopSecret.phone_number_filter,
+        TopSecret.ssn_filter,
+        TopSecret.people_filter,
+        TopSecret.location_filter
+      ].compact
+    end
   end
 end

data/lib/top_secret/text/global_mapping.rb

@@ -16,7 +16,7 @@ module TopSecret
       # Creates a new GlobalMapping instance
       def initialize
         @mapping = {}
-        @label_counters = {}
+        @sequence = LabelSequence.new
       end
 
       # Builds the global mapping by processing all individual results
@@ -32,7 +32,7 @@ module TopSecret
       private
 
       attr_reader :mapping
-      attr_reader :label_counters
+      attr_reader :sequence
 
       # Processes a single result, adding new values to the global mapping
       #
@@ -41,23 +41,10 @@ module TopSecret
         result.mapping.each do |individual_key, value|
           next if mapping.key?(value)
 
-          mapping[value] = generate_global_key(individual_key)
+          label_type = Category.type_from_key(individual_key)
+          mapping[value] = sequence.next_label(label_type)
         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/label_sequence.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module TopSecret
+  class Text
+    # Generates unique, sequenced label symbols for each label type.
+    #
+    # @example
+    #   sequence = TopSecret::Text::LabelSequence.new
+    #   sequence.next_label("EMAIL")       # => :EMAIL_1
+    #   sequence.next_label("EMAIL")       # => :EMAIL_2
+    #   sequence.next_label("PERSON")      # => :PERSON_1
+    class LabelSequence
+      # Creates a new LabelSequence instance with all counters at zero.
+      def initialize
+        @counters = Hash.new(0)
+      end
+
+      # Returns the next sequenced label for the given label type.
+      #
+      # @param label_type [String] the label type (e.g., "EMAIL", "CREDIT_CARD")
+      # @return [Symbol] the sequenced label (e.g., :EMAIL_1, :EMAIL_2)
+      def next_label(label_type)
+        @counters[label_type] += 1
+        :"#{label_type}#{TopSecret::LABEL_DELIMITER}#{@counters[label_type]}"
+      end
+    end
+  end
+end

data/lib/top_secret/text.rb

@@ -1,15 +1,47 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/object/blank"
 require_relative "null_model"
 require_relative "text/result"
 require_relative "text/batch_result"
 require_relative "text/scan_result"
 require_relative "text/global_mapping"
+require_relative "text/label_sequence"
 
 module TopSecret
   # Processes text to identify and redact sensitive information using configured filters.
   class Text
+    @mutex = Mutex.new
+
+    class << self
+      # Returns a cached MITIE model instance to avoid expensive reinitialization
+      #
+      # @return [Mitie::NER, NullModel] The cached model instance
+      def shared_model
+        return @shared_model if @shared_model
+
+        @mutex.synchronize do
+          return @shared_model if @shared_model
+
+          @shared_model = if TopSecret.model_path
+            Mitie::NER.new(TopSecret.model_path)
+          else
+            NullModel.new
+          end
+        end
+      end
+
+      # Clears the cached model, forcing reinitialization on next access
+      #
+      # @return [void]
+      def clear_model_cache!
+        @mutex.synchronize do
+          @shared_model = nil
+        end
+      end
+    end
+
     # @param input [String] The original text to be filtered
     # @param filters [Hash, nil] Optional set of filters to override the defaults
     # @param custom_filters [Array] Additional custom filters to apply
@@ -170,6 +202,8 @@ module TopSecret
     # @param label [String] Label identifying the filter type
     # @return [void]
     def build_mapping(values, label:)
+      validate_label! label
+
       values.uniq.each.with_index(1) do |value, index|
         filter = "#{label}_#{index}"
         mapping.merge!({filter.to_sym => value})
@@ -208,6 +242,40 @@ module TopSecret
       merged_filters.assert_valid_keys(*default_filters.keys)
     end
 
+    # Validates that a label conforms to the required format for redaction placeholders.
+    #
+    # Labels must meet the following criteria:
+    # - Start with a letter (a-z, A-Z)
+    # - End with a letter (a-z, A-Z)
+    # - Contain only letters and single underscores (no consecutive underscores)
+    # - Not be blank or nil
+    #
+    # Valid labels will have `_N` appended automatically during mapping, where N is the sequence number.
+    #
+    # @param label [String] The label to validate
+    # @return [void]
+    # @raise [Error::MalformedLabel] If the label is blank or doesn't meet format requirements
+    #
+    # @example Valid labels
+    #   validate_label!("EMAIL")           # Valid
+    #   validate_label!("IP_ADDRESS")      # Valid
+    #   validate_label!("CREDIT_CARD")     # Valid
+    #
+    # @example Invalid labels
+    #   validate_label!("_EMAIL")          # Invalid - starts with underscore
+    #   validate_label!("EMAIL_")          # Invalid - ends with underscore
+    #   validate_label!("EMAIL1")          # Invalid - ends with digit
+    #   validate_label!("EMAIL__ADDRESS")  # Invalid - consecutive underscores
+    #   validate_label!("EMAIL*ADDRESS")   # Invalid - special characters
+    #   validate_label!("")                # Invalid - blank
+    def validate_label!(label)
+      raise Error::MalformedLabel, "You must provide a label." if label.blank?
+
+      unless label.match?(/\A[a-zA-Z]+(_[a-zA-Z]+)*\z/)
+        raise Error::MalformedLabel, "Unsupported label. Labels must contain only letters and underscores: '#{label}'"
+      end
+    end
+
     # Returns the default filters configuration hash
     #
     # @return [Hash] Hash containing all configured default filters, keyed by filter name
@@ -224,15 +292,11 @@ module TopSecret
     end
 
     # Creates the default model based on configuration.
-    # Returns a MITIE NER model if a model path is configured, otherwise returns a null model.
+    # Returns the cached shared model to avoid expensive reinitialization.
     #
     # @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
+      Text.shared_model
     end
   end
 end

data/lib/top_secret/version.rb

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

data/lib/top_secret.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 # dependencies
-require "active_support/configurable"
-require "active_support/ordered_options"
+require "active_support/core_ext/module/attribute_accessors"
 require "mitie"
 
 # modules
 require_relative "top_secret/version"
 require_relative "top_secret/constants"
+require_relative "top_secret/category"
 require_relative "top_secret/mapping"
 require_relative "top_secret/filters/ner"
 require_relative "top_secret/filters/regex"
@@ -44,17 +44,21 @@ require_relative "top_secret/filtered_text"
 # @!attribute [rw] location_filter
 #   @return [TopSecret::Filters::NER] filter for location names
 module TopSecret
-  include ActiveSupport::Configurable
+  mattr_accessor :model_path, default: MODEL_PATH
+  mattr_accessor :min_confidence_score, default: MIN_CONFIDENCE_SCORE
 
-  config_accessor :model_path, default: MODEL_PATH
-  config_accessor :min_confidence_score, default: MIN_CONFIDENCE_SCORE
+  mattr_accessor :custom_filters, default: []
 
-  config_accessor :custom_filters, default: []
+  mattr_accessor :credit_card_filter, default: TopSecret::Filters::Regex.new(label: "CREDIT_CARD", regex: CREDIT_CARD_REGEX)
+  mattr_accessor :email_filter, default: TopSecret::Filters::Regex.new(label: "EMAIL", regex: EMAIL_REGEX)
+  mattr_accessor :phone_number_filter, default: TopSecret::Filters::Regex.new(label: "PHONE_NUMBER", regex: PHONE_REGEX)
+  mattr_accessor :ssn_filter, default: TopSecret::Filters::Regex.new(label: "SSN", regex: SSN_REGEX)
+  mattr_accessor :people_filter, default: TopSecret::Filters::NER.new(label: "PERSON", tag: :person)
+  mattr_accessor :location_filter, default: TopSecret::Filters::NER.new(label: "LOCATION", tag: :location)
 
-  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)
+  class << self
+    def configure
+      yield self
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: top_secret
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Steve Polito
@@ -58,6 +58,7 @@ files:
 - README.md
 - Rakefile
 - lib/top_secret.rb
+- lib/top_secret/category.rb
 - lib/top_secret/constants.rb
 - lib/top_secret/error.rb
 - lib/top_secret/filtered_text.rb
@@ -69,6 +70,7 @@ files:
 - lib/top_secret/text.rb
 - lib/top_secret/text/batch_result.rb
 - lib/top_secret/text/global_mapping.rb
+- lib/top_secret/text/label_sequence.rb
 - lib/top_secret/text/result.rb
 - lib/top_secret/text/scan_result.rb
 - lib/top_secret/version.rb
@@ -94,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Filter sensitive information from free text.
 test_files: []