optify-config 1.18.0 → 1.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd8f5a1196800f635ebc7f4a9c1ac020ba3cc021654fa7dbbd914d0cb6122ff0
-  data.tar.gz: 27555219991c4a53971f29c50bf7b01ab5f40efab70c4264c4b155595d4e02e8
+  metadata.gz: '029bd9d7bb3680eff70b702cfca85a1b8ccf95ad96fde27b1e23a6f635b36c97'
+  data.tar.gz: 8cdfa212412ddb927fbfdcda7fa3c2fe658a0529af4c9ade7117bced98cce61f
 SHA512:
-  metadata.gz: b7dda691f74e094addd304d87c184361565e9df2d604e7a13ea3bf89e7833e4ac9e3350a500cdaf7cc5f6ec4885900e7ebdebe985e73a8bb17295710eb6e49f4
-  data.tar.gz: da0e154d813a6ee1858c25fb4ba4b62288acb639822a89567621641d0708e0682505b38fd0dfeb94e9084b195fb102d424f5aa21464a15b928f5c7d9dffdb252
+  metadata.gz: 9bd1a0ba1a66bc6115b9489502b1fda87d66ab22936d0b111a4204392299c7d0120660e04107caa5948c8333841246890dfb6166bb86ec8cc13b47e4ee341aa3
+  data.tar.gz: 03d8822a3407b6a3b317c70877244dce3000a2b9b407bce75ec0f0b2c39cf7262a37712cdac9fb8f42ab5a205050e9b49fc728ef89e810ded654da70dd78e0a8

data/ext/optify_ruby/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "optify_ruby"
-version = "0.20.0"
+version = "0.23.0"
 edition = "2021"
 
 description = "optify bindings for Ruby"
@@ -20,7 +20,8 @@ exclude = [
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = "0.8.0"
-optify = { path = "../../../../rust/optify", version = "0.20.5" }
-rb-sys = { version = "*", default-features = false, features = ["ruby-static"] }
+magnus = "0.8.2"
+# Can't put a relative path here because then others can't install the source gem: https://github.com/juharris/optify/pull/176
+optify = "1.0.0"
+rb-sys = { version = "0.9.124", default-features = false, features = ["ruby-static"] }
 serde_json = "1.0.143"

data/ext/optify_ruby/src/lib.rs

@@ -1,4 +1,7 @@
-use magnus::{function, method, prelude::*, wrap, Object, Ruby, Value as RbValue};
+use magnus::{
+    exception::ExceptionClass, function, method, prelude::*, wrap, Object, RModule, Ruby,
+    Value as RbValue,
+};
 use optify::builder::OptionsProviderBuilder;
 use optify::builder::OptionsRegistryBuilder;
 use optify::builder::OptionsWatcherBuilder;
@@ -13,6 +16,24 @@ use crate::preferences::MutGetOptionsPreferences;
 
 mod preferences;
 
+const UNKNOWN_FEATURE_PATTERN: &str = "is not a known feature.";
+
+fn get_unknown_feature_error(ruby: &Ruby) -> Result<ExceptionClass, magnus::Error> {
+    let module: RModule = ruby.class_object().const_get("Optify")?;
+    module.const_get("UnknownFeatureError")
+}
+
+fn map_feature_error(ruby: &Ruby, error: String) -> magnus::Error {
+    if error.contains(UNKNOWN_FEATURE_PATTERN) {
+        match get_unknown_feature_error(ruby) {
+            Ok(exception_class) => magnus::Error::new(exception_class, error),
+            Err(_) => magnus::Error::new(ruby.exception_runtime_error(), error),
+        }
+    } else {
+        magnus::Error::new(ruby.exception_runtime_error(), error)
+    }
+}
+
 fn json_value_to_ruby(ruby: &Ruby, value: &serde_json::Value) -> Result<RbValue, magnus::Error> {
     match value {
         serde_json::Value::Null => Ok(ruby.qnil().as_value()),
@@ -117,7 +138,7 @@ impl WrappedOptionsProvider {
             .get_all_options(&feature_names, None, Some(preferences))
         {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -134,7 +155,7 @@ impl WrappedOptionsProvider {
             .get_all_options(&feature_names, None, Some(preferences))
         {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -147,7 +168,7 @@ impl WrappedOptionsProvider {
             .0
             .borrow()
             .get_canonical_feature_name(&feature_name)
-            .map_err(|e| magnus::Error::new(ruby.exception_arg_error(), e))
+            .map_err(|e| map_feature_error(ruby, e))
     }
 
     fn get_canonical_feature_names(
@@ -159,7 +180,7 @@ impl WrappedOptionsProvider {
             .0
             .borrow()
             .get_canonical_feature_names(&feature_names)
-            .map_err(|e| magnus::Error::new(ruby.exception_arg_error(), e))
+            .map_err(|e| map_feature_error(ruby, e))
     }
 
     fn get_feature_metadata_json(&self, canonical_feature_name: String) -> Option<String> {
@@ -191,7 +212,7 @@ impl WrappedOptionsProvider {
             .get_filtered_feature_names(&feature_names, Some(preferences))
         {
             Ok(features) => Ok(features),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -208,7 +229,7 @@ impl WrappedOptionsProvider {
             .get_options_with_preferences(&key, &feature_names, None, None)
         {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -227,7 +248,7 @@ impl WrappedOptionsProvider {
             Some(preferences),
         ) {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -243,7 +264,7 @@ impl WrappedOptionsProvider {
             .get_options_with_preferences(&key, &feature_names, None, None)
         {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -262,13 +283,30 @@ impl WrappedOptionsProvider {
             Some(preferences),
         ) {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
     fn has_conditions(&self, canonical_feature_name: String) -> bool {
         self.0.borrow().has_conditions(&canonical_feature_name)
     }
+
+    fn map_feature_names(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<Vec<Option<String>>, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self
+            .0
+            .borrow()
+            .map_feature_names(&feature_names, Some(preferences))
+        {
+            Ok(features) => Ok(features),
+            Err(e) => Err(map_feature_error(ruby, e)),
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -363,7 +401,7 @@ impl WrappedOptionsWatcher {
             .get_all_options(&feature_names, None, Some(preferences))
         {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -380,7 +418,7 @@ impl WrappedOptionsWatcher {
             .get_all_options(&feature_names, None, Some(preferences))
         {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -393,7 +431,7 @@ impl WrappedOptionsWatcher {
             .0
             .borrow()
             .get_canonical_feature_name(&feature_name)
-            .map_err(|e| magnus::Error::new(ruby.exception_arg_error(), e))
+            .map_err(|e| map_feature_error(ruby, e))
     }
 
     fn get_canonical_feature_names(
@@ -405,7 +443,7 @@ impl WrappedOptionsWatcher {
             .0
             .borrow()
             .get_canonical_feature_names(&feature_names)
-            .map_err(|e| magnus::Error::new(ruby.exception_arg_error(), e))
+            .map_err(|e| map_feature_error(ruby, e))
     }
 
     fn get_feature_metadata_json(&self, canonical_feature_name: String) -> Option<String> {
@@ -436,7 +474,7 @@ impl WrappedOptionsWatcher {
             .get_filtered_feature_names(&feature_names, Some(preferences))
         {
             Ok(features) => Ok(features),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -452,7 +490,7 @@ impl WrappedOptionsWatcher {
             .get_options_with_preferences(&key, &feature_names, None, None)
         {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -471,7 +509,7 @@ impl WrappedOptionsWatcher {
             Some(preferences),
         ) {
             Ok(options) => Ok(options.to_string()),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -487,7 +525,7 @@ impl WrappedOptionsWatcher {
             .get_options_with_preferences(&key, &feature_names, None, None)
         {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -506,7 +544,7 @@ impl WrappedOptionsWatcher {
             Some(preferences),
         ) {
             Ok(options) => json_value_to_ruby(ruby, &options),
-            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+            Err(e) => Err(map_feature_error(ruby, e)),
         }
     }
 
@@ -517,6 +555,23 @@ impl WrappedOptionsWatcher {
     fn last_modified(&self) -> std::time::SystemTime {
         self.0.borrow().last_modified()
     }
+
+    fn map_feature_names(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<Vec<Option<String>>, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self
+            .0
+            .borrow()
+            .map_feature_names(&feature_names, Some(preferences))
+        {
+            Ok(features) => Ok(features),
+            Err(e) => Err(map_feature_error(ruby, e)),
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -551,6 +606,8 @@ impl WrappedOptionsWatcherBuilder {
 fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
     let module = ruby.define_module("Optify")?;
 
+    module.define_error("UnknownFeatureError", ruby.exception_standard_error())?;
+
     let builder_class = module.define_class("OptionsProviderBuilder", ruby.class_object())?;
 
     builder_class
@@ -620,6 +677,10 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "conditions?",
         method!(WrappedOptionsProvider::has_conditions, 1),
     )?;
+    provider_class.define_method(
+        "map_feature_names",
+        method!(WrappedOptionsProvider::map_feature_names, 2),
+    )?;
 
     // Private methods for internal use.
     provider_class.define_private_method(
@@ -759,6 +820,10 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "last_modified",
         method!(WrappedOptionsWatcher::last_modified, 0),
     )?;
+    watcher_class.define_method(
+        "map_feature_names",
+        method!(WrappedOptionsWatcher::map_feature_names, 2),
+    )?;
 
     // Private methods for internal use.
     watcher_class.define_private_method(

data/lib/optify_ruby/cache_init_options.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Optify
+  # The mode for the cache.
+  module CacheMode
+    # Non-thread-safe LRU cache.
+    # Should be faster than `THREAD_SAFE` for single-threaded applications.
+    NOT_THREAD_SAFE = :not_thread_safe #: Symbol
+    # Thread-safe LRU cache.
+    THREAD_SAFE = :thread_safe #: Symbol
+  end
+
+  # Options for initializing the cache.
+  class CacheInitOptions
+    #: Integer?
+    attr_reader :max_size
+
+    # A value from `CacheMode`.
+    #
+    #: Symbol
+    attr_reader :mode
+
+    # Initializes the cache options.
+    # Defaults to a non-thread-safe unlimited size cache for backwards compatibility
+    # with how this library was originally configured with an unbounded hash as the base.
+    # @param mode A value from `CacheMode`.
+    #
+    #: (
+    #|   ?max_size: Integer?,
+    #|   ?mode: Symbol,
+    #| ) -> void
+    def initialize(
+      max_size: nil,
+      mode: CacheMode::NOT_THREAD_SAFE
+    )
+      @max_size = max_size
+      @mode = mode
+    end
+  end
+end

data/lib/optify_ruby/implementation.rb

@@ -4,6 +4,7 @@
 require 'sorbet-runtime'
 
 require_relative './base_config'
+require_relative './cache_init_options'
 require_relative './options_metadata'
 require_relative './provider_module'
 
@@ -32,9 +33,9 @@ module Optify
 
     # (Optional) Eagerly initializes the cache.
     # @return [OptionsProvider] `self`.
-    #: -> OptionsProvider
-    def init
-      _init
+    #: (?CacheInitOptions?) -> OptionsProvider
+    def init(cache_init_options = nil)
+      _init(cache_init_options)
       self
     end
   end

data/lib/optify_ruby/provider_module.rb

@@ -2,11 +2,47 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'lru_redux'
 require 'sorbet-runtime'
 
 module Optify
   # @!visibility private
   module ProviderModule
+    #: [T] (LruRedux::Cache | Hash[untyped, untyped], Array[untyped]) { -> T } -> T
+    def self._cache_getset(cache, cache_key, &block)
+      if cache.is_a? LruRedux::Cache
+        cache.getset(cache_key, &block)
+      else
+        # Plain Hash - use fetch with block and store result
+        cache.fetch(cache_key) do
+          result = block.call
+          cache[cache_key] = result
+        end
+      end
+    end
+
+    #: (CacheInitOptions?) -> ( Hash[Array[untyped], untyped] | LruRedux::Cache)
+    def self._create_cache(cache_init_options)
+      # Be backwards compatible with the original implementation of this library.
+      return {} if cache_init_options.nil?
+
+      max_size = cache_init_options.max_size
+      mode = cache_init_options.mode
+      if max_size.nil?
+        Kernel.raise ArgumentError, 'Thread-safe cache is not supported when max_size is nil' if mode == CacheMode::THREAD_SAFE
+        {}
+      else
+        case mode
+        when CacheMode::THREAD_SAFE
+          LruRedux::ThreadSafeCache.new(max_size)
+        when CacheMode::NOT_THREAD_SAFE
+          LruRedux::Cache.new(max_size)
+        else
+          Kernel.raise ArgumentError, "Invalid cache mode: #{mode}"
+        end
+      end
+    end
+
     #: (Array[String] feature_names) -> Array[String]
     def get_canonical_feature_names(feature_names)
       # Try to optimize a typical case where there are just a few features.
@@ -55,7 +91,7 @@ module Optify
     # @return The options.
     #: [Config] (String, Array[String], Class[Config], ?CacheOptions?, ?Optify::GetOptionsPreferences?) -> Config
     def _get_options(key, feature_names, config_class, cache_options = nil, preferences = nil)
-      return get_options_with_cache(key, feature_names, config_class, cache_options, preferences) if cache_options
+      return _get_options_with_cache(key, feature_names, config_class, cache_options, preferences) if cache_options
 
       unless config_class.respond_to?(:from_hash)
         Kernel.raise NotImplementedError,
@@ -73,14 +109,8 @@ module Optify
         .from_hash(hash)
     end
 
-    #: -> void
-    def _init
-      @cache = {} #: Hash[untyped, untyped]?
-      @features_with_metadata = nil #: Hash[String, OptionsMetadata]?
-    end
-
     #: [Config] (String key, Array[String] feature_names, Class[Config] config_class, Optify::CacheOptions _cache_options, ?Optify::GetOptionsPreferences? preferences) -> Config
-    def get_options_with_cache(key, feature_names, config_class, _cache_options, preferences = nil)
+    def _get_options_with_cache(key, feature_names, config_class, _cache_options, preferences = nil)
       # Cache directly in Ruby instead of Rust because:
       # * Avoid any possible conversion overhead.
       # * Memory management: probably better to do it in Ruby for a Ruby app and avoid memory in Rust.
@@ -100,22 +130,27 @@ module Optify
       # Features are filtered, so we don't need the constraints in the cache key.
       are_configurable_strings_enabled = preferences&.are_configurable_strings_enabled? || false
       cache_key = [key, feature_names, are_configurable_strings_enabled, config_class]
-      @cache #: as !nil
-        .fetch(cache_key) do
+      ProviderModule._cache_getset(
+        @cache, #: as !nil
+        cache_key,
+      ) do
         # Handle a cache miss.
 
         # We can avoid converting the features names because they're already converted from filtering above, if that was desired.
         # We don't need the constraints because we filtered the features above.
         # We already know there are no overrides because we checked above.
-        preferences = GetOptionsPreferences.new
-        preferences.skip_feature_name_conversion = true
-        preferences.enable_configurable_strings if are_configurable_strings_enabled
+        cache_miss_preferences = GetOptionsPreferences.new
+        cache_miss_preferences.skip_feature_name_conversion = true
+        cache_miss_preferences.enable_configurable_strings if are_configurable_strings_enabled
 
-        result = _get_options(key, feature_names, config_class, nil, preferences)
-
-        @cache #: as !nil
-          .[]= cache_key, result
+        _get_options(key, feature_names, config_class, nil, cache_miss_preferences)
       end
     end
+
+    #: (?CacheInitOptions?) -> void
+    def _init(cache_init_options = nil)
+      @cache = ProviderModule._create_cache(cache_init_options) #: ( Hash[untyped, untyped] | LruRedux::Cache)?
+      @features_with_metadata = nil #: Hash[String, OptionsMetadata]?
+    end
   end
 end

data/lib/optify_ruby/watcher_implementation.rb

@@ -30,9 +30,9 @@ module Optify
 
     # (Optional) Eagerly initializes the cache.
     # @return [OptionsWatcher] `self`.
-    #: -> OptionsWatcher
-    def init
-      _init
+    #: (?CacheInitOptions?) -> OptionsWatcher
+    def init(cache_init_options = nil)
+      _init(cache_init_options)
       @cache_creation_time = Time.now #: Time?
       self
     end

data/rbi/optify.rbi

@@ -3,6 +3,10 @@
 
 # Tools for working with configurations declared in files.
 module Optify
+  # Raised when a feature name is not found in the registry.
+  class UnknownFeatureError < StandardError
+  end
+
   # DEPRECATED: Use `Optify::FromHashable` instead.
   # A base class for classes from configuration files.
   # Classes that derive from this can easily be used with `Optify::OptionsProvider.get_options`
@@ -19,6 +23,37 @@ module Optify
   class CacheOptions < FromHashable
   end
 
+  # The mode for the cache.
+  module CacheMode
+    # Non-thread-safe LRU cache.
+    # Should be faster than `THREAD_SAFE` for single-threaded applications.
+    NOT_THREAD_SAFE = T.let(:not_thread_safe, Symbol)
+    # Thread-safe LRU cache.
+    THREAD_SAFE = T.let(:thread_safe, Symbol)
+  end
+
+  # Options for initializing the cache.
+  class CacheInitOptions
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_size
+
+    # A value from `CacheMode`.
+    sig { returns(Symbol) }
+    attr_reader :mode
+
+    # Initializes the cache options.
+    # Defaults to a non-thread-safe unlimited size cache for backwards compatibility
+    # with how this library was originally configured with an unbounded hash as the base.
+    # @param mode A value from `CacheMode`.
+    sig do
+      params(
+        max_size: T.nilable(Integer),
+        mode: Symbol,
+      ).void
+    end
+    def initialize(max_size: nil, mode: CacheMode::NOT_THREAD_SAFE); end
+  end
+
   # Information about a feature.
   class OptionsMetadata < FromHashable
     sig { returns(T.nilable(T::Array[String])) }
@@ -161,6 +196,15 @@ module Optify
   # Some of the methods shown within this module are implemented in Rust
   # and are declared in this common module to avoid duplicate declarations in different classes.
   module ProviderModule
+    # @param canonical_feature_name [String] A canonical feature name
+    # @return Whether the feature has conditions.
+    sig { params(canonical_feature_name: String).returns(T::Boolean) }
+    def conditions?(canonical_feature_name); end
+
+    # @return All of the keys and values for the the features.
+    sig { returns(String) }
+    def features_with_metadata_json; end
+
     # Map an alias or canonical feature name (perhaps derived from a file name) to a canonical feature name.
     # Canonical feature names map to themselves.
     #
@@ -188,7 +232,7 @@ module Optify
     sig do
       params(
         feature_names: T::Array[String],
-        preferences: GetOptionsPreferences
+        preferences: GetOptionsPreferences,
       )
         .returns(T::Array[String])
     end
@@ -211,7 +255,7 @@ module Optify
           feature_names: T::Array[String],
           config_class: T::Class[T.type_parameter(:Config)],
           cache_options: T.nilable(CacheOptions),
-          preferences: T.nilable(Optify::GetOptionsPreferences)
+          preferences: T.nilable(Optify::GetOptionsPreferences),
         )
         .returns(T.type_parameter(:Config))
     end
@@ -257,15 +301,25 @@ module Optify
     end
     def get_options_json_with_preferences(key, feature_names, preferences); end
 
-    # @param canonical_feature_name [String] A canonical feature name
-    # @return Whether the feature has conditions.
-    sig { params(canonical_feature_name: String).returns(T::Boolean) }
-    def conditions?(canonical_feature_name); end
-
     # (Optional) Eagerly initializes the cache.
     # @return `self`.
-    sig { returns(T.self_type) }
-    def init; end
+    sig do
+      params(cache_init_options: T.nilable(CacheInitOptions))
+        .returns(T.self_type)
+    end
+    def init(cache_init_options = nil); end
+
+    # Filters `feature_names` based on the preferences,
+    # such as the `preferences`'s constraints.
+    # Returns an array matching the input order where each element is the canonical name if the feature was kept, or nil if it was filtered out.
+    sig do
+      params(
+        feature_names: T::Array[String],
+        preferences: GetOptionsPreferences,
+      )
+        .returns(T::Array[T.nilable(String)])
+    end
+    def map_feature_names(feature_names, preferences); end
 
     private
 
@@ -281,10 +335,6 @@ module Optify
     # @return The metadata for the feature.
     sig { params(canonical_feature_name: String).returns(T.nilable(String)) }
     def get_feature_metadata_json(canonical_feature_name); end
-
-    # @return All of the keys and values for the the features.
-    sig { returns(String) }
-    def features_with_metadata_json; end
   end
 
   # Provides configurations based on keys and enabled feature names.

data/sig/optify.rbs

@@ -2,6 +2,10 @@
 module Optify
 end
 
+# Raised when a feature name is not found in the registry.
+class Optify::UnknownFeatureError < StandardError
+end
+
 # DEPRECATED: Use `Optify::FromHashable` instead.
 # A base class for classes from configuration files.
 # Classes that derive from this can easily be used with `Optify::OptionsProvider.get_options`
@@ -17,6 +21,22 @@ end
 class Optify::CacheOptions < FromHashable
 end
 
+# The mode for the cache.
+module Optify::CacheMode
+end
+
+Optify::Optify::CacheMode::NOT_THREAD_SAFE: Symbol
+
+Optify::Optify::CacheMode::THREAD_SAFE: Symbol
+
+# Options for initializing the cache.
+class Optify::CacheInitOptions
+  # A value from `CacheMode`.
+  def initialize: () -> Integer?
+                | () -> Symbol
+                | (?max_size: Integer? max_size, ?mode: Symbol mode) -> void
+end
+
 # Information about a feature.
 class Optify::OptionsMetadata < FromHashable
   def aliases: () -> ::Array[String]?
@@ -119,6 +139,13 @@ end
 # Some of the methods shown within this module are implemented in Rust
 # and are declared in this common module to avoid duplicate declarations in different classes.
 module Optify::ProviderModule
+  # @param canonical_feature_name [String] A canonical feature name
+  # @return Whether the feature has conditions.
+  def conditions?: (String canonical_feature_name) -> bool
+
+  # @return All of the keys and values for the the features.
+  def features_with_metadata_json: () -> String
+
   # Map an alias or canonical feature name (perhaps derived from a file name) to a canonical feature name.
   # Canonical feature names map to themselves.
   #
@@ -159,13 +186,9 @@ module Optify::ProviderModule
 
   def get_options_json_with_preferences: (String key, ::Array[String] feature_names, GetOptionsPreferences preferences) -> String
 
-  # @param canonical_feature_name [String] A canonical feature name
-  # @return Whether the feature has conditions.
-  def conditions?: (String canonical_feature_name) -> bool
+  def init: (?CacheInitOptions? cache_init_options) -> self
 
-  # (Optional) Eagerly initializes the cache.
-  # @return `self`.
-  def init: () -> self
+  def map_feature_names: (::Array[String] feature_names, GetOptionsPreferences preferences) -> ::Array[String?]
 
   # Map aliases or canonical feature names (perhaps derived from a file names) to the canonical feature names.
   # Canonical feature names map to themselves.
@@ -177,9 +200,6 @@ module Optify::ProviderModule
 
   # @return The metadata for the feature.
   def get_feature_metadata_json: (String canonical_feature_name) -> String?
-
-  # @return All of the keys and values for the the features.
-  def features_with_metadata_json: () -> String
 end
 
 # Provides configurations based on keys and enabled feature names.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 1.18.0
+  version: 1.21.1
 platform: ruby
 authors:
 - Justin D. Harris
@@ -15,28 +15,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.117
+        version: 0.9.124
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.117
+        version: 0.9.124
 - !ruby/object:Gem::Dependency
   name: optify-from_hash
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: sin_lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -91,14 +105,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.76.1
+        version: 1.82.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.76.1
+        version: 1.82.1
 - !ruby/object:Gem::Dependency
   name: rubocop-sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -175,6 +189,7 @@ files:
 - ext/optify_ruby/src/preferences.rs
 - lib/optify.rb
 - lib/optify_ruby/base_config.rb
+- lib/optify_ruby/cache_init_options.rb
 - lib/optify_ruby/get_options_preferences.rb
 - lib/optify_ruby/implementation.rb
 - lib/optify_ruby/options_metadata.rb