optify-config 0.4.5-arm64-darwin → 0.5.0-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b10cb37278306bd9da1250a3a5958c2165fd14fb7289e64cc49c58f9d3e79f2
-  data.tar.gz: 96213deb814fb5161074e3fd11995a2cbcd9a4d6e1964906148877b6f431a1d9
+  metadata.gz: 47cf7688c8f3c9577071f1341ff980f68dbbd97986819c4f8350a996ba4f5a37
+  data.tar.gz: bb291553dc8d1f317e8526c1ddcb8ae15c20830e43625dd830f5cd9440b0b810
 SHA512:
-  metadata.gz: b0be294ba5a11d2d26167db9d3f9c05ef7766f5cb3a833e6c6c0fbed04c25eeb333b3df12a35e39aa525716bda6cb9455c6922efc7c974cd35dfe45b69d755b9
-  data.tar.gz: fd15663c091e83330192ce2e1708f7ee7775ca24a65fa13926ef2cbf0eb00cb031de1e55316b6b3003698a834f836242f91bab2d50b933e9779bca4864fa2a74
+  metadata.gz: 1b8ddc42cce41b784eef183b84fb50481b1fe80313c998dd39607580ddfb6ba85181758dbe657597246265276dd72ab9326859cb3660d4ad4402f5c0ab059ff6
+  data.tar.gz: 4fbfa6f0613702b023ef4288033c2ebf9464f74d74e98d627d42397a9e33a04a87c2c0f12ddda5c266678ab1a78743025e01d263a94ef17aa10f6e2ee76d9419

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: arm64-darwin
 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