tablesalt 0.26.0.2 → 0.27.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a2ac1d35f932b3a53828157c6d1bcaa4d5fd43659ef216b2b4db1dc6c8d414
-  data.tar.gz: a41494e1189416e3f6a79dee3bd7c9f91d96c1c996ec3cf391df3c30322b714b
+  metadata.gz: 6afc837476271cac528b32cc0eef83747d14bef637291e667322ade86735ad98
+  data.tar.gz: bf1c5ca11e457c8a6f16ef30d84deb17ad66206cc55d8e42cf21ccc5978cb7e2
 SHA512:
-  metadata.gz: c0330a1d4a2504237b30be4ed6c4acf585e24a5918ed7ccd0284aba02652cb78c92fd2a0966ed92b2e477acc01b5d17c1b229b215b748482024ed302c98bda59
-  data.tar.gz: 022a6d37cfd878368676f61c50adcbbb6d9c49835c8a5e913af2257caee0c030f23316e6692d119abd6f346d67eb9beb61fdf0e2b2488d0a36ff2c3f96d35cc3
+  metadata.gz: 73f94eb9cab2f065eae115c5c8887d1565582d624afc86ae2d8cc50f81c36e2b725663e5dc3afb17cc26e10755009b8475c593f54366fac01ae2f83717dd9389
+  data.tar.gz: b33354269fa7bd1aa40f63a559aae58477a147e7aacd405b4d5da128b5d1555d41c4f884587c980771e5263fd69e7ed76f7737d650959186fc079a58613f74e5

data/README.md

@@ -31,7 +31,140 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### ClassPass
+
+TODO: write usage instructions
+
+### DSLAccessor
+
+TODO: write usage instructions
+
+### Isolation
+
+TODO: write usage instructions
+
+### StringableObject
+
+TODO: write usage instructions
+
+### ThreadAccessor
+
+In the simplest use case, a ThreadAccessor can be used to set a value on the current working thread to be used later on. The `thread_accessor` method creates a singleton and instance method for reading and writing a given variable stored on the thread.
+
+#### Defined methods
+* `thread_reader(method_name, thread_key = method_name, private: true)`
+  Defines singleton method and instance method to read from the given thread key.
+* `thread_writer(method_name, thread_key = method_name, private: true)`
+  Defines singleton method and instance method to write to the given thread key.
+* `thread_accessor(method_name, thread_key = method_name, private: true)`
+  Calls `thread_reader` and `thread_writer` with the given arguments.
+  
+#### Example
+
+```ruby
+class CurrentUser
+  include TableSalt::ThreadAccessor
+
+  thread_accessor :current_user
+
+  def self.set(user)
+    self.current_user = user
+  end
+end
+
+CurrentUser.set(User.first)
+
+# then, sometime later within the same request:
+CurrentUser.current_user
+# => #<User id: 1>
+```
+
+#### Thread Safety
+Yep, when you mess with thread variables, you need to think about thread safety. For Rack applications, `ThreadAccessor` ships with a Rack middleware component:
+```ruby
+# in config/initializers/rack.rb, or config/initializers/tablesalt.rb, or anywhere else in your boot path:
+config.middleware.use TableSalt::ThreadAccessor::RackMiddleware
+```
+
+If your application isn't on Rack, you'll need to add a little more code manually to take care of this:
+```ruby
+# Somewhere in your request path:
+class YourMiddleware
+  def call
+    ThreadAccessor.clean_thread_context { yield }
+  end
+end
+```
+
+#### Namespaces
+
+Maybe you wrote a gem that, say, sets a current user value on the thread to enable some other cool behavior. Since you don't want your gem's behavior to interfere with other behavior of the application, you can use a namespaced thread store instead:
+```ruby
+module MyGem
+  class CurrentUser
+    # This isolates the module's thread store for your gem. 
+    include Tablesalt::ThreadAccessor[MyGem]
+
+    thread_accessor :current_user
+
+    def self.set(user)
+      self.current_user = user
+    end
+  end
+
+  class DoAThing
+    include Tablesalt::ThreadAccessor[MyGem]
+    
+    thread_accessor :current_user
+  end
+end
+
+MyGem::CurrentUser.set(User.first)
+
+# then, sometime later within the same request:
+MyGem::DoAThing.current_user
+# => #<User id: 1>
+
+# From class defined above:
+CurrentUser.current_user
+# => nil
+```
+
+Note that this will require you to clear your gem's thread store manually. It is recommended you provide your own middleware with your gem to keep the application's thread stores clean:
+
+```ruby
+module MyGem
+  class MyMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(req)
+      ThreadAccessor.clean_thread_context(namespace: MyGem) { @app.call(req) }
+    end
+  end
+end
+```
+
+#### Test Helpers
+
+Tablesalt's spec helper provides custom RSpec matchers for thread accessor methods:
+* `defines_thread_accessor(name, thread_key, private: true, namespace: nil)`
+* `defines_thread_reader(name, thread_key, private: true, namespace: nil)`
+* `defines_thread_writer(name, thread_key, private: true, namespace: nil)`
+
+If your application uses ThreadAccessor, you'll need to clear the thread stores between test runs. 
+* **RSpec**
+  If you're using RSpec, you're in luck! Just `require tablesalt/spec_helper` in `spec_helper.rb` or `rails_helper.rb`.
+* **Minitest & others**
+  If you're using Minitest or some other testing framework, you'll need to clear things out manually. This is pretty simple, just run the following after each test run:
+  ```ruby
+  Thread.current[Tablesalt::ThreadAccessor::THREAD_ACCESSOR_STORE_THREAD_KEY] = nil
+  ```
+
+### UsesHashForEquality
+
+TODO: write usage instructions
 
 ## Development
 

data/lib/tablesalt/class_pass.rb

@@ -18,7 +18,7 @@ module Tablesalt
 
       private
 
-      def class_pass_method(*methods)
+      def class_pass_method(*methods, to: nil)
         methods.each do |method|
           next if _class_pass_methods.include?(method)
 
@@ -26,9 +26,9 @@ module Tablesalt
 
           define_singleton_method method do |*args, **attrs|
             if RUBY_VERSION < "2.7.0" && attrs.empty?
-              new(*args).public_send(method)
+              new(*args).public_send(to || method)
             else
-              new(*args, **attrs).public_send(method)
+              new(*args, **attrs).public_send(to || method)
             end
           end
         end

data/lib/tablesalt/rspec/config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Thread.current[Tablesalt::ThreadAccessor::THREAD_ACCESSOR_STORE_THREAD_KEY] = nil
+  end
+end

data/lib/tablesalt/rspec/custom_matchers/define_thread_accessor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# RSpec matcher to assert the definition of a thread accessor
+#
+#     class MyClass
+#       include Tablesalt::ThreadAccessor
+#
+#       thread_accessor :foo, :a_foo_key
+#     end
+#
+#     RSpec.describe MyClass do
+#       subject { described_class }
+#
+#       it { is_expected.to define_thread_accessor :foo, :a_foo_key, private: false }
+#     end
+RSpec::Matchers.define :define_thread_accessor do |accessor_name, thread_key, **options|
+  match do |subject|
+    expect(subject).to define_thread_reader accessor_name, thread_key, **options
+    expect(subject).to define_thread_writer accessor_name, thread_key, **options
+  end
+end

data/lib/tablesalt/rspec/custom_matchers/define_thread_reader.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/hash/keys"
 # RSpec matcher to assert the definition of a thread accessor
 #
 #     class MyClass
-#       include Tablesalt::ConfigDelegation
+#       include Tablesalt::ThreadAccessor
 #
 #       thread_reader :a_thread_key
 #     end
@@ -16,20 +16,21 @@ require "active_support/core_ext/hash/keys"
 #       it { is_expected.to define_thread_reader :a_thread_key, private: false }
 #     end
 RSpec::Matchers.define :define_thread_reader do |method_name, thread_key, **options|
-  attr_reader :subject, :method_name, :thread_key, :private_opt
+  attr_reader :subject, :method_name, :thread_key, :private_opt, :namespace
 
-  description { "defines#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}" }
+  description { "define#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
 
-  failure_message { "expected #{subject_module} to define#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}" }
-  failure_message_when_negated { "expected #{subject_module} not to define#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}" }
+  failure_message { "expected #{subject_module} to define#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
+  failure_message_when_negated { "expected #{subject_module} not to define#{a_private} thread reader #{method_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
 
-  match_unless_raises do |subject|
-    options.assert_valid_keys(:private)
+  match do |subject|
+    options.assert_valid_keys(:private, :namespace)
 
     @subject = subject
     @method_name = method_name
     @thread_key = thread_key.to_sym
     @private_opt = options.fetch(:private, true)
+    @namespace = options.fetch(:namespace, nil)
 
     with_value_on_thread do
       expect(instance).to be_respond_to(method_name, true)
@@ -50,11 +51,12 @@ RSpec::Matchers.define :define_thread_reader do |method_name, thread_key, **opti
   private
 
   def with_value_on_thread
-    Thread.current[thread_key] = stubbed_value
+    value_before = Tablesalt::ThreadAccessor.store(namespace)[thread_key]
+    Tablesalt::ThreadAccessor.store(namespace)[thread_key] = stubbed_value
 
     yield
 
-    Thread.current[thread_key] = nil
+    Tablesalt::ThreadAccessor.store(namespace)[thread_key] = value_before
   end
 
   def subject_module
@@ -62,19 +64,12 @@ RSpec::Matchers.define :define_thread_reader do |method_name, thread_key, **opti
   end
 
   def klass
-    @klass ||=
-      case subject
-      when Class
-        subject
-      when Module
-        Class.new(subject)
-      else
-        subject.class
-      end
+    @klass ||= subject.is_a?(Module) ? subject : subject.class
   end
 
   def instance
     return subject unless subject.is_a?(Module)
+    return subject unless subject.respond_to?(:new)
 
     @instance ||= begin
       allow(klass).to receive(:initialize).with(any_args)
@@ -91,4 +86,10 @@ RSpec::Matchers.define :define_thread_reader do |method_name, thread_key, **opti
 
     " a private"
   end
+
+  def namespace_failure_message
+    return if namespace.blank?
+
+    " in #{namespace.inspect} namespace"
+  end
 end

data/lib/tablesalt/rspec/custom_matchers/define_thread_writer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+
+# RSpec matcher to assert the definition of a thread accessor
+#
+#     class MyClass
+#       include Tablesalt::ThreadAccessor
+#
+#       thread_writer :foo, :a_foo_key
+#     end
+#
+#     RSpec.describe MyClass do
+#       subject { described_class }
+#
+#       it { is_expected.to define_thread_writer :foo, :a_foo_key, private: false }
+#     end
+RSpec::Matchers.define :define_thread_writer do |writer_name, thread_key, **options|
+  attr_reader :subject, :writer_name, :method_name, :thread_key, :private_opt, :namespace
+
+  description { "define#{a_private} thread writer #{writer_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
+
+  failure_message { "expected #{subject_module} to define#{a_private} thread writer #{writer_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
+  failure_message_when_negated { "expected #{subject_module} not to define#{a_private} thread writer #{writer_name.inspect} with thread key #{thread_key.inspect}#{namespace_failure_message}" }
+
+  match do |subject|
+    options.assert_valid_keys(:private, :namespace)
+
+    @subject = subject
+    @writer_name = writer_name
+    @method_name = "#{writer_name}="
+    @thread_key = thread_key.to_sym
+    @private_opt = options.fetch(:private, true)
+    @namespace = options.fetch(:namespace, nil)
+
+    expect(instance).to be_respond_to(method_name, true)
+    expect(klass).to be_respond_to(method_name, true)
+
+    klass.__send__(method_name, class_stubbed_value)
+    expect(Tablesalt::ThreadAccessor.store(namespace)[thread_key]).to eq class_stubbed_value
+
+    instance.__send__(method_name, instance_stubbed_value)
+    expect(Tablesalt::ThreadAccessor.store(namespace)[thread_key]).to eq instance_stubbed_value
+
+    if private_opt
+      expect(klass).to be_private_method_defined method_name
+      expect(klass.singleton_class).to be_private_method_defined method_name
+    end
+
+    true
+  end
+
+  private
+
+  def subject_module
+    subject.is_a?(Module) ? subject : subject.class
+  end
+
+  def klass
+    @klass ||= subject.is_a?(Module) ? subject : subject.class
+  end
+
+  def instance
+    return subject unless subject.is_a?(Module)
+    return subject unless subject.respond_to?(:new)
+
+    @instance ||= begin
+      allow(klass).to receive(:initialize).with(any_args)
+      subject.new
+    end
+  end
+
+  def class_stubbed_value
+    @class_stubbed_value ||= double("class thread value")
+  end
+
+  def instance_stubbed_value
+    @instance_stubbed_value ||= double("instance thread value")
+  end
+
+  def a_private
+    return unless private_opt
+
+    " a private"
+  end
+
+  def namespace_failure_message
+    return if namespace.blank?
+
+    " in #{namespace.inspect} namespace"
+  end
+end

data/lib/tablesalt/rspec/custom_matchers.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "custom_matchers/define_thread_accessor"
 require_relative "custom_matchers/define_thread_reader"
+require_relative "custom_matchers/define_thread_writer"
 require_relative "custom_matchers/isolate"

data/lib/tablesalt/spec_helper.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
 require_relative "rspec/custom_matchers"
+require_relative "rspec/config"

data/lib/tablesalt/thread_accessor/management.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Tablesalt
+  module ThreadAccessor
+    module Management
+      def store(namespace = nil)
+        raise ArgumentError, "cannot request a namespaced store from a namespaced accessor" if namespace.present? && self::THREAD_ACCESSOR_STORE_NAMESPACE.present?
+
+        namespace = self::THREAD_ACCESSOR_STORE_NAMESPACE if namespace.nil?
+
+        stores = Thread.current[Tablesalt::ThreadAccessor::THREAD_ACCESSOR_STORE_THREAD_KEY] ||= {}
+        stores[namespace] ||= ThreadStore.new
+      end
+
+      # Cleans up ThreadAccessor state after given block executes
+      #
+      # @param :logger [Logger] Optional; A logger instance that implements the method :warn to send warning messages to
+      # @yield Required; Yields no variables to the given block
+      def clean_thread_context(logger: nil, namespace: nil)
+        if store(namespace).present?
+          if logger.nil?
+            puts "WARNING: ThreadAccessor variables set outside ThreadAccessor context: #{store(namespace).keys.join(", ")}"
+          else
+            logger.warn("ThreadAccessor variables set outside ThreadAccessor context: #{store(namespace).keys.join(", ")}")
+          end
+        end
+
+        yield
+      ensure
+        store(namespace).clear
+      end
+    end
+  end
+end

data/lib/tablesalt/thread_accessor/rack_middleware.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Tablesalt
+  module ThreadAccessor
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      # Clears thread variables after request is finished processing.
+      # Make sure this middleware appears +before+ anything that may set
+      # thread variables using ThreadAccessor
+      def call(req)
+        ThreadAccessor.clean_thread_context(logger: logger) { @app.call(req) }
+      end
+
+      def logger
+        return unless @app.respond_to? :logger
+
+        @app.logger
+      end
+    end
+  end
+end

data/lib/tablesalt/thread_accessor/scoped_accessor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tablesalt
+  module ThreadAccessor
+    class ScopedAccessor < Module
+      attr_reader :scope
+
+      def initialize(scope)
+        @scope = scope
+
+        extend ActiveSupport::Concern
+        extend Management
+        include ThreadAccessor
+
+        const_set :THREAD_ACCESSOR_STORE_NAMESPACE, scope
+      end
+
+      def name
+        "#{self.class}:#{scope}"
+      end
+
+      def inspect
+        "#<#{name}>"
+      end
+    end
+  end
+end

data/lib/tablesalt/thread_accessor/store_instance.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tablesalt
+  module ThreadAccessor
+    module StoreInstance
+      private
+
+      def __thread_accessor_store_instance__
+        ThreadAccessor.store(respond_to?(:const_get) ? self::THREAD_ACCESSOR_STORE_NAMESPACE : self.class::THREAD_ACCESSOR_STORE_NAMESPACE)
+      end
+    end
+  end
+end

data/lib/tablesalt/thread_accessor/thread_store.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_support/hash_with_indifferent_access"
+
+module Tablesalt
+  module ThreadAccessor
+    class ThreadStore
+      delegate :==, to: :hash
+      delegate_missing_to :hash
+
+      def hash
+        @hash ||= HashWithIndifferentAccess.new
+      end
+    end
+  end
+end

data/lib/tablesalt/thread_accessor.rb

@@ -1,12 +1,49 @@
 # frozen_string_literal: true
 
 require "active_support/concern"
+require "active_support/core_ext/module/delegation"
 
+require_relative "thread_accessor/management"
+require_relative "thread_accessor/rack_middleware"
+require_relative "thread_accessor/scoped_accessor"
+require_relative "thread_accessor/store_instance"
+require_relative "thread_accessor/thread_store"
+
+# WARNING: This module is still in beta mode and will likely change significantly soon. Tread carefully...
 module Tablesalt
   module ThreadAccessor
     extend ActiveSupport::Concern
+    extend Management
+
+    THREAD_ACCESSOR_STORE_THREAD_KEY = :__tablesalt_thread_accessor_store__
+
+    # nil by default, gets overridden by ScopedAccessor
+    THREAD_ACCESSOR_STORE_NAMESPACE = nil
+
+    include StoreInstance
+
+    class << self
+      # @example
+      #   module MyGem
+      #     class MyClass
+      #       include Tablesalt::ThreadAccessor[:my_gem]
+      #
+      #       # Stored in a separate thread store for :my_gem, safe from mischievous app developers
+      #       thread_accessor :foo, :my_foo
+      #     end
+      #   end
+      #
+      # @param scope [String, Symbol] A namespace for the thread variables
+      # @return [Module] A ThreadAccessor module to be included into your class
+      def [](scope)
+        @scoped_accessors ||= {}
+        @scoped_accessors[scope] ||= ScopedAccessor.new(scope)
+      end
+    end
 
     module ClassMethods
+      include StoreInstance
+
       private
 
       # Defines an instance method and a singleton method to read from a given key in Thread.current
@@ -29,8 +66,8 @@ module Tablesalt
       # @param thread_key [String, Symbol] The key to read from Thread.current
       # @option :private [Boolean] If true, both defined methods will be private. Default: true
       def thread_reader(method, thread_key, **options)
-        define_method(method) { Thread.current[thread_key] }
-        define_singleton_method(method) { Thread.current[thread_key] }
+        define_method(method) { __thread_accessor_store_instance__[thread_key] }
+        define_singleton_method(method) { __thread_accessor_store_instance__[thread_key] }
 
         return unless options.fetch(:private, true)
 
@@ -52,14 +89,25 @@ module Tablesalt
       #   Thread.current[:foo]
       #   => "bar"
       #
+      # Note::
+      #   All written thread variables are tracked on-thread, but will not be automatically cleared when
+      #   the thread is done processing a request/unit of work. Make sure to either use the provided
+      #   {ThreadAccessor::RackMiddleware} or run {ThreadAccessor.clean_thread_context} manually once
+      #   the thread is finished to avoid pollluting other requests.
+      #
+      # Gem Authors::
+      #   Thread variables should ideally be kept in a namespaced store instead of the global one. This means
+      #   you are responsible for clearing your own store - either add your own middleware or advise users how
+      #   to clear the thread store themselves.
+      #
       # @param method [String, Symbol] The name of the writer method
       # @param thread_key [String, Symbol] The key to write to on Thread.current
       # @option :private [Boolean] If true, both defined methods will be private. Default: true
       def thread_writer(method, thread_key, **options)
         method_name = "#{method}="
 
-        define_method(method_name) { |value| Thread.current[thread_key] = value }
-        define_singleton_method(method_name) { |value| Thread.current[thread_key] = value }
+        define_method(method_name) { |value| __thread_accessor_store_instance__[thread_key] = value }
+        define_singleton_method(method_name) { |value| __thread_accessor_store_instance__[thread_key] = value }
 
         return unless options.fetch(:private, true)
 

data/lib/tablesalt/version.rb

@@ -2,5 +2,5 @@
 
 module Tablesalt
   # This constant is managed by spicerack
-  VERSION = "0.26.0.2"
+  VERSION = "0.27.1"
 end

data/lib/tablesalt.rb

@@ -3,13 +3,13 @@
 require "active_support"
 require "short_circu_it"
 
-require "tablesalt/version"
-
-require "tablesalt/class_pass"
-require "tablesalt/dsl_accessor"
-require "tablesalt/isolation"
-require "tablesalt/stringable_object"
-require "tablesalt/thread_accessor"
-require "tablesalt/uses_hash_for_equality"
+require_relative "tablesalt/version"
+
+require_relative "tablesalt/class_pass"
+require_relative "tablesalt/dsl_accessor"
+require_relative "tablesalt/isolation"
+require_relative "tablesalt/stringable_object"
+require_relative "tablesalt/thread_accessor"
+require_relative "tablesalt/uses_hash_for_equality"
 
 module Tablesalt; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tablesalt
 version: !ruby/object:Gem::Version
-  version: 0.26.0.2
+  version: 0.27.1
 platform: ruby
 authors:
 - Jordan Minneti
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-28 00:00:00.000000000 Z
+date: 2021-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,12 +53,20 @@ files:
 - lib/tablesalt/class_pass.rb
 - lib/tablesalt/dsl_accessor.rb
 - lib/tablesalt/isolation.rb
+- lib/tablesalt/rspec/config.rb
 - lib/tablesalt/rspec/custom_matchers.rb
+- lib/tablesalt/rspec/custom_matchers/define_thread_accessor.rb
 - lib/tablesalt/rspec/custom_matchers/define_thread_reader.rb
+- lib/tablesalt/rspec/custom_matchers/define_thread_writer.rb
 - lib/tablesalt/rspec/custom_matchers/isolate.rb
 - lib/tablesalt/spec_helper.rb
 - lib/tablesalt/stringable_object.rb
 - lib/tablesalt/thread_accessor.rb
+- lib/tablesalt/thread_accessor/management.rb
+- lib/tablesalt/thread_accessor/rack_middleware.rb
+- lib/tablesalt/thread_accessor/scoped_accessor.rb
+- lib/tablesalt/thread_accessor/store_instance.rb
+- lib/tablesalt/thread_accessor/thread_store.rb
 - lib/tablesalt/uses_hash_for_equality.rb
 - lib/tablesalt/version.rb
 homepage: https://github.com/Freshly/spicerack/tree/main/tablesalt
@@ -68,7 +76,7 @@ metadata:
   homepage_uri: https://github.com/Freshly/spicerack/tree/main/tablesalt
   source_code_uri: https://github.com/Freshly/spicerack/tree/main/tablesalt
   changelog_uri: https://github.com/Freshly/spicerack/blob/main/tablesalt/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/tablesalt/0.26.0.2
+  documentation_uri: https://www.rubydoc.info/gems/tablesalt/0.27.1
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -84,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.26
 signing_key: 
 specification_version: 4
 summary: Miscellaneous helper modules, POROs, and more, that standardize common behavior