registry 0.2.0.pre.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 405967140d2373d27b319d0f74981bc6888223c7bcb3969f0d4e1c09ff85b2bd
-  data.tar.gz: 91bb40d834cc7022af25e52c41f5e622afb959fb9f200abdae1759dd6d9feeb4
+  metadata.gz: 60730b7e7b1943b16358e9ad787af3df00955cbdf4c3acfe44d1099679a4203f
+  data.tar.gz: 3aa8fa552783586504f34bf54ec7f52e1f4362ba9504ba351c379fc4ff94255c
 SHA512:
-  metadata.gz: c852869221ae25d859fa2a60797105aa448b65a1a2d3a0648599b2e3350bdaa13ad9871f5347fda99c01cb2c5924668a342ac23cd57d531651426066b9b69228
-  data.tar.gz: 488f46f1dd10c82f6aba9f9a958f108f1168ce0fedd3eaf2784f5e929b1b8072d631f73b1463d7776efcf7f57fc2a9db41fc3d1717702d1f41969fab0acd8107
+  metadata.gz: c54ebc5c5ad44ce5e8aba1668a476733e599841d200846a55c9ff12fb6baa5b38d97b9e654c27b473ceb66e66fa9aabf2770b3d8c2b29ea6bd68787fc9dab191
+  data.tar.gz: f860b911818a5863c521be653a3dadb9bc077f1e1015c14cc4f70e68cef015a128637ddb70cecb9932767d7a07438d85fb3754c65c181b670e7720520ac86200

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# CHANGELOG
+
+## [0.3.0] - TBD
+
+### Added
+
+- **Thread Safety**: Added optional `thread_safe: true` parameter for concurrent
+  access
+- **Enhanced Error Handling**: New exception hierarchy with
+  `Registry::IndexNotFound`, `Registry::MissingAttributeError`
+- **API Enhancements**:
+  - `exists?(criteria)` method for checking item existence
+  - Better error messages with contextual information
+- **Memory Management**:
+  - Automatic cleanup of method watching
+  - `cleanup!` method for manual memory management
+  - Tracking of watched objects to prevent memory leaks
+
+### Changed
+
+- Improved error messages with more context and suggestions
+- Better handling of edge cases in `where` method
+- Enhanced initialization to support new features
+
+### Technical Improvements
+
+- Added comprehensive test coverage for new features
+- Improved code organization and documentation
+- Better handling of thread safety concerns
+
+## [0.2.0] - Previous Release
+
+- Basic registry functionality
+- Method watching for automatic reindexing
+- Core indexing and querying capabilities

data/README.md

@@ -1,15 +1,14 @@
-[![Version      ](https://img.shields.io/gem/v/registry.svg)](https://rubygems.org/gems/registry)
-[![Build Status ](https://travis-ci.org/TwilightCoders/registry.svg)](https://travis-ci.org/TwilightCoders/registry)
-[![Code Climate ](https://api.codeclimate.com/v1/badges/a18ae809af878357acfa/maintainability)](https://codeclimate.com/github/TwilightCoders/registry/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/a18ae809af878357acfa/test_coverage)](https://codeclimate.com/github/TwilightCoders/registry/test_coverage)
-[![Dependencies ](https://gemnasium.com/badges/github.com/TwilightCoders/registry.svg)](https://gemnasium.com/github.com/TwilightCoders/registry)
-
 # Registry
 
+[![Version](https://img.shields.io/gem/v/registry.svg)](https://rubygems.org/gems/registry)
+[![Build Status](https://github.com/TwilightCoders/registry/workflows/CI/badge.svg)](https://github.com/TwilightCoders/registry/actions)
+[![Code Quality](https://img.shields.io/badge/qlty-monitored-blue)](https://qlty.sh)
+
 Provides a data structure for collecting homogeneous objects and indexing them for quick lookup.
 
 ## Requirements
-Ruby 2.3+
+
+Ruby 3.0+
 
 ## Installation
 
@@ -21,28 +20,72 @@ gem 'registry'
 
 And then execute:
 
-    $ bundle
+```bash
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install registry
+```bash
+gem install registry
+```
 
 ## Usage
 
+### Basic Usage
+
+```ruby
+Person = Struct.new(:id, :name, :email)
+
+registry = Registry.new([
+  Person.new(1, 'Dale', 'jason@twilightcoders.net'),
+  Person.new(2, 'Dale', 'dale@twilightcoders.net')
+])
+
+registry.index(:name)
+
+# Find items using where method
+results = registry.where(name: 'Dale')
+
+# Check if items exist
+registry.exists?(name: 'Dale') #=> true
+
+# Automatic reindexing when attributes change
+d = registry.where(name: 'Dale').first
+d.name = "Jason"
+registry.where(name: 'Jason') # Contains the updated item
+```
+
+### Advanced Features
+
+#### Thread Safety
+
 ```ruby
-  Person = Struct.new(:id, :name, :email)
+# Create a thread-safe registry
+registry = Registry.new(items, thread_safe: true)
+```
 
-  registry = Registry.new([
-    Person.new(1, 'Dale', 'jason@twilightcoders.net'),
-    Person.new(2, 'Dale', 'dale@twilightcoders.net')
-  ])
+#### Memory Management
 
-  registry.index(:name)
+```ruby
+# Clean up method watching for long-lived registries
+registry.cleanup!
+```
 
-  d = registry[:name, 'Dale'].first
-  d.name = "Jason"
+#### Error Handling
 
-  registry.find(:name, 'Jason')
+```ruby
+begin
+  registry.where(nonexistent_index: 'value')
+rescue Registry::IndexNotFound => e
+  puts "Index not found: #{e.message}"
+end
+
+begin
+  registry.add("invalid item")
+rescue Registry::MissingAttributeError => e
+  puts "Missing required attributes: #{e.message}"
+end
 ```
 
 ## Development
@@ -51,7 +94,10 @@ After checking out the repo, run `bundle` to install dependencies. Then, run `bu
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/TwilightCoders/registry. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at
+<https://github.com/TwilightCoders/registry>. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to the
+[Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/lib/registry/index_store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'set'
+
+# Manages index storage and reindexing operations
+module RegistryIndexStore
+  attr_reader :indexes
+
+  def initialize_index_store
+    @indexed = {}
+    @indexes = []
+  end
+
+  # Add one or more indexes to the registry
+  def index(*new_indexes)
+    new_indexes.each do |idx|
+      warn "Index #{idx} already exists!" and next if @indexed.key?(idx)
+
+      # OPTIMIZE: Build index hash directly instead of using group_by + transformation
+      index_hash = {}
+      each do |item|
+        watch_setter(item, idx)
+        add_to_watched_objects(item) # Track watched objects
+
+        # Get the index value and build the index in one pass
+        idx_value = item.send(idx)
+        (index_hash[idx_value] ||= Set.new) << item
+      end
+      @indexed[idx] = index_hash
+      @indexes << idx
+    end
+  end
+
+  # Rebuild all indexes from scratch
+  def reindex!(new_indexes = [])
+    @indexed.clear
+    @indexes.clear
+    index(*new_indexes)
+  end
+
+  # Update an index when an item's value changes
+  def reindex_item(idx, item, old_value, new_value)
+    return unless @indexed.key?(idx)
+
+    @indexed[idx][old_value].delete item
+    (@indexed[idx][new_value] ||= Set.new).add item
+  end
+
+  # Look up items by index value
+  def lookup_index(idx, value)
+    @indexed.dig(idx, value) || Set.new
+  end
+
+  # Check if an index exists
+  def index_exists?(idx)
+    @indexed.key?(idx)
+  end
+end

data/lib/registry/method_watcher.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'set'
+
+# Manages method watching for automatic reindexing when object attributes change
+module RegistryMethodWatcher
+  def initialize_method_watcher
+    @watched_objects = Set.new
+    @method_cache = {}
+  end
+
+  # Add an item to the watched objects set
+  def add_to_watched_objects(item)
+    @watched_objects.add(item)
+  end
+
+  # Remove an item from the watched objects set
+  def remove_from_watched_objects(item)
+    @watched_objects.delete(item)
+  end
+
+  # Set up watching on a setter method to trigger reindexing
+  def watch_setter(item, idx)
+    return if item.frozen?
+
+    ensure_registry_reference(item)
+    setter_method = lookup_setter_method(item.class, idx)
+    return unless setter_method
+
+    watched_method = :"__watched_#{setter_method}"
+    return if item.methods.include?(watched_method)
+
+    install_watched_method(item, idx, setter_method, watched_method)
+  end
+
+  # Remove watching from a setter method
+  def ignore_setter(item, idx)
+    return if item.frozen?
+
+    # Use cached method lookup
+    item_class = item.class
+    cache_key = [item_class, idx]
+    setter_method = @method_cache[cache_key]
+
+    return unless setter_method
+
+    original_method = setter_method
+    watched_method = :"__watched_#{original_method}"
+    renamed_method = :"__unwatched_#{original_method}"
+
+    return unless item.methods.include?(watched_method)
+
+    item.singleton_class.class_eval do
+      alias_method original_method, renamed_method
+      remove_method(watched_method)
+      remove_method(renamed_method)
+    end
+  end
+
+  # Clean up all watched methods from all watched objects
+  def cleanup_watched_methods
+    @watched_objects.each do |item|
+      indexes.each do |idx|
+        ignore_setter(item, idx)
+      end
+    end
+    @watched_objects.clear
+  end
+
+  # Full cleanup of watched methods and cache
+  def cleanup!
+    cleanup_watched_methods
+  end
+
+  private
+
+  def lookup_setter_method(item_class, idx)
+    cache_key = [item_class, idx]
+    @method_cache[cache_key] ||= begin
+      method_name = :"#{idx}="
+      item_class.instance_methods.include?(method_name) ? method_name : nil
+    end
+  end
+
+  def ensure_registry_reference(item)
+    item.instance_variable_set(:@__registry__, self) unless item.instance_variable_defined?(:@__registry__)
+  end
+
+  def install_watched_method(item, idx, setter_method, watched_method)
+    original_method = setter_method
+    renamed_method = :"__unwatched_#{original_method}"
+
+    item.singleton_class.class_eval do
+      define_method(watched_method) do |*args|
+        old_value = send(idx)
+        send(renamed_method, *args).tap do |new_value|
+          instance_variable_get(:@__registry__).send(:reindex_item, idx, self, old_value, new_value)
+        end
+      end
+      alias_method renamed_method, original_method
+      alias_method original_method, watched_method
+    end
+  end
+end

data/lib/registry/query_cache.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Manages query result caching for performance optimization
+module RegistryQueryCache
+  CACHE_SIZE_LIMIT = 1000
+
+  def initialize_query_cache
+    @query_cache = {}
+    @cache_hits = 0
+    @cache_misses = 0
+  end
+
+  # Check cache for a query result
+  def check_cache(cache_key)
+    if @query_cache.key?(cache_key)
+      @cache_hits += 1
+      @query_cache[cache_key]
+    else
+      @cache_misses += 1
+      nil
+    end
+  end
+
+  # Store a query result in the cache
+  def store_in_cache(cache_key, result_set)
+    return if @query_cache.size >= CACHE_SIZE_LIMIT
+
+    @query_cache[cache_key] = result_set.dup
+  end
+
+  # Invalidate all cached queries (called when registry changes)
+  def invalidate_cache
+    @query_cache.clear
+  end
+
+  # Get cache performance statistics
+  def cache_stats
+    total_queries = @cache_hits + @cache_misses
+    return { hits: 0, misses: 0, hit_rate: 0.0, total_queries: 0 } if total_queries.zero?
+
+    {
+      hits: @cache_hits,
+      misses: @cache_misses,
+      hit_rate: (@cache_hits.to_f / total_queries * 100).round(2),
+      total_queries: total_queries
+    }
+  end
+end

data/lib/registry/version.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+REGISTRY_VERSION = '0.3.0'

data/lib/registry.rb

@@ -1,13 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'registry/version'
+
+require 'set'
+require_relative 'registry/index_store'
+require_relative 'registry/query_cache'
+require_relative 'registry/method_watcher'
+
 class Registry < Set
+  include RegistryIndexStore
+  include RegistryQueryCache
+  include RegistryMethodWatcher
 
-  MoreThanOneRecordFound = Class.new(StandardError)
+  # Exception classes for better error handling
+  class RegistryError < StandardError; end
+  class MoreThanOneRecordFound < RegistryError; end
+  class IndexNotFound < RegistryError; end
+  class MissingAttributeError < RegistryError; end
+  class ThreadSafetyError < RegistryError; end
 
-  VERSION = "0.2.0-1"
+  VERSION = REGISTRY_VERSION
 
   DEFAULT_INDEX = :object_id
 
-  def initialize(*args, indexes: [])
-    @indexed = {}
+  def initialize(*args, indexes: [], thread_safe: false)
+    @thread_safe = thread_safe
+    @mutex = Mutex.new if @thread_safe
+
+    # Initialize module-specific state
+    initialize_index_store
+    initialize_query_cache
+    initialize_method_watcher
+
     super(*args)
     reindex!(indexes)
   end
@@ -20,10 +44,6 @@ class Registry < Set
     @indexed
   end
 
-  def indexes
-    @indexed.keys - [:object_id]
-  end
-
   def delete(item)
     @indexed.each do |idx, store|
       ignore_setter(item, idx) if include?(item)
@@ -31,11 +51,15 @@ class Registry < Set
         idx_value = item.send(idx)
         (store[idx_value] ||= Set.new).delete(item)
         store.delete(idx_value) if store[idx_value].empty?
-      rescue NoMethodError => e
-        raise "#{item.name} cannot be added because indexable attribute (#{idx}) is missing."
+      rescue NoMethodError
+        raise MissingAttributeError,
+              "Item #{item.inspect} cannot be deleted because indexable attribute '#{idx}' " \
+              'is missing or not accessible.'
       end
     end
-    super(item)
+    remove_from_watched_objects(item)
+    invalidate_cache
+    super
   end
 
   def add(item)
@@ -43,99 +67,143 @@ class Registry < Set
       watch_setter(item, idx) unless include?(item)
       begin
         idx_value = item.send(idx)
-        (store[idx_value] ||= Set.new) << (item)
-      rescue NoMethodError => e
-        raise "#{item.name} cannot be added because indexable attribute (#{idx}) is missing."
+        (store[idx_value] ||= Set.new) << item
+      rescue NoMethodError
+        raise MissingAttributeError,
+              "Item #{item.inspect} cannot be added because indexable attribute '#{idx}' is missing or not accessible."
       end
     end
-    super(item)
+    add_to_watched_objects(item) unless include?(item)
+    invalidate_cache
+    super
   end
   alias << add
 
   def find!(search_criteria)
-    _find(search_criteria) { raise MoreThanOneRecordFound, "There were more than 1 records found" }
+    _find(search_criteria) { raise MoreThanOneRecordFound, 'There were more than 1 records found' }
   end
 
   def find(search_criteria)
-    _find(search_criteria) { warn "There were more than 1 records found" }
+    _find(search_criteria) { warn 'There were more than 1 records found' }
   end
 
-  def where(search_criteria)
-    sets = search_criteria.inject([]) do |sets, (idx, value)|
-      raise "No '#{idx}' index! Add it with '.index(:#{idx})'" unless @indexed.include?(idx)
-      sets << (@indexed.dig(idx, value) || Set.new)
-    end
+  def where(limit: nil, offset: 0, **search_criteria)
+    with_thread_safety do
+      # Handle nil or empty criteria
+      return new_registry_from_set(Set.new) if search_criteria.nil? || search_criteria.empty?
+
+      cache_key = [:where, search_criteria.sort, limit, offset]
+      cached_result = check_cache(cache_key)
+      return new_registry_from_set(cached_result) if cached_result
+
+      result_set = if search_criteria.size == 1
+                     single_criteria_search(search_criteria)
+                   else
+                     multi_criteria_search(search_criteria)
+                   end
+
+      # Apply pagination if specified
+      if limit || offset.positive?
+        records_array = result_set.to_a
+        start_idx = offset
+        end_idx = limit ? start_idx + limit - 1 : -1
+        result_set = Set.new(records_array[start_idx..end_idx] || [])
+      end
 
-    subset_records = sets.reduce(sets.first, &:&)
-    subset_registry = Registry.new(subset_records, indexes: indexes)
-    subset_registry
+      store_in_cache(cache_key, result_set)
+      new_registry_from_set(result_set)
+    end
   end
 
-  def index(*indexes)
-    indexes.each do |idx|
-      warn "Index #{idx} already exists!" and next if @indexed.key?(idx)
-      each { |item| watch_setter(item, idx) }
-      indexed_records = group_by { |a| a.send(idx) }
-      indexed_sets = Hash[indexed_records.keys.zip(indexed_records.values.map { |e| Set.new(e) })]
-      @indexed[idx] = indexed_sets
+  # Check if any items exist matching the criteria
+  def exists?(**search_criteria)
+    with_thread_safety do
+      search_criteria.size == 1 ? single_criteria_exists?(search_criteria) : multi_criteria_exists?(search_criteria)
     end
   end
 
-  def reindex!(indexes = [])
-    @indexed = {}
-    index(*([DEFAULT_INDEX] | indexes))
+  # Count items matching the criteria without creating a Registry object
+  def count_where(**search_criteria)
+    with_thread_safety do
+      return 0 if search_criteria.nil? || search_criteria.empty?
+
+      result_set = if search_criteria.size == 1
+                     single_criteria_search(search_criteria)
+                   else
+                     multi_criteria_search(search_criteria)
+                   end
+      result_set.size
+    end
   end
 
-  protected
-
-  def reindex(idx, item, old_value, new_value)
-    if (new_value != old_value)
-      @indexed[idx][old_value].delete item
-      (@indexed[idx][new_value] ||= Set.new).add item
-    end
+  def reindex!(new_indexes = [])
+    cleanup_watched_methods # Clean up before reindexing
+    @indexed = {}
+    @indexes = []
+    index(*([DEFAULT_INDEX] | new_indexes))
   end
 
   private
 
   def _find(search_criteria)
-    results = where(search_criteria)
+    results = where(**search_criteria)
     yield if block_given? && results.count > 1
     results.first
   end
 
-  def watch_setter(item, idx)
-    return if item.frozen?
-    __registry__ = self
-    item.public_methods.select { |m| m.match(/^#{idx}=$/) }.each do |original_method|
-      watched_method = "__watched_#{original_method}".to_sym
-      renamed_method = "__unwatched_#{original_method}".to_sym
-      next if item.methods.include?(watched_method)
-
-      item.singleton_class.class_eval do
-        define_method(watched_method) do |*args|
-          old_value = item.send(idx)
-          send(renamed_method, *args).tap do |new_value|
-            __registry__.send(:reindex, idx, item, old_value, new_value)
-          end
-        end
-        alias_method renamed_method, original_method
-        alias_method original_method, watched_method
-      end
+  def new_registry_from_set(set)
+    Registry.new(set.to_a, indexes: indexes, thread_safe: @thread_safe)
+  end
+
+  def validate_index_exists!(idx)
+    return if index_exists?(idx)
+
+    raise IndexNotFound,
+          "Index '#{idx}' not found. Available indexes: #{indexes.inspect}. Add it with '.index(:#{idx})'"
+  end
+
+  def single_criteria_search(search_criteria)
+    idx, value = search_criteria.first
+    validate_index_exists!(idx)
+    lookup_index(idx, value)
+  end
+
+  def multi_criteria_search(search_criteria)
+    result_set = nil
+    search_criteria.each do |idx, value|
+      validate_index_exists!(idx)
+      current_set = lookup_index(idx, value)
+      result_set = result_set ? (result_set & current_set) : current_set
+      break if result_set.empty?
     end
+    result_set || Set.new
   end
 
-  def ignore_setter(item, idx)
-    return if item.frozen?
-    item.public_methods.select { |m| m.match(/^#{idx}=$/) }.each do |original_method|
-      watched_method = "__watched_#{original_method}".to_sym
-      renamed_method = "__unwatched_#{original_method}".to_sym
-      next unless item.methods.include?(watched_method)
-      item.singleton_class.class_eval do
-        alias_method original_method, renamed_method
-        remove_method(watched_method)
-        remove_method(renamed_method)
-      end
+  def single_criteria_exists?(search_criteria)
+    idx, value = search_criteria.first
+    validate_index_exists!(idx)
+    lookup_index(idx, value).any?
+  end
+
+  def multi_criteria_exists?(search_criteria)
+    result_set = nil
+    search_criteria.each do |idx, value|
+      validate_index_exists!(idx)
+      current_set = lookup_index(idx, value)
+      return false if current_set.nil? || current_set.empty?
+
+      result_set = result_set ? (result_set & current_set) : current_set
+      return false if result_set.empty?
     end
+    true
   end
 
+  # Thread safety wrapper
+  def with_thread_safety(&block)
+    if @thread_safe
+      @mutex.synchronize(&block)
+    else
+      yield
+    end
+  end
 end

metadata

@@ -1,72 +1,140 @@
 --- !ruby/object:Gem::Specification
 name: registry
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Dale Stevens
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-description: 
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 email:
 - dale@twilightcoders.net
 executables: []
@@ -77,12 +145,16 @@ files:
 - LICENSE
 - README.md
 - lib/registry.rb
+- lib/registry/index_store.rb
+- lib/registry/method_watcher.rb
+- lib/registry/query_cache.rb
+- lib/registry/version.rb
 homepage: https://github.com/TwilightCoders/registry.
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -91,15 +163,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 4.0.5
 specification_version: 4
 summary: Data structure for quick item lookup via indexes.
 test_files: []