typed_cache 0.3.1 → 0.4.0.pre.1

data/sig/generated/typed_cache/either.rbs

@@ -79,6 +79,18 @@ module TypedCache
 
     # : (Array[top]) -> ({ error: E })
     def deconstruct_keys: (Array[top]) -> { error: E }
+
+    # @rbs (other: Object) -> bool
+    def ==: (other: Object) -> bool
+
+    # @rbs () -> Integer
+    def hash: () -> Integer
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
   end
 
   # @rbs generic out R
@@ -126,5 +138,17 @@ module TypedCache
 
     # : (Array[top]) -> ({ value: R })
     def deconstruct_keys: (Array[top]) -> { value: R }
+
+    # @rbs (other: Object) -> bool
+    def ==: (other: Object) -> bool
+
+    # @rbs () -> Integer
+    def hash: () -> Integer
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
   end
 end

data/sig/generated/typed_cache/instrumenters.rbs

@@ -7,7 +7,7 @@ module TypedCache
     # Registry class directly because many instrumenters mix in `Singleton`,
     # making `.new` inaccessible. Instead we implement a thin facade that
     # returns either the singleton instance (preferred) or a fresh instance.
-    REGISTRY: Registry[Symbol, Class[Instrumenter]]
+    REGISTRY: Registry[Instrumenter]
 
     extend Forwardable
 
@@ -15,9 +15,10 @@ module TypedCache
     # @rbs () -> Registry[Symbol, Class[Instrumenter]]
     def self.registry: () -> Registry[Symbol, Class[Instrumenter]]
 
-    def register: (Symbol, Class[Instrumenter]) -> void
+    # @rbs (Symbol, ?namespace: String, **untyped) -> either[Error, Instrumenter]
+    def self.resolve: (Symbol, ?namespace: String, **untyped) -> either[Error, Instrumenter]
 
-    def resolve: (Symbol, **untyped) -> either[Error, Instrumenter]
+    def register: (Symbol, Class[Instrumenter]) -> void
 
     def available: () -> Array[Symbol]
 

data/sig/generated/typed_cache/maybe.rbs

@@ -71,6 +71,18 @@ module TypedCache
 
     # : (Array[top]) -> ({ value: V })
     def deconstruct_keys: (Array[top]) -> { value: V }
+
+    # @rbs (other: Object) -> bool
+    def ==: (other: Object) -> bool
+
+    # @rbs () -> Integer
+    def hash: () -> Integer
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
   end
 
   class Nothing
@@ -101,5 +113,17 @@ module TypedCache
     # @rbs override
     # : -> V
     def value_or_raise!: ...
+
+    # @rbs (other: Object) -> bool
+    def ==: (other: Object) -> bool
+
+    # @rbs () -> Integer
+    def hash: () -> Integer
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
   end
 end

data/sig/generated/typed_cache/namespace.rbs

@@ -141,8 +141,6 @@ module TypedCache
     # @rbs (Object) -> bool
     def ==: (Object) -> bool
 
-    alias eql? ==
-
     private
 
     # @rbs (String) -> String

data/sig/generated/typed_cache/snapshot.rbs

@@ -41,6 +41,12 @@ module TypedCache
 
     alias flat_map bind
 
+    # @rbs () -> String
+    def to_s: () -> String
+
+    # @rbs () -> String
+    def inspect: () -> String
+
     # Creates a snapshot for a cached value
     # : [V] (CacheKey, V) -> Snapshot[V]
     def self.cached: [V] (CacheKey, V) -> Snapshot[V]

data/sig/generated/typed_cache/store.rbs

@@ -9,114 +9,121 @@ module TypedCache
   # - Queries (get, key?, fetch) ask questions without side effects
   #
   # @rbs generic V
-  module Store[V]
+  class Store[V]
     type cache_key = String | CacheKey
 
     interface _Store[V]
-      def read: (cache_key) -> either[Error, Snapshot[V]]
+      def read: (cache_key) -> either[Error, Snapshot[maybe[V]]]
 
-      def read_all: (Array[cache_key]) -> either[Error, Array[Snapshot[V]]]
+      def read_all: (Array[cache_key]) -> either[Error, Hash[CacheKey, Snapshot[V]]]
 
       def ref: (cache_key) -> CacheRef[V]
 
       def write: (cache_key, V) -> either[Error, Snapshot[V]]
 
-      def write_all: (Hash[cache_key, V]) -> either[Error, Array[Snapshot[V]]]
+      def write_all: (Hash[cache_key, V]) -> either[Error, Hash[CacheKey, Snapshot[V]]]
 
-      def delete: (cache_key) -> either[Error, Snapshot[V]]
+      def delete: (cache_key) -> either[Error, maybe[V]]
 
       def key?: (cache_key) -> bool
 
-      def clear: () -> maybe[Error]
+      def clear: () -> void
 
-      def fetch: (cache_key) { () -> V? } -> either[Error, Snapshot[maybe[V]]]
+      def fetch: (cache_key) { (CacheKey) -> V? } -> either[Error, Snapshot[maybe[V]]]
 
       def fetch_all: (Array[cache_key]) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
 
+      def fetch_or_compute_all: (Array[cache_key]) { (Array[CacheKey]) -> Hash[CacheKey, V] } -> either[Error, Hash[CacheKey, Snapshot[V]]]
+
       def namespace: () -> Namespace
 
       def with_namespace: (Namespace) -> Store[V]
 
-      def store_type: () -> String
+      def at_namespace: (Namespace) -> Store[V]
+
+      def cache_for: [T] (Class[T], at: Namespace | String | Array[String]) -> Store[T]
+
+      def backend: () -> Backend[V]
     end
 
     include _Store[V]
 
-    interface _Decorator[V]
-      def initialize: (Store[V]) -> void
-    end
+    attr_reader namespace: Namespace
+
+    attr_reader backend: Backend[V]
+
+    # @rbs (Namespace, Backend[V]) -> void
+    def initialize: (Namespace, Backend[V]) -> void
 
     # @rbs (Store[V]) -> void
     def initialize_copy: (Store[V]) -> void
 
     # Retrieves a value from the cache
-    # @rbs (cache_key) -> either[Error, Snapshot[V]]
-    def read: (cache_key) -> either[Error, Snapshot[V]]
+    # @rbs (cache_key, **top) -> either[Error, Snapshot[maybe[V]]]
+    def read: (cache_key, **top) -> either[Error, Snapshot[maybe[V]]]
 
-    # @rbs (Array[cache_key]) -> either[Error, Hash[cache_key, Snapshot[V]]]
-    def read_all: (Array[cache_key]) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    # @rbs (Array[cache_key], **top) -> either[Error, Hash[CacheKey, Snapshot[V]]]
+    def read_all: (Array[cache_key], **top) -> either[Error, Hash[CacheKey, Snapshot[V]]]
 
     # Retrieves a cache reference for a key
     # @rbs (cache_key) -> CacheRef[V]
     def ref: (cache_key) -> CacheRef[V]
 
     # Stores a value in the cache
-    # @rbs (cache_key, V) -> either[Error, Snapshot[V]]
-    def write: (cache_key, V) -> either[Error, Snapshot[V]]
+    # @rbs (cache_key, V, **top) -> either[Error, Snapshot[V]]
+    def write: (cache_key, V, **top) -> either[Error, Snapshot[V]]
 
-    # @rbs (Hash[cache_key, V]) -> either[Error, Hash[cache_key, Snapshot[V]]]
-    def write_all: (Hash[cache_key, V]) -> either[Error, Hash[cache_key, Snapshot[V]]]
+    def write_all: (untyped values, **untyped kwargs) -> untyped
 
     # Removes a value from the cache, returning the removed value
-    # @rbs (cache_key) -> either[Error, Snapshot[V]]
-    def delete: (cache_key) -> either[Error, Snapshot[V]]
+    # @rbs (cache_key) -> either[Error, maybe[V]]
+    def delete: (cache_key) -> either[Error, maybe[V]]
 
     # Checks if a key exists in the cache (query operation)
     # @rbs (cache_key) -> bool
     def key?: (cache_key) -> bool
 
     # Clears all values from the cache namespace (command operation)
-    # @rbs () -> maybe[Error]
-    def clear: () -> maybe[Error]
+    # @rbs () -> void
+    def clear: () -> void
 
     # Fetches a value from cache, computing and storing it if not found
     # This is an atomic operation that combines read and write
-    # @rbs (cache_key) { () -> V } -> either[Error, Snapshot[V]]
-    def fetch: (cache_key) { () -> V } -> either[Error, Snapshot[V]]
+    # @rbs (cache_key, **top) { (CacheKey) -> V? } -> either[Error, Snapshot[maybe[V]]]
+    def fetch: (cache_key, **top) { (CacheKey) -> V? } -> either[Error, Snapshot[maybe[V]]]
 
-    # @rbs (Array[cache_key]) { (CacheKey) -> V } -> either[Error, Array[Snapshot[V]]]
-    def fetch_all: (Array[cache_key]) { (CacheKey) -> V } -> either[Error, Array[Snapshot[V]]]
+    # @rbs (Array[cache_key], **top) { (CacheKey) -> V? } -> either[Error, Hash[CacheKey, Snapshot[V]]]
+    def fetch_all: (Array[cache_key], **top) { (CacheKey) -> V? } -> either[Error, Hash[CacheKey, Snapshot[V]]]
+
+    # @rbs (Array[cache_key], **top) { (Array[CacheKey]) -> Hash[CacheKey, V] } -> either[Error, Hash[CacheKey, Snapshot[V]]]
+    def fetch_or_compute_all: (Array[cache_key], **top) { (Array[CacheKey]) -> Hash[CacheKey, V] } -> either[Error, Hash[CacheKey, Snapshot[V]]]
 
     # @rbs () -> Instrumenter
     def instrumenter: () -> Instrumenter
 
-    # Returns the namespace for this store (for instrumentation/debugging)
-    # @rbs () -> Namespace
-    def namespace: () -> Namespace
-
     # Accepts a String segment or a fully-formed Namespace and returns a cloned
     # store scoped to that namespace.
     # : (Namespace | String | Array[String]) -> Store[V]
     def with_namespace: (Namespace | String | Array[String]) -> Store[V]
 
-    # Returns the store type identifier for instrumentation/debugging
+    # @rbs [T] (Class[T], at: (Namespace | String | Array[String])) -> Store[T]
+    def cache_for: [T] (Class[T], at: Namespace | String | Array[String]) -> Store[T]
+
+    alias at_namespace with_namespace
+
     # @rbs () -> String
-    def store_type: () -> String
+    def to_s: () -> String
 
-    attr_writer namespace: Namespace
+    # @rbs () -> String
+    def inspect: () -> String
 
-    private
+    attr_writer namespace: untyped
 
-    # : (String) -> String
-    def snake_case: (String) -> String
+    private
 
     # : (cache_key) -> CacheKey
     def namespaced_key: (cache_key) -> CacheKey
   end
 
-  type backend[V] = Store::_Store[V]
-
-  type decorator[V] = backend[V] & Store::_Decorator[V]
-
-  type store[V] = backend[V] | decorator[V]
+  type store[V] = Store::_Store[V]
 end

data/sig/generated/typed_cache.rbs

@@ -7,6 +7,8 @@ module TypedCache
     def enabled: () -> bool
 
     def namespace: () -> String
+
+    def instrumenter: () -> Symbol
   end
 
   interface _TypedCacheConfig
@@ -19,9 +21,11 @@ module TypedCache
 
   type typed_cache_config = _TypedCacheConfig
 
+  type cache_definition = TypedCache::_CacheDefinition
+
   # Returns a CacheBuilder with the fluent interface
-  # @rbs [V] () -> CacheBuilder[V]
-  def self.builder: [V] () -> CacheBuilder[V]
+  # @rbs () -> cache_definition
+  def self.builder: () -> cache_definition
 
   def config: () -> _TypedCacheConfig
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typed_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0.pre.1
 platform: ruby
 authors:
 - Autumn Winter
@@ -35,7 +35,7 @@ cert_chain:
   uuhUq525FXA3gYeLAfnCSHNm7D1H7whsXYd3z+gKvEhSEQPb3mSBQ+31TDFmA5k7
   q7YL3dwhxKPXtnAboI+30XBImpdizFG9Nyqgzgj/kD0QwVzL0QsVdVWnNTJXrm4n
   -----END CERTIFICATE-----
-date: 2025-08-16 00:00:00.000000000 Z
+date: 2025-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -220,7 +220,7 @@ licenses:
 - Apache-2.0
 metadata:
   issue_tracker_uri: https://github.com/glossawy/typed_cache/issues
-  changelog_uri: https://github.com/glossawy/typed_cache/blob/main/VERSIONS.adoc#031
+  changelog_uri: https://github.com/glossawy/typed_cache/blob/main/VERSIONS.adoc#040-1
   license_uri: https://github.com/glossawy/typed_cache/blob/main/LICENSE
   label: caching
   labels: typed_cache,ruby,caching,type-safety,rails,rbs