optify-config 0.4.5-x86_64-linux → 0.5.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61b60b3de9aed7bb5e3505e50cce60b9ac0cdf48442b660f2ffa46b93646dff8
-  data.tar.gz: fa74293e430542ed80331539806ecf29b63a303c321082d8446c197d6d9ac92e
+  metadata.gz: f6d592561af2272187516372a4c4c8dcf3b2ff66c3eaf0d4188f94a97561c6b7
+  data.tar.gz: 485852f9405f080f684400e552b42de1abf43e075f4a3fd13097223edf279425
 SHA512:
-  metadata.gz: adb4a8c0a2713e14b8346c73b676455f86c06c21393612f1d399fb00485316ec4160c3bfaa0de3a5757885b843b3abf1df0734b5c6071c28b5db7433e1465c1b
-  data.tar.gz: 66a4fb1a085bd16181a2a003de3e952f0546bbfa5106d48d7e2ae995fafacc43f582638292b68dd8d12e2511e185d63eea1f786af56ad490a5cc4d5a3eb0c3cc
+  metadata.gz: d79d2bfbd4cdf84c6c7126c390dd4fadde5857232e8ea26a6b5687a3a9c344f2cb17887905235ec37d0b2e35e0bd167837178a3e48ae4018d384f86e9a8de696
+  data.tar.gz: b91df6d5c3bb954781cb5e9be9d4f425df17c829ecf0fe4afc132510298988a5e0fb51ffd6f159cc5a70ed0e18d1d583ecdad8746a05403a6db16e3b1828a03a

data/lib/optify_ruby/base_config.rb

@@ -16,7 +16,7 @@ module Optify
     extend T::Helpers
     abstract!
 
-    # Create a new instance of the class from a hash.
+    # Create a new immutable instance of the class from a hash.
     #
     # This is a class method that so that it can set members with private setters.
     # @param hash [Hash] The hash to create the instance from.
@@ -30,7 +30,8 @@ module Optify
         value = _convert_value(value, sig_return_type)
         result.instance_variable_set("@#{key}", value)
       end
-      result
+
+      T.unsafe(result).freeze if T.unsafe(result).respond_to?(:freeze)
     end
 
     sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
@@ -44,11 +45,11 @@ module Optify
                  # Handle array of 1 type.
                  type.type
                end
-        return value.map { |v| _convert_value(v, type) }
+        return value.map { |v| _convert_value(v, type) }.freeze
       when Hash
         # Handle nilable hash.
         type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
-        return _convert_hash(value, type)
+        return _convert_hash(value, type).freeze
       end
 
       value

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,25 +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)
-      T.unsafe(result).freeze if T.unsafe(result).respond_to?(:freeze)
+      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.5
+  version: 0.5.0
 platform: x86_64-linux
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime