safe_memoize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4806562a18a6f5143379d638d270ea3552280637dd33ed322c0f667f1257d836
+  data.tar.gz: bdb12e7ae3a41d230c85fd24750edcc5eeba4d90cf2ac93b59cd0bccc8ba0325
+SHA512:
+  metadata.gz: 4799eb0209980d5fee072ae05ff1661d70b8db5869e8701cac3fcd9241c1106f17fa84a798f85bcb084c197c24c646e2996fe60fa7375d4db8d780ad3bc4b71a
+  data.tar.gz: 6d64a7e4bef4d5b3825d903294bc955c1ec483157aee479496e001cb500e6128804e148791793d862938543bf5e9e7ee05cca128adb4bb37e68a9d4858bcb517

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-02-26
+
+- Initial release

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,119 @@
+# SafeMemoize
+
+Thread-safe memoization for Ruby that correctly handles `nil` and `false` values.
+
+## The Problem
+
+Ruby's common memoization pattern breaks with falsy values:
+
+```ruby
+def user
+  @user ||= find_user  # Re-runs find_user every time it returns nil!
+end
+```
+
+SafeMemoize uses `Hash#key?` to distinguish "not yet cached" from "cached nil/false", so your methods are only computed once regardless of return value.
+
+## Features
+
+- Correctly memoizes `nil` and `false` return values
+- Caches per unique arguments (positional and keyword)
+- Thread-safe via double-check locking
+- Zero runtime dependencies
+- Simple `prepend` + `memoize` API
+- Block arguments bypass cache (blocks aren't comparable)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "safe_memoize"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install safe_memoize
+```
+
+## Usage
+
+### Basic memoization
+
+```ruby
+class UserService
+  prepend SafeMemoize
+
+  def current_user
+    # This expensive lookup runs only once
+    User.find_by(session_id: session_id)
+  end
+  memoize :current_user
+end
+```
+
+### With arguments
+
+Results are cached per unique argument combination:
+
+```ruby
+class Calculator
+  prepend SafeMemoize
+
+  def compute(x, y)
+    sleep(2)
+    x + y
+  end
+  memoize :compute
+end
+
+calc = Calculator.new
+calc.compute(1, 2)  # computes and caches
+calc.compute(1, 2)  # returns cached result
+calc.compute(3, 4)  # computes and caches (different args)
+```
+
+### Nil and false safety
+
+```ruby
+class Config
+  prepend SafeMemoize
+
+  def enabled?
+    # Only called once, even though it returns false
+    ENV["FEATURE_FLAG"] == "true"
+  end
+  memoize :enabled?
+end
+```
+
+### Cache reset
+
+```ruby
+obj = MyService.new
+obj.reset_memo(:current_user)  # Clears cache for one method
+obj.reset_all_memos            # Clears all memoized values
+```
+
+## How It Works
+
+SafeMemoize uses Ruby's `prepend` mechanism. When you call `memoize :method_name`, it creates an anonymous module with a wrapper method and prepends it onto your class. The wrapper calls `super` to invoke the original method and stores the result in a per-instance hash. Thread safety is achieved with a per-instance `Mutex` using double-check locking.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eclectic-coding/safe_memoize.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

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

data/lib/safe_memoize/version.rb

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

data/lib/safe_memoize.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "safe_memoize/version"
+
+module SafeMemoize
+  class Error < StandardError; end
+
+  def self.prepended(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def memoize(method_name)
+      method_name = method_name.to_sym
+
+      mod = Module.new do
+        define_method(method_name) do |*args, **kwargs, &block|
+          # Blocks bypass cache entirely — they aren't comparable
+          return super(*args, **kwargs, &block) if block
+
+          cache_key = [method_name, args, kwargs]
+
+          @__safe_memo_mutex__ ||= Mutex.new
+
+          # Fast path: check without lock
+          if defined?(@__safe_memo_cache__) && @__safe_memo_cache__.key?(cache_key)
+            return @__safe_memo_cache__[cache_key]
+          end
+
+          # Slow path: lock and double-check
+          @__safe_memo_mutex__.synchronize do
+            @__safe_memo_cache__ ||= {}
+
+            if @__safe_memo_cache__.key?(cache_key)
+              @__safe_memo_cache__[cache_key]
+            else
+              @__safe_memo_cache__[cache_key] = super(*args, **kwargs)
+            end
+          end
+        end
+      end
+
+      prepend mod
+    end
+  end
+
+  def reset_memo(method_name)
+    method_name = method_name.to_sym
+
+    return unless defined?(@__safe_memo_cache__)
+
+    if defined?(@__safe_memo_mutex__) && @__safe_memo_mutex__
+      @__safe_memo_mutex__.synchronize do
+        @__safe_memo_cache__.delete_if { |key, _| key[0] == method_name }
+      end
+    else
+      @__safe_memo_cache__.delete_if { |key, _| key[0] == method_name }
+    end
+  end
+
+  def reset_all_memos
+    if defined?(@__safe_memo_mutex__) && @__safe_memo_mutex__
+      @__safe_memo_mutex__.synchronize do
+        @__safe_memo_cache__ = {}
+      end
+    else
+      @__safe_memo_cache__ = {}
+    end
+  end
+end

data/sig/safe_memoize.rbs

@@ -0,0 +1,12 @@
+module SafeMemoize
+  VERSION: String
+
+  def self.prepended: (Class base) -> void
+
+  def reset_memo: (Symbol method_name) -> void
+  def reset_all_memos: () -> void
+
+  module ClassMethods
+    def memoize: (Symbol | String method_name) -> void
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: safe_memoize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chuck Smith
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A prepend-based memoization module for Ruby that safely caches nil and
+  false return values, supports method arguments, and provides thread safety via double-check
+  locking.
+email:
+- eclectic-coding@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/safe_memoize.rb
+- lib/safe_memoize/version.rb
+- sig/safe_memoize.rbs
+homepage: https://github.com/eclectic-coding/safe_memoize
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/eclectic-coding/safe_memoize
+  source_code_uri: https://github.com/eclectic-coding/safe_memoize/tree/main
+  changelog_uri: https://github.com/eclectic-coding/safe_memoize/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.2
+specification_version: 4
+summary: Thread-safe memoization that correctly handles nil and false values
+test_files: []