optify-config 0.4.6-aarch64-linux → 0.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f5a5d6197f5d36b99efdf187d48ea186bc47b45a68c4f8c07781f1fc1b1919
-  data.tar.gz: 785fd1a53790d5147bf1ca0139fb10fc162267cb1c391230c4019079c629d5c8
+  metadata.gz: 86b1b6a0724c23d2c5bf72e6835d9523dd36cc80919bbefa484b3c6a86f59ce3
+  data.tar.gz: 4fa13d99ea25b46d0790ab435bf3d256653a55a513dc6150cd447341135e8bf6
 SHA512:
-  metadata.gz: c6b294ef55d0d8b7947f67cd8c70c6a730d3eaccf687a7f9e37e541d288aa4ec4f0074e0c9def1ebc9e63f06d90860fb1e353c57cad8d38eadb3e95cbbc0d0c3
-  data.tar.gz: 45ea42b24324f9c2113c528ef8c38b7b509d49bac30cfe1117d2a73b3a2e9f5f7f6dfb89d4062a9679fef238e58d604ff5e9a18e017e942168055870957a51d6
+  metadata.gz: df5f70f4962e3b8abb98da20b5b2099986a5e9c27fd31b45afb9d29f92ec331f9481760d8e622a72a80115bbcb605e88726cc9af5e4f97c3a1386c036c37fe25
+  data.tar.gz: 7970abf30ceb3c97a20ee0468ccc0fa41142403fe7ad0eed467ef26238a6787d907714c73c90f31a49be82848b76d6695345fb209542e42ffa8730163cabbfb1

data/lib/optify_ruby/implementation.rb

@@ -24,7 +24,8 @@ module Optify
     # @param feature_names [Array<String>] The enabled feature names to use to build the options.
     # @param config_class [ConfigType] The class of the configuration to return.
     # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
-    # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
+    # @param cache_options [CacheOptions] Set this if caching is desired. Only very simple caching is supported for now.
+    # @param preferences [GetOptionsPreferences] The preferences to use when getting options.
     # @return [ConfigType] The options.
     sig do
       type_parameters(:Config)
@@ -32,12 +33,13 @@ module Optify
           key: String,
           feature_names: T::Array[String],
           config_class: T::Class[T.type_parameter(:Config)],
-          cache_options: T.nilable(CacheOptions)
+          cache_options: T.nilable(CacheOptions),
+          preferences: T.nilable(Optify::GetOptionsPreferences)
         )
         .returns(T.type_parameter(:Config))
     end
-    def get_options(key, feature_names, config_class, cache_options = nil)
-      return get_options_with_cache(key, feature_names, config_class, cache_options) if cache_options
+    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
 
       unless config_class.respond_to?(:from_hash)
         raise NotImplementedError,
@@ -46,11 +48,23 @@ module Optify
               Recommended: extend `Optify::BaseConfig`."
       end
 
-      options_json = get_options_json(key, feature_names)
+      options_json = if preferences
+                       get_options_json_with_preferences(key, feature_names, preferences)
+                     else
+                       get_options_json(key, feature_names)
+                     end
       hash = JSON.parse(options_json)
       T.unsafe(config_class).from_hash(hash)
     end
 
+    # (Optional) Eagerly initializes the cache.
+    # @return [OptionsProvider] `self`.
+    sig { returns(OptionsProvider) }
+    def init
+      @cache = T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
+      self
+    end
+
     private
 
     NOT_FOUND_IN_CACHE_SENTINEL = Object.new
@@ -61,24 +75,29 @@ module Optify
           key: String,
           feature_names: T::Array[String],
           config_class: T::Class[T.type_parameter(:Config)],
-          _cache_options: CacheOptions
+          _cache_options: CacheOptions,
+          preferences: T.nilable(Optify::GetOptionsPreferences)
         )
         .returns(T.type_parameter(:Config))
     end
-    def get_options_with_cache(key, feature_names, config_class, _cache_options)
+    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.
-      # TODO: Consider aliases when caching. Right now, they are only visible in Rust
-      # and we don't want the cache in Rust because we won't to avoid any conversion overhead.
-      @cache ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
+      init unless @cache
+      feature_names = feature_names.map do |feature_name|
+        get_canonical_feature_name(feature_name)
+      end
+
       cache_key = [key, feature_names, config_class]
-      result = @cache.fetch(cache_key, NOT_FOUND_IN_CACHE_SENTINEL)
+      result = @cache&.fetch(cache_key, NOT_FOUND_IN_CACHE_SENTINEL)
       return result unless result.equal?(NOT_FOUND_IN_CACHE_SENTINEL)
 
-      result = get_options(key, feature_names, config_class)
+      preferences ||= GetOptionsPreferences.new
+      preferences.skip_feature_name_conversion = true
+      result = get_options(key, feature_names, config_class, nil, preferences)
 
-      @cache[cache_key] = result
+      T.must(@cache)[cache_key] = result
     end
   end
 end

data/rbi/optify.rbi

@@ -26,15 +26,32 @@ module Optify
   class CacheOptions < BaseConfig
   end
 
+  # Preferences when getting options.
+  class GetOptionsPreferences
+    sig { params(value: T::Boolean).returns(GetOptionsPreferences) }
+    def skip_feature_name_conversion=(value); end
+    sig { returns(T::Boolean) }
+    def skip_feature_name_conversion; end
+  end
+
   # Provides configurations based on keys and enabled feature names.
   class OptionsProvider
+    # Map an alias or canonical feature name (perhaps derived from a file name) to a canonical feature name.
+    # Canonical feature names map to themselves.
+    #
+    # @param feature_name The name of an alias or a feature.
+    # @return The canonical feature name.
+    sig { params(feature_name: String).returns(String) }
+    def get_canonical_feature_name(feature_name); end
+
     # Fetches options based on the provided key and feature names.
     #
     # @param key [String] the key to fetch options for.
     # @param feature_names [Array<String>] The enabled feature names to use to build the options.
     # @param config_class [ConfigType] The class of the configuration to return.
     # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
-    # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
+    # @param cache_options [CacheOptions] Set this if caching is desired. Only very simple caching is supported for now.
+    # @param preferences [GetOptionsPreferences] The preferences to use when getting options.
     # @return [ConfigType] The options.
     sig do
       type_parameters(:Config)
@@ -42,11 +59,12 @@ module Optify
           key: String,
           feature_names: T::Array[String],
           config_class: T::Class[T.type_parameter(:Config)],
-          cache_options: T.nilable(CacheOptions)
+          cache_options: T.nilable(CacheOptions),
+          preferences: T.nilable(Optify::GetOptionsPreferences)
         )
         .returns(T.type_parameter(:Config))
     end
-    def get_options(key, feature_names, config_class, cache_options = nil); end
+    def get_options(key, feature_names, config_class, cache_options = nil, preferences = nil); end
 
     # Fetches options in JSON format based on the provided key and feature names.
     #
@@ -55,6 +73,23 @@ module Optify
     # @return [String] the options in JSON.
     sig { params(key: String, feature_names: T::Array[String]).returns(String) }
     def get_options_json(key, feature_names); end
+
+    # Fetches options in JSON format based on the provided key and feature names.
+    #
+    # @param key [String] the key to fetch options for.
+    # @param feature_names [Array<String>] The enabled feature names to use to build the options.
+    # @param preferences [GetOptionsPreferences] The preferences to use when getting options.
+    # @return [String] the options in JSON.
+    sig do
+      params(key: String, feature_names: T::Array[String], preferences: GetOptionsPreferences)
+        .returns(String)
+    end
+    def get_options_json_with_preferences(key, feature_names, preferences); end
+
+    # (Optional) Eagerly initializes the cache.
+    # @return [OptionsProvider] `self`.
+    sig { returns(OptionsProvider) }
+    def init; end
   end
 
   # A builder for creating an `OptionsProvider` instance.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: aarch64-linux
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime