typed_cache 0.4.0.pre.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ec41a8981323affe19dcf95567cd004f58c744e6bada1e4b629678eda393f7d
-  data.tar.gz: 35cc676a0564191003dec33b91c53e98fea1e1f90bdc89269fbbfa35c395b2eb
+  metadata.gz: f4ce9735b042027d3a74d3d5b624c916dade1673855d906503c843e214ab08f7
+  data.tar.gz: 1e448a580e62f8889edd6520066d3ef212bf3ad8892e58ce79ba1d3eaec94fbf
 SHA512:
-  metadata.gz: 51a2c6dd90dcf5757d8058021cae3eb1d3002c0441673f008ed1c0a1302b8b3b32ad21981cf21c909ee0bf2f6a67f59827397bb0169d0f33e9fd536d9a468cac
-  data.tar.gz: 5f9a98912d940cbc4fb357f65d273ad030b7f97200a374b31b7b246c66ac85a733cd4b9332b545ea03fe7f25053271dcc19a4919e9312c2e0f85ea348a7eefce
+  metadata.gz: 7173225ff902a77ac9083483a005238ac7b54301943a75c4179e52ccaaaaff12923f17a0d427f6f7a07da56d183e588c4fe8922af64b4a0c7077e1042f786805
+  data.tar.gz: 5b9e1fefd5b4e82e5cb24f126336a69d92c91e2b2d0312b19e1ad82e3af5967721224d47bd1960dfcf2637dc50c92da1d290fa9783a3b6a2f320d9ee7b9e4acd

data/lib/typed_cache/backend.rb

@@ -18,7 +18,7 @@ module TypedCache
     #     def read_multi: (Array[cache_key], **top) -> Hash[cache_key, V]
     #     def write: (cache_key, V, **top) -> V
     #     def write_multi: (Hash[cache_key, V], **top) -> Hash[cache_key, V]
-    #     def delete: (cache_key) -> V?
+    #     def delete: (cache_key, **top) -> V?
     #     def key?: (cache_key) -> bool
     #     def clear: () -> void
     #     def fetch: (cache_key, **top) { () -> V? } -> V?
@@ -52,19 +52,19 @@ module TypedCache
     end
 
     # @rbs override
-    # @rbs (cache_key) -> V?
+    # @rbs (cache_key, **top) -> V?
     def delete(key, **opts)
       raise NotImplementedError, "#{self.class} must implement #delete"
     end
 
     # @rbs override
     # @rbs (cache_key) -> bool
-    def key?(key, **opts)
+    def key?(key)
       raise NotImplementedError, "#{self.class} must implement #key?"
     end
 
     # @rbs override
-    # @rbs () -> void
+    # @rbs (**top) -> void
     def clear(**opts)
       raise NotImplementedError, "#{self.class} must implement #clear"
     end
@@ -80,14 +80,6 @@ module TypedCache
     def fetch_multi(keys, **opts, &block)
       keys.to_h { |key| [key, fetch(key, **opts, &block)] }
     end
-
-    # @rbs override
-    # @rbs () -> String
-    def to_s = self.class.name
-
-    # @rbs override
-    # @rbs () -> String
-    def inspect = self.class.inspect
   end
 
   # @rbs! type backend[V] = Backend::_Backend[V]

data/lib/typed_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypedCache
-  VERSION = '0.4.0-1'
+  VERSION = '0.4.0'
 end

data/rbi/typed_cache/backend.rbi

@@ -4,25 +4,25 @@ module TypedCache
   module Backend
     extend T::Generic
 
-    interface!
+    abstract!
 
     BackendType = type_member
 
-    KeyValue = T.type_alias { T.any(CacheKey, String) }
+    KeyValue = T.type_alias { T.any(::TypedCache::CacheKey, String) }
 
-    sig { abstract.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, Snapshot[Maybe[BackendType]]]) }
+    sig { abstract.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(BackendType)) }
     def read(key, **opts); end
 
-    sig { abstract.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, Snapshot[BackendType]]) }
+    sig { abstract.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(BackendType) }
     def write(key, value, **opts); end
 
-    sig { abstract.params(key: KeyValue).returns(Either[Error, Snapshot[Maybe[BackendType]]]) }
-    def delete(key); end
+    sig { abstract.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(BackendType)) }
+    def delete(key, **opts); end
 
-    sig { abstract.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    sig { abstract.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(T::Hash[KeyValue, BackendType]) }
     def read_multi(keys, **opts); end
 
-    sig { abstract.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    sig { abstract.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(T::Hash[KeyValue, BackendType]) }
     def write_multi(values, **opts); end
 
     sig { abstract.void }
@@ -31,21 +31,18 @@ module TypedCache
     sig { abstract.params(key: KeyValue).returns(T::Boolean) }
     def key?(key); end
 
-    sig { abstract.returns(T.nilable(Instrumenter)) }
-    def instrumenter; end
-
     sig do
       abstract
         .type_parameters(:K)
-        .params(key: T.all(KeyValue, T.type_parameter(:K)), block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(Either[Error, Snapshot[Maybe[BackendType]]])
+        .params(key: T.all(KeyValue, T.type_parameter(:K)), opts: T::Hash[Symbol, T.untyped], block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(T.nilable(BackendType))
     end
-    def fetch(key, &block); end
+    def fetch(key, **opts, &block); end
 
     sig do
       abstract
         .type_parameters(:K)
-        .params(keys: T::Array[T.all(KeyValue, T.type_parameter(:K))], block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]])
+        .params(keys: T::Array[T.all(KeyValue, T.type_parameter(:K))], opts: T::Hash[Symbol, T.untyped], block: T.proc.params(key: T.all(KeyValue, T.type_parameter(:K))).returns(T.nilable(BackendType))).returns(T::Hash[T.all(KeyValue, T.type_parameter(:K)), BackendType])
     end
-    def fetch_multi(keys, &block); end
+    def fetch_multi(keys, **opts, &block); end
   end
 end

data/rbi/typed_cache/cache_builder.rbi

@@ -7,10 +7,10 @@ module TypedCache
 
     InstrumenterSource = T.type_alias { T.any(Symbol, ::TypedCache::Instrumenter) }
 
-    interface!
+    abstract!
     sealed!
 
-    sig { abstract.params(name: Symbol, args: T.untyped, options: T::Hash[Symbol, T.anything]).returns(T.all(CacheDefinition, CacheBuilder)) }
+    sig { abstract.params(name: Symbol, args: T.untyped, options: T::Hash[Symbol, T.anything]).returns(T.all(::TypedCache::CacheDefinition, ::TypedCache::CacheBuilding)) }
     def with_backend(name, *args, **options); end
 
     sig { abstract.params(name: Symbol, options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
@@ -20,11 +20,11 @@ module TypedCache
     def with_instrumentation(source = T.unsafe(nil)); end
   end
 
-  module CacheBuilder
+  module CacheBuilding
     extend T::Sig
     extend T::Helpers
 
-    interface!
+    abstract!
     sealed!
 
     sig { abstract.params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Either[::TypedCache::Error, ::TypedCache::Store[T.untyped]]) }
@@ -39,4 +39,9 @@ module TypedCache
     sig { abstract.returns(::TypedCache::Backend[T.untyped]) }
     def build_backend!; end
   end
+
+  class CacheBuilder
+    include ::TypedCache::CacheBuilding
+    include ::TypedCache::CacheDefinition
+  end
 end

data/rbi/typed_cache/decorator.rbi

@@ -17,37 +17,34 @@ module TypedCache
     sig { abstract.returns(::TypedCache::Backend[BackendType]) }
     def backend; end
 
-    sig { override.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
+    sig { override.overridable.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(BackendType)) }
     def read(key, **opts); end
 
-    sig { override.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[BackendType]]) }
+    sig { override.overridable.params(key: KeyValue, value: BackendType, opts: T::Hash[Symbol, T.untyped]).returns(BackendType) }
     def write(key, value, **opts); end
 
-    sig { override.params(key: KeyValue).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
-    def delete(key); end
+    sig { override.overridable.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(BackendType)) }
+    def delete(key, **opts); end
 
-    sig { override.params(key: KeyValue).returns(T::Boolean) }
+    sig { override.overridable.params(key: KeyValue).returns(T::Boolean) }
     def key?(key); end
 
-    sig { override.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped], block: T.proc.returns(T.nilable(BackendType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[Maybe[BackendType]]]) }
+    sig { override.overridable.params(key: KeyValue, opts: T::Hash[Symbol, T.untyped], block: T.proc.returns(T.nilable(BackendType))).returns(T.nilable(BackendType)) }
     def fetch(key, **opts, &block); end
 
-    sig { override.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    sig { override.overridable.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped]).returns(T::Hash[KeyValue, BackendType]) }
     def read_multi(keys, **opts); end
 
-    sig { override.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped], block: T.proc.params(key: KeyValue).returns(T.nilable(BackendType))).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    sig { override.overridable.params(keys: T::Array[KeyValue], opts: T::Hash[Symbol, T.untyped], block: T.proc.params(key: KeyValue).returns(T.nilable(BackendType))).returns(T::Hash[KeyValue, BackendType]) }
     def fetch_multi(keys, **opts, &block); end
 
-    sig { override.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(::TypedCache::Either[Error, T::Hash[KeyValue, Snapshot[BackendType]]]) }
+    sig { override.overridable.params(values: T::Hash[KeyValue, BackendType], opts: T::Hash[Symbol, T.untyped]).returns(T::Hash[KeyValue, BackendType]) }
     def write_multi(values, **opts); end
 
-    sig { override.void }
+    sig { override.overridable.void }
     def clear; end
 
     sig { overridable.params(other: T.self_type).void }
     def initialize_copy(other); end
-
-    sig { override.returns(T.nilable(::TypedCache::Instrumenter)) }
-    def instrumenter; end
   end
 end

data/sig/generated/typed_cache/backend.rbs

@@ -21,7 +21,7 @@ module TypedCache
 
       def write_multi: (Hash[cache_key, V], **top) -> Hash[cache_key, V]
 
-      def delete: (cache_key) -> V?
+      def delete: (cache_key, **top) -> V?
 
       def key?: (cache_key) -> bool
 
@@ -51,7 +51,7 @@ module TypedCache
     def write_multi: ...
 
     # @rbs override
-    # @rbs (cache_key) -> V?
+    # @rbs (cache_key, **top) -> V?
     def delete: ...
 
     # @rbs override
@@ -59,7 +59,7 @@ module TypedCache
     def key?: ...
 
     # @rbs override
-    # @rbs () -> void
+    # @rbs (**top) -> void
     def clear: ...
 
     # @rbs override
@@ -69,14 +69,6 @@ module TypedCache
     # @rbs override
     # @rbs (Array[cache_key], **top) { (cache_key) -> V? } -> Hash[cache_key, V]
     def fetch_multi: ...
-
-    # @rbs override
-    # @rbs () -> String
-    def to_s: ...
-
-    # @rbs override
-    # @rbs () -> String
-    def inspect: ...
   end
 
   type backend[V] = Backend::_Backend[V]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typed_cache
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Autumn Winter
@@ -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#040-1
+  changelog_uri: https://github.com/glossawy/typed_cache/blob/main/VERSIONS.adoc#040
   license_uri: https://github.com/glossawy/typed_cache/blob/main/LICENSE
   label: caching
   labels: typed_cache,ruby,caching,type-safety,rails,rbs