sec_id 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b0779f0d2735ded84be536bcc9690a4b106c729b03aab007a0458b6512020e8
-  data.tar.gz: 3b4d99c3534856e5e05ff68cec5355f3c7a2665e2854dad5415815e275a734b1
+  metadata.gz: bc458a32d8a5cb8fc4db2b1ab4c635a6c88e4160d38948e4ce779e90b039bd3c
+  data.tar.gz: 298298a51ca424aef20c814ed620e35d32bbfe9bf285fe1f6ee6f44bac163980
 SHA512:
-  metadata.gz: ec036b3fbf2c3d7a89ec823fed2dea6c8cb92be1ede8792bae623c1474454141a3dcc3da27d14c5e3734b050dd95b25672552fc9f4c6983bc68d807a7493d392
-  data.tar.gz: 397e7c17dd46c8aad067262289307317e04cdba4fac65d890aa3e3ff1a1b9ecf175ab916d9600dab7a7a5d4629b54f7750fd40f11c79ed220d3bca339a210d0c
+  metadata.gz: 78650675337ce8a03970e4b1227713aaa0adafb8c18da35466099add8fc39389c8b02583602c18f9aeb59a340ee6b9db9f42ef7662d96284dd0ed93336a50a6a
+  data.tar.gz: 27d54f707d2ec471218a15e6f9dadc2d78d3f46985084f1e18be921b83691f4fe5cd4d82d793ae9cbb34c3e55df30e2966aa834b5942606dfa81d5e3d38e4799

data/CHANGELOG.md

@@ -8,6 +8,20 @@ and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
 
 ## [Unreleased]
 
+## [5.2.0] - 2026-02-24
+
+### Added
+
+- `SecID.scan` and `SecID.extract` methods for finding identifiers in freeform text — returns `Scanner::Match` objects (`Data.define(:type, :raw, :range, :identifier)`) with the validated identifier instance; supports `types:` filtering, hyphenated identifiers, and compound patterns (OCC with spaces, FISN with slashes)
+- `SecID.explain` method for debugging identifier detection — returns per-type validation results showing exactly why each type matched or rejected the input
+- `on_ambiguous:` option for `SecID.parse` and `SecID.parse!` — `:first` (default, existing behavior), `:raise` (raises `AmbiguousMatchError`), `:all` (returns array of all matching instances)
+- `SecID::AmbiguousMatchError` exception class for ambiguous identifier detection
+- `#as_json` method on all identifier types (delegates to `#to_h`) and on `Errors` (delegates to `#details`) for JSON serialization compatibility
+- `SecID::IBAN.supported_countries` class method returning sorted array of all supported country codes
+- `SecID::CFI.categories` class method returning the categories hash
+- `SecID::CFI.groups_for(category_code)` class method returning groups hash for a given category
+
+
 ## [5.1.0] - 2026-02-19
 
 ### Added

data/README.md

@@ -1,6 +1,6 @@
 # SecID [![Gem Version](https://img.shields.io/gem/v/sec_id)](https://rubygems.org/gems/sec_id) [![Codecov](https://img.shields.io/codecov/c/github/svyatov/sec_id)](https://app.codecov.io/gh/svyatov/sec_id) [![CI](https://github.com/svyatov/sec_id/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/sec_id/actions?query=workflow%3ACI)
 
-> Validate securities identification numbers with ease!
+> A Ruby toolkit for securities identifiers — validate, parse, normalize, detect, and convert.
 
 ## Table of Contents
 
@@ -8,6 +8,8 @@
 - [Installation](#installation)
 - [Supported Standards and Usage](#supported-standards-and-usage)
   - [Metadata Registry](#metadata-registry) - enumerate, filter, look up, and detect identifier types
+  - [Text Scanning](#text-scanning) - find identifiers in freeform text
+  - [Debugging Detection](#debugging-detection) - understand why strings match or don't
   - [Structured Validation](#structured-validation) - detailed error codes and messages
   - [ISIN](#isin) - International Securities Identification Number
   - [CUSIP](#cusip) - Committee on Uniform Securities Identification Procedures
@@ -38,7 +40,7 @@ Ruby 3.2+ is required.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sec_id', '~> 5.1'
+gem 'sec_id', '~> 5.2'
 ```
 
 And then execute:
@@ -67,6 +69,7 @@ All identifier classes provide `valid?`, `errors`, `validate`, `validate!` metho
 
 **All identifiers** support hash serialization:
 - `#to_h` - returns a hash with `:type`, `:full_id`, `:normalized`, `:valid`, and `:components` keys
+- `#as_json` - same as `#to_h`, for JSON serialization compatibility (Rails, `JSON.generate`, etc.)
 
 ```ruby
 SecID::ISIN.new('US5949181045').to_h
@@ -144,6 +147,56 @@ SecID.parse('594918104', types: [:cusip])         # => #<SecID::CUSIP>
 # Bang version raises on failure
 SecID.parse!('US5949181045')                      # => #<SecID::ISIN>
 SecID.parse!('unknown')                           # raises SecID::InvalidFormatError
+
+# Handle ambiguous matches
+SecID.parse('514000', on_ambiguous: :first)        # => #<SecID::WKN> (default)
+SecID.parse('514000', on_ambiguous: :raise)        # raises SecID::AmbiguousMatchError
+SecID.parse('514000', on_ambiguous: :all)          # => [#<SecID::WKN>, #<SecID::Valoren>, #<SecID::CIK>]
+SecID.parse('US5949181045', on_ambiguous: :raise)  # => #<SecID::ISIN> (unambiguous, no error)
+```
+
+### Text Scanning
+
+Find identifiers embedded in freeform text:
+
+```ruby
+# Extract all identifiers from text
+matches = SecID.extract('Portfolio: US5949181045, 594918104, B0YBKJ7')
+matches.map(&:type)   # => [:isin, :cusip, :sedol]
+matches.first.raw     # => "US5949181045"
+matches.first.range   # => 11...23
+matches.first.identifier.country_code  # => "US"
+
+# Lazy scanning with Enumerator
+SecID.scan('Buy US5949181045 now').each { |m| puts m.type }
+
+# Filter by types
+SecID.extract('514000', types: [:valoren])  # => only Valoren matches
+
+# Handles hyphenated identifiers
+match = SecID.extract('ID: US-5949-1810-45').first
+match.raw                    # => "US-5949-1810-45"
+match.identifier.normalized  # => "US5949181045"
+```
+
+> **Known limitations:** Format-only types (CIK, Valoren, WKN, CFI) can false-positive on
+> common numbers and short words in prose — use the `types:` filter to restrict scanning when
+> this is a concern. Identifiers prefixed with special characters (e.g. `#US5949181045`) may be
+> consumed as a single token by CUSIP's `*@#` character class and fail validation, preventing
+> the embedded identifier from being found.
+
+### Debugging Detection
+
+Understand why a string matches or doesn't match specific identifier types:
+
+```ruby
+result = SecID.explain('US5949181040')
+isin = result[:candidates].find { |c| c[:type] == :isin }
+isin[:valid]                      # => false
+isin[:errors].first[:error]       # => :invalid_check_digit
+
+# Filter to specific types
+SecID.explain('US5949181045', types: %i[isin cusip])
 ```
 
 ### Structured Validation
@@ -396,6 +449,11 @@ iban.to_pretty_s           # => 'DE89 3704 0044 0532 0130 00'
 
 Full BBAN structural validation is supported for EU/EEA countries. Other countries have length-only validation.
 
+```ruby
+# List all supported countries
+SecID::IBAN.supported_countries  # => ["AD", "AE", "AT", "BE", "BG", "CH", ...]
+```
+
 ### CIK
 
 > [Central Index Key](https://en.wikipedia.org/wiki/Central_Index_Key) - a 10-digit number used by the SEC to identify corporations and individuals who have filed disclosures.
@@ -522,6 +580,12 @@ cfi.registered?    # => true
 
 CFI validates the category code (position 1) against 14 valid values and the group code (position 2) against valid values for that category. Attribute positions 3-6 accept any letter A-Z, with X meaning "not applicable".
 
+```ruby
+# Introspect valid codes
+SecID::CFI.categories            # => { "E" => :equity, "C" => :collective_investment_vehicles, ... }
+SecID::CFI.groups_for('E')       # => { "S" => :common_shares, "P" => :preferred_shares, ... }
+```
+
 ### FISN
 
 > [Financial Instrument Short Name](https://en.wikipedia.org/wiki/ISO_18774) - a human-readable short name for financial instruments per ISO 18774.

data/lib/sec_id/base.rb

@@ -52,6 +52,7 @@ module SecID
     # @api private
     def self.inherited(subclass)
       super
+      # Skip anonymous classes and classes outside the SecID namespace (e.g. in tests)
       SecID.__send__(:register_identifier, subclass) if subclass.name&.start_with?('SecID::')
     end
 
@@ -89,6 +90,13 @@ module SecID
       }
     end
 
+    # Returns a JSON-compatible hash representation.
+    #
+    # @return [Hash]
+    def as_json(*)
+      to_h
+    end
+
     protected
 
     # @return [String]

data/lib/sec_id/cfi.rb

@@ -164,7 +164,22 @@ module SecID
         'C' => :combined_instruments,
         'M' => :miscellaneous
       }
-    }.freeze
+    }.each_value(&:freeze).freeze
+
+    # Returns the category codes hash.
+    #
+    # @return [Hash{String => Symbol}]
+    def self.categories
+      CATEGORIES
+    end
+
+    # Returns the groups hash for a given category code.
+    #
+    # @param category_code [String] single-letter category code
+    # @return [Hash{String => Symbol}, nil]
+    def self.groups_for(category_code)
+      GROUPS[category_code.to_s.upcase]
+    end
 
     # @return [String, nil] the category code (position 1)
     attr_reader :category_code

data/lib/sec_id/errors.rb

@@ -63,5 +63,12 @@ module SecID
     def to_a
       messages
     end
+
+    # Returns a JSON-compatible array of error detail hashes.
+    #
+    # @return [Array<Hash>]
+    def as_json(*)
+      details
+    end
   end
 end

data/lib/sec_id/iban.rb

@@ -33,6 +33,13 @@ module SecID
       (?<rest>[A-Z0-9]{13,32})
     \z/x
 
+    # Returns sorted array of all supported country codes.
+    #
+    # @return [Array<String>]
+    def self.supported_countries
+      @supported_countries ||= (COUNTRY_RULES.keys + LENGTH_ONLY_COUNTRIES.keys).sort.freeze
+    end
+
     # @return [String, nil] the ISO 3166-1 alpha-2 country code
     attr_reader :country_code
 

data/lib/sec_id/scanner.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module SecID
+  # Immutable value object representing a matched identifier found in text.
+  Match = Data.define(:type, :raw, :range, :identifier)
+
+  # Finds securities identifiers in freeform text using regex candidate extraction,
+  # length/charset pre-filtering, and cursor-based overlap prevention.
+  #
+  # @api private
+  class Scanner
+    # Composite regex for candidate extraction.
+    #
+    # Three named groups tried left-to-right via alternation:
+    # - fisn: contains `/` (unique FISN delimiter)
+    # - occ: contains structural spaces + date/type pattern
+    # - simple: common alphanumeric tokens (covers all other types)
+    CANDIDATE_RE = %r{
+      (?<![A-Za-z0-9*@\#/.$])
+      (?:
+        (?<fisn>[A-Za-z0-9](?:[A-Za-z0-9 ]{0,33}[A-Za-z0-9])?/[A-Za-z0-9](?:[A-Za-z0-9 ]{0,33}[A-Za-z0-9])?)
+        |
+        (?<occ>[A-Za-z]{1,6}\ {1,5}\d{6}[CcPp]\d{8})
+        |
+        (?<simple>[A-Za-z0-9*@\#](?:[A-Za-z0-9*@\#-]{0,40}[A-Za-z0-9*@\#])?)
+      )
+      (?![A-Za-z0-9*@\#.])
+    }x
+
+    # @param identifier_list [Array<Class>] registered identifier classes
+    def initialize(identifier_list)
+      @classes = identifier_list.dup.freeze
+      precompute
+    end
+
+    # Scans text for identifiers, yielding or returning matches.
+    #
+    # @param text [String, nil] the text to scan
+    # @param classes [Array<Class>, nil] restrict to specific classes
+    # @return [Enumerator<Match>] if no block given
+    # @yieldparam match [Match]
+    def call(text, classes: nil, &block)
+      return enum_for(:call, text, classes: classes) unless block
+
+      input = text.to_s
+      return if input.empty?
+
+      scan_text(input, classes || @classes, &block)
+    end
+
+    private
+
+    # @return [void]
+    def precompute # rubocop:disable Metrics/AbcSize
+      build_key_table
+      build_priority_table
+      @fisn_classes = @classes.select { |k| k.short_name == 'FISN' }
+      @occ_classes = @classes.select { |k| k.short_name == 'OCC' }
+      @simple_classes = @classes - @fisn_classes - @occ_classes
+      @candidates_by_length = Hash.new { |h, k| h[k] = [] }
+      @classes.each do |klass|
+        id_length = klass::ID_LENGTH
+        lengths = id_length.is_a?(Range) ? id_length : [id_length]
+        lengths.each { |len| @candidates_by_length[len] << klass }
+      end
+      @candidates_by_length.each_value(&:freeze)
+    end
+
+    # @return [void]
+    def build_key_table
+      @key_for = {}
+      @classes.each { |klass| @key_for[klass] = klass.short_name.downcase.to_sym }
+      @key_for.freeze
+    end
+
+    # @return [void]
+    def build_priority_table
+      @priority_for = {}
+      @classes.each_with_index do |klass, index|
+        check_digit_rank = klass.has_check_digit? ? 0 : 1
+        id_length = klass::ID_LENGTH
+        range_size = id_length.is_a?(Range) ? id_length.size : 1
+        @priority_for[klass] = [check_digit_rank, range_size, index].freeze
+      end
+      @priority_for.freeze
+    end
+
+    # @param input [String]
+    # @param target_classes [Array<Class>]
+    # @return [void]
+    def scan_text(input, target_classes)
+      pos = 0
+      while pos < input.length
+        match_data = CANDIDATE_RE.match(input, pos)
+        break unless match_data
+
+        result = identify_candidate(match_data, target_classes)
+        if result
+          yield result
+          pos = match_data.end(0)
+        else
+          pos = match_data.begin(0) + 1
+        end
+      end
+    end
+
+    # @param match_data [MatchData]
+    # @param target_classes [Array<Class>]
+    # @return [Match, nil]
+    def identify_candidate(match_data, target_classes)
+      raw = match_data[0]
+      start_pos = match_data.begin(0)
+
+      if match_data[:fisn]
+        try_classes(raw, raw.upcase, start_pos, target_classes & @fisn_classes)
+      elsif match_data[:occ]
+        try_classes(raw, raw.upcase, start_pos, target_classes & @occ_classes)
+      else
+        cleaned = raw.gsub('-', '').upcase
+        try_classes(raw, cleaned, start_pos, target_classes & @simple_classes)
+      end
+    end
+
+    # @return [Match, nil]
+    def try_classes(raw, cleaned, start_pos, classes)
+      best = best_match(cleaned, classes)
+      return unless best
+
+      end_pos = start_pos + raw.length
+      Match.new(type: @key_for[best], raw: raw, range: start_pos...end_pos, identifier: best.new(cleaned))
+    end
+
+    # @return [Class, nil]
+    def best_match(cleaned, classes)
+      return if classes.empty?
+
+      candidates = (@candidates_by_length[cleaned.length] || []) & classes
+      return if candidates.empty?
+
+      validated = candidates.select { |k| cleaned.match?(k::VALID_CHARS_REGEX) && k.valid?(cleaned) }
+      validated.min_by { |k| @priority_for[k] }
+    end
+  end
+end

data/lib/sec_id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SecID
-  VERSION = '5.1.0'
+  VERSION = '5.2.0'
 end

data/lib/sec_id.rb

@@ -15,6 +15,9 @@ module SecID
   # Raised for type-specific structural errors (invalid prefix, category, group, BBAN, or date).
   class InvalidStructureError < Error; end
 
+  # Raised when multiple identifier types match and on_ambiguous: :raise is used.
+  class AmbiguousMatchError < Error; end
+
   class << self
     # Looks up an identifier class by its symbol key.
     #
@@ -54,45 +57,85 @@ module SecID
       types.any? { |key| self[key].valid?(str) }
     end
 
-    # Parses a string into the most specific matching identifier instance.
-    #
+    # @param text [String, nil] the text to scan
+    # @param types [Array<Symbol>, nil] restrict to specific types
+    # @return [Array<Match>]
+    # @raise [ArgumentError] if any key in types is unknown
+    def extract(text, types: nil)
+      scan(text, types: types).to_a
+    end
+
+    # @param text [String, nil] the text to scan
+    # @param types [Array<Symbol>, nil] restrict to specific types
+    # @return [Enumerator<Match>] if no block given
+    # @yieldparam match [Match]
+    # @raise [ArgumentError] if any key in types is unknown
+    def scan(text, types: nil, &)
+      classes = types&.map { |key| self[key] }
+      scanner.call(text, classes: classes, &)
+    end
+
+    # @param str [String, nil] the identifier string to explain
+    # @param types [Array<Symbol>, nil] restrict to specific types
+    # @return [Hash] hash with :input and :candidates keys
+    def explain(str, types: nil)
+      input = str.to_s.strip
+      target_keys = types || identifier_list.map { |k| k.short_name.downcase.to_sym }
+      candidates = target_keys.map do |key|
+        instance = self[key].new(input)
+        { type: key, valid: instance.valid?, errors: instance.errors.details }
+      end
+      { input: input, candidates: candidates }
+    end
+
     # @param str [String, nil] the identifier string to parse
     # @param types [Array<Symbol>, nil] restrict to specific types (e.g. [:isin, :cusip])
-    # @return [SecID::Base, nil] a valid identifier instance, or nil if no match
-    # @raise [ArgumentError] if any key in types is unknown
-    def parse(str, types: nil)
-      types.nil? ? parse_any(str) : parse_from(str, types)
+    # @param on_ambiguous [:first, :raise, :all] how to handle multiple matches
+    # @return [SecID::Base, nil, Array<SecID::Base>] depends on on_ambiguous mode
+    # @raise [AmbiguousMatchError] when on_ambiguous: :raise and multiple types match
+    def parse(str, types: nil, on_ambiguous: :first)
+      case on_ambiguous
+      when :first then types.nil? ? parse_any(str) : parse_from(str, types)
+      when :raise then parse_strict(str, types)
+      when :all   then parse_all(str, types)
+      else raise ArgumentError, "Unknown on_ambiguous mode: #{on_ambiguous.inspect}"
+      end
     end
 
-    # Parses a string into the most specific matching identifier instance, raising on failure.
-    #
     # @param str [String, nil] the identifier string to parse
     # @param types [Array<Symbol>, nil] restrict to specific types (e.g. [:isin, :cusip])
-    # @return [SecID::Base] a valid identifier instance
+    # @param on_ambiguous [:first, :raise, :all] how to handle multiple matches
+    # @return [SecID::Base, Array<SecID::Base>] depends on on_ambiguous mode
     # @raise [InvalidFormatError] if no matching identifier type is found
-    # @raise [ArgumentError] if any key in types is unknown
-    def parse!(str, types: nil)
-      parse(str, types: types) || raise(InvalidFormatError, parse_error_message(str, types))
+    # @raise [AmbiguousMatchError] when on_ambiguous: :raise and multiple types match
+    def parse!(str, types: nil, on_ambiguous: :first)
+      result = parse(str, types: types, on_ambiguous: on_ambiguous)
+
+      if on_ambiguous == :all
+        raise(InvalidFormatError, parse_error_message(str, types)) if result.empty?
+
+        return result
+      end
+
+      result || raise(InvalidFormatError, parse_error_message(str, types))
     end
 
     private
 
-    # @param klass [Class] the identifier class to register
     # @return [void]
     def register_identifier(klass)
       key = klass.name.split('::').last.downcase.to_sym
       identifier_map[key] = klass
       identifier_list << klass
       @detector = nil
+      @scanner = nil
     end
 
-    # @return [SecID::Base, nil]
     def parse_any(str)
       key = detect(str).first
       key && self[key].new(str)
     end
 
-    # @return [SecID::Base, nil]
     def parse_from(str, types)
       types.each do |key|
         instance = self[key].new(str)
@@ -101,26 +144,37 @@ module SecID
       nil
     end
 
-    # @return [String]
-    def parse_error_message(str, types)
-      base = "No matching identifier type found for #{str.to_s.strip.inspect}"
-      types ? "#{base} among #{types.inspect}" : base
+    def parse_strict(str, types)
+      candidates = resolve_candidates(str, types)
+      raise AmbiguousMatchError, ambiguous_message(str, candidates) if candidates.size > 1
+
+      candidates.first && self[candidates.first].new(str)
     end
 
-    # @return [Detector]
-    def detector
-      @detector ||= Detector.new(identifier_list)
+    def parse_all(str, types)
+      resolve_candidates(str, types).map { |key| self[key].new(str) }
     end
 
-    # @return [Hash{Symbol => Class}]
-    def identifier_map
-      @identifier_map ||= {}
+    # @return [Array<Symbol>]
+    def resolve_candidates(str, types)
+      types ? types.select { |key| self[key].valid?(str) } : detect(str)
     end
 
-    # @return [Array<Class>]
-    def identifier_list
-      @identifier_list ||= []
+    # @return [String]
+    def ambiguous_message(str, candidates)
+      "Ambiguous identifier #{str.to_s.strip.inspect}: matches #{candidates.inspect}"
+    end
+
+    # @return [String]
+    def parse_error_message(str, types)
+      base = "No matching identifier type found for #{str.to_s.strip.inspect}"
+      types ? "#{base} among #{types.inspect}" : base
     end
+
+    def detector = @detector ||= Detector.new(identifier_list)
+    def scanner = @scanner ||= Scanner.new(identifier_list)
+    def identifier_map = @identifier_map ||= {}
+    def identifier_list = @identifier_list ||= []
   end
 end
 
@@ -131,6 +185,7 @@ require 'sec_id/concerns/validatable'
 require 'sec_id/concerns/checkable'
 require 'sec_id/base'
 require 'sec_id/detector'
+require 'sec_id/scanner'
 require 'sec_id/isin'
 require 'sec_id/cusip'
 require 'sec_id/sedol'

data/sec_id.gemspec

@@ -10,10 +10,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Leonid Svyatov']
   spec.email         = ['leonid@svyatov.ru']
 
-  spec.summary       = 'Validate securities identification numbers with ease!'
-  spec.description   = 'Validate, calculate check digits, and parse components of securities identifiers. ' \
-                       'Supports ISIN, CUSIP, CEI, SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN, Valoren, CFI, ' \
-                       'and FISN standards.'
+  spec.summary       = 'A Ruby toolkit for securities identifiers — validate, parse, normalize, detect, and convert.'
+  spec.description   = 'Validate, normalize, parse, and convert securities identifiers. Auto-detect identifier ' \
+                       'type from any string. Calculate and restore check digits. Supports ISIN, CUSIP, CEI, ' \
+                       'SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN, Valoren, CFI, and FISN.'
   spec.homepage      = 'https://github.com/svyatov/sec_id'
   spec.license       = 'MIT'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sec_id
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -9,9 +9,9 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Validate, calculate check digits, and parse components of securities
-  identifiers. Supports ISIN, CUSIP, CEI, SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN, Valoren,
-  CFI, and FISN standards.
+description: Validate, normalize, parse, and convert securities identifiers. Auto-detect
+  identifier type from any string. Calculate and restore check digits. Supports ISIN,
+  CUSIP, CEI, SEDOL, FIGI, LEI, IBAN, CIK, OCC, WKN, Valoren, CFI, and FISN.
 email:
 - leonid@svyatov.ru
 executables: []
@@ -41,6 +41,7 @@ files:
 - lib/sec_id/isin.rb
 - lib/sec_id/lei.rb
 - lib/sec_id/occ.rb
+- lib/sec_id/scanner.rb
 - lib/sec_id/sedol.rb
 - lib/sec_id/valoren.rb
 - lib/sec_id/version.rb
@@ -70,5 +71,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: Validate securities identification numbers with ease!
+summary: A Ruby toolkit for securities identifiers — validate, parse, normalize, detect,
+  and convert.
 test_files: []