optify-config 1.17.4 → 1.17.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddc8459ff6f74376a610782d4fc078ce91f197a971fd342505694396cf427657
-  data.tar.gz: 6f77569afc22e2d209c8efd4f83d6dab2942b806f107a90e839eebb4f000a285
+  metadata.gz: bb889131ad05549592201854a95085f700c72a576d220c5f76f7169332d49cad
+  data.tar.gz: 9c7d21e4319ddc82e459ff85ddac506b3e740b28375b1dc7753ed6cc1af64858
 SHA512:
-  metadata.gz: f62b8ffe0e38f0c3d8c69eba643da48e7de8cb790c8d5fa130064ad8b0713d309e6f8917cf886aa2ce481936243c94bf8a570c976d61549b31c5e558628ea502
-  data.tar.gz: b3267d50c074c09ad428d29583daaa468f8fddebb2659cbddb5e44a02768cdef2ae76eace4ef1ebe1f9776b00459cac3529a4f55d6c459405e8402e516ae1946
+  metadata.gz: aee1ece9d60a043e3fb6c81c9152759dbacaca66e94e766eb3f5920fc4b13b3a2363b2fd97014a26c9ca75841a3233bdcaacc952099e74ff012dd7c9ec3b3589
+  data.tar.gz: 86b083e4b963b968a7162de2581a6b1ffd6878cf3be15f2b12adf1b56fe1f20b8ef4529ed5017e7982b235d86edc755eef2f47f46ab864463ee619ea028295c6

data/ext/optify_ruby/extconf.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: false
+# frozen_string_literal: true
 
 require 'mkmf'
 require 'rb_sys/mkmf'

data/ext/optify_ruby/src/lib.rs

@@ -1,4 +1,4 @@
-use magnus::{function, method, prelude::*, wrap, Object, Ruby};
+use magnus::{function, method, prelude::*, wrap, Object, Ruby, Value as RbValue};
 use optify::builder::OptionsProviderBuilder;
 use optify::builder::OptionsRegistryBuilder;
 use optify::builder::OptionsWatcherBuilder;
@@ -13,6 +13,40 @@ use crate::preferences::MutGetOptionsPreferences;
 
 mod preferences;
 
+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()),
+        serde_json::Value::Bool(b) => Ok(ruby.into_value(*b)),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Ok(ruby.into_value(i))
+            } else if let Some(f) = n.as_f64() {
+                Ok(ruby.into_value(f))
+            } else {
+                Err(magnus::Error::new(
+                    ruby.exception_type_error(),
+                    "Invalid number",
+                ))
+            }
+        }
+        serde_json::Value::String(s) => Ok(ruby.into_value(s.as_str())),
+        serde_json::Value::Array(arr) => {
+            let rb_arr = ruby.ary_new_capa(arr.len());
+            for item in arr {
+                rb_arr.push(json_value_to_ruby(ruby, item)?)?;
+            }
+            Ok(rb_arr.as_value())
+        }
+        serde_json::Value::Object(obj) => {
+            let rb_hash = ruby.hash_new_capa(obj.len());
+            for (key, val) in obj {
+                rb_hash.aset(key.as_str(), json_value_to_ruby(ruby, val)?)?;
+            }
+            Ok(rb_hash.as_value())
+        }
+    }
+}
+
 #[wrap(class = "Optify::OptionsProvider")]
 struct WrappedOptionsProvider(RefCell<OptionsProvider>);
 
@@ -87,6 +121,23 @@ impl WrappedOptionsProvider {
         }
     }
 
+    fn get_all_options_hash(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<RbValue, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self
+            .0
+            .borrow()
+            .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)),
+        }
+    }
+
     fn get_canonical_feature_name(
         ruby: &Ruby,
         rb_self: &Self,
@@ -179,6 +230,41 @@ impl WrappedOptionsProvider {
             Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
         }
     }
+
+    fn get_options_hash(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+    ) -> Result<RbValue, magnus::Error> {
+        match rb_self
+            .0
+            .borrow()
+            .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)),
+        }
+    }
+
+    fn get_options_hash_with_preferences(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<RbValue, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self.0.borrow().get_options_with_preferences(
+            &key,
+            &feature_names,
+            None,
+            Some(preferences),
+        ) {
+            Ok(options) => json_value_to_ruby(ruby, &options),
+            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -277,6 +363,23 @@ impl WrappedOptionsWatcher {
         }
     }
 
+    fn get_all_options_hash(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<RbValue, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self
+            .0
+            .borrow()
+            .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)),
+        }
+    }
+
     fn get_canonical_feature_name(
         ruby: &Ruby,
         rb_self: &Self,
@@ -368,6 +471,41 @@ impl WrappedOptionsWatcher {
         }
     }
 
+    fn get_options_hash(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+    ) -> Result<RbValue, magnus::Error> {
+        match rb_self
+            .0
+            .borrow()
+            .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)),
+        }
+    }
+
+    fn get_options_hash_with_preferences(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<RbValue, magnus::Error> {
+        let preferences = &convert_preferences(preferences);
+        match rb_self.0.borrow().get_options_with_preferences(
+            &key,
+            &feature_names,
+            None,
+            Some(preferences),
+        ) {
+            Ok(options) => json_value_to_ruby(ruby, &options),
+            Err(e) => Err(magnus::Error::new(ruby.exception_runtime_error(), e)),
+        }
+    }
+
     fn last_modified(&self) -> std::time::SystemTime {
         self.0.borrow().last_modified()
     }
@@ -442,6 +580,10 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "get_all_options_json",
         method!(WrappedOptionsProvider::get_all_options_json, 2),
     )?;
+    provider_class.define_method(
+        "get_all_options_hash",
+        method!(WrappedOptionsProvider::get_all_options_hash, 2),
+    )?;
     provider_class.define_method(
         "get_canonical_feature_name",
         method!(WrappedOptionsProvider::get_canonical_feature_name, 1),
@@ -458,6 +600,14 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "get_options_json_with_preferences",
         method!(WrappedOptionsProvider::get_options_json_with_preferences, 3),
     )?;
+    provider_class.define_method(
+        "get_options_hash",
+        method!(WrappedOptionsProvider::get_options_hash, 2),
+    )?;
+    provider_class.define_method(
+        "get_options_hash_with_preferences",
+        method!(WrappedOptionsProvider::get_options_hash_with_preferences, 3),
+    )?;
 
     // Private methods for internal use.
     provider_class.define_private_method(
@@ -561,6 +711,10 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "get_all_options_json",
         method!(WrappedOptionsWatcher::get_all_options_json, 2),
     )?;
+    watcher_class.define_method(
+        "get_all_options_hash",
+        method!(WrappedOptionsWatcher::get_all_options_hash, 2),
+    )?;
     watcher_class.define_method(
         "get_canonical_feature_name",
         method!(WrappedOptionsWatcher::get_canonical_feature_name, 1),
@@ -577,6 +731,14 @@ fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
         "get_options_json_with_preferences",
         method!(WrappedOptionsWatcher::get_options_json_with_preferences, 3),
     )?;
+    watcher_class.define_method(
+        "get_options_hash",
+        method!(WrappedOptionsWatcher::get_options_hash, 2),
+    )?;
+    watcher_class.define_method(
+        "get_options_hash_with_preferences",
+        method!(WrappedOptionsWatcher::get_options_hash_with_preferences, 3),
+    )?;
     watcher_class.define_method(
         "last_modified",
         method!(WrappedOptionsWatcher::last_modified, 0),

data/lib/optify.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 # The implementation to use directly Ruby and with types declared.
 require_relative 'optify_ruby/get_options_preferences'

data/lib/optify_ruby/base_config.rb

@@ -1,159 +1,18 @@
 # typed: strict
 # frozen_string_literal: true
 
+require 'optify-from_hash'
 require 'sorbet-runtime'
 require 'tapioca'
 
 module Optify
+  # 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`
   # because they will have an implementation of `from_hash` that works recursively.
   # This class is a work in progress with minimal error handling.
   # It may be moved to another gem in the future.
-  class BaseConfig
-    extend T::Sig
-    extend T::Helpers
+  class BaseConfig < Optify::FromHashable
     abstract!
-
-    # Create a new immutable instance of the class from a hash.
-    #
-    # This is a class method so that it can set members with private setters.
-    # @param hash The hash to create the instance from.
-    # @return The new instance.
-    #: (Hash[untyped, untyped] hash) -> instance
-    def self.from_hash(hash)
-      instance = new
-
-      hash.each do |key, value|
-        begin
-          method = instance_method(key)
-        rescue StandardError
-          raise ArgumentError, "Error converting hash to `#{name}` because of key \"#{key}\". Perhaps \"#{key}\" is not a valid attribute for `#{name}`."
-        end
-
-        sig = T::Utils.signature_for_method(method)
-        raise "A Sorbet signature is required for `#{name}.#{key}`." if sig.nil?
-
-        sig_return_type = sig.return_type
-        value = _convert_value(value, sig_return_type)
-        instance.instance_variable_set("@#{key}", value)
-      end
-
-      instance.freeze
-    end
-
-    #: (untyped value, untyped type) -> untyped
-    def self._convert_value(value, type)
-      if type.is_a?(T::Types::Untyped)
-        # No preferred type is given, so return the value as is.
-        return value
-      end
-
-      return value.to_sym if type.is_a?(T::Types::Simple) && type.raw_type == Symbol
-
-      case value
-      when Array
-        # Handle `T.nilable(T::Array[...])`
-        type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
-        inner_type = type.type
-        return value.map { |v| _convert_value(v, inner_type) }.freeze
-      when Hash
-        # Handle `T.nilable(T::Hash[...])` and `T.any(...)`.
-        # We used to use `type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)`, but it's not needed now that we handle `T.any(...)`
-        # because using `.types` works for both cases.
-        if type.respond_to?(:types)
-          # Find a type that works for the hash.
-          type.types.each do |t|
-            return _convert_hash(value, t).freeze
-          rescue StandardError
-            # Ignore and try the next type.
-          end
-          raise TypeError, "Could not convert hash: #{value} to #{type}."
-        end
-        return _convert_hash(value, type).freeze
-      end
-
-      # It would be nice to validate that the value is of the correct type here.
-      # For example that a string is a string and an Integer is an Integer.
-      value
-    end
-
-    #: (Hash[untyped, untyped] hash, untyped type) -> untyped
-    def self._convert_hash(hash, type)
-      if type.respond_to?(:raw_type)
-        # There is an object for the hash.
-        # It could be a custom class, a String, or maybe something else.
-        type_for_hash = type.raw_type
-        return type_for_hash.from_hash(hash) if type_for_hash.respond_to?(:from_hash)
-      elsif type.is_a?(T::Types::TypedHash)
-        # The hash should be a hash, but the values might be objects to convert.
-        type_for_keys = type.keys
-
-        convert_key = if type_for_keys.is_a?(T::Types::Simple) && type_for_keys.raw_type == Symbol
-                        lambda(&:to_sym)
-                      else
-                        lambda(&:itself)
-                      end
-
-        type_for_values = type.values
-        return hash.map { |k, v| [convert_key.call(k), _convert_value(v, type_for_values)] }.to_h
-      end
-
-      raise TypeError, "Could not convert hash #{hash} to `#{type}`."
-    end
-
-    private_class_method :_convert_hash, :_convert_value
-
-    # Compare this object with another object for equality.
-    # @param other The object to compare.
-    # @return [Boolean] true if the objects are equal; otherwise, false.
-    #: (untyped other) -> bool
-    def ==(other)
-      return true if other.equal?(self)
-      return false unless other.is_a?(self.class)
-
-      instance_variables.all? do |name|
-        instance_variable_get(name) == other.instance_variable_get(name)
-      end
-    end
-
-    # Convert this object to a Hash recursively.
-    # This is mostly the reverse operation of `from_hash`,
-    # as keys will be symbols
-    # and `from_hash` will convert strings to symbols if that's how the attribute is declared.
-    # @return [Hash] The hash representation of this object.
-    #: () -> Hash[Symbol, untyped]
-    def to_h
-      result = Hash.new(instance_variables.size)
-
-      instance_variables.each do |var_name|
-        # Remove the @ prefix to get the method name
-        method_name = var_name.to_s[1..] #: as !nil
-        value = instance_variable_get(var_name)
-        result[method_name.to_sym] = _convert_value_to_hash(value)
-      end
-
-      result
-    end
-
-    private
-
-    #: (untyped value) -> untyped
-    def _convert_value_to_hash(value)
-      case value
-      when Array
-        value.map { |v| _convert_value_to_hash(v) }
-      when Hash
-        value.transform_values { |v| _convert_value_to_hash(v) }
-      when nil
-        nil
-      else
-        if value.respond_to?(:to_h)
-          value.to_h
-        else
-          value
-        end
-      end
-    end
   end
 end

data/lib/optify_ruby/get_options_preferences.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 module Optify
   # Preferences for `get_options`.

data/lib/optify_ruby/implementation.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require 'sorbet-runtime'
 
@@ -11,7 +11,7 @@ require_relative './provider_module'
 module Optify
   # Options for caching.
   # Only enabling or disabling caching is supported for now.
-  class CacheOptions < BaseConfig
+  class CacheOptions < FromHashable
   end
 
   # Provides configurations based on keys and enabled feature names.

data/lib/optify_ruby/options_metadata.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'sorbet-runtime'
 
@@ -7,7 +7,9 @@ require_relative './base_config'
 
 module Optify
   # Information about a feature.
-  class OptionsMetadata < BaseConfig
+  class OptionsMetadata < FromHashable
+    extend T::Sig
+
     sig { returns(T.nilable(T::Array[String])) }
     attr_reader :aliases
 

data/lib/optify_ruby/provider_module.rb

@@ -1,6 +1,7 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
+require 'json'
 require 'sorbet-runtime'
 
 module Optify
@@ -48,11 +49,11 @@ module Optify
     # @param feature_names The enabled feature names to use to build the options.
     # @param config_class The class of the configuration to return.
     # The class must implement `from_hash` as a class method to convert a hash to an instance of the class.
-    # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
+    # It is recommended to use a class that extends `Optify::FromHashable` because it implements `from_hash`.
     # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
     # @param preferences The preferences to use when getting options.
     # @return The options.
-    #: [Config] (String key, Array[String] feature_names, Class[Config] config_class, ?CacheOptions? cache_options, ?Optify::GetOptionsPreferences? preferences) -> Config
+    #: [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
 
@@ -60,15 +61,14 @@ module Optify
         Kernel.raise NotImplementedError,
                      "The provided config class must implement `from_hash` as a class method
               in order to be converted.
-              Recommended: extend `Optify::BaseConfig`."
+              Recommended: extend `Optify::FromHashable`."
       end
 
-      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)
+      hash = if preferences
+               get_options_hash_with_preferences(key, feature_names, preferences)
+             else
+               get_options_hash(key, feature_names)
+             end
       config_class #: as untyped
         .from_hash(hash)
     end
@@ -79,8 +79,6 @@ module Optify
       @features_with_metadata = nil #: Hash[String, OptionsMetadata]?
     end
 
-    NOT_FOUND_IN_CACHE_SENTINEL = Object.new
-
     #: [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)
       # Cache directly in Ruby instead of Rust because:
@@ -102,23 +100,22 @@ 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]
-      result = @cache #: as !nil
-               .fetch(cache_key, NOT_FOUND_IN_CACHE_SENTINEL)
-      return result unless result.equal?(NOT_FOUND_IN_CACHE_SENTINEL)
-
-      # Handle a cache miss.
+      @cache #: as !nil
+        .fetch(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
+        # 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
 
-      result = get_options(key, feature_names, config_class, nil, preferences)
+        result = get_options(key, feature_names, config_class, nil, preferences)
 
-      @cache #: as !nil
-        .[]= cache_key, result
+        @cache #: as !nil
+          .[]= cache_key, result
+      end
     end
   end
 end

data/lib/optify_ruby/watcher_implementation.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require 'sorbet-runtime'
 

data/rbi/optify.rbi

@@ -1,47 +1,26 @@
-# frozen_string_literal: true
 # typed: strong
+# frozen_string_literal: true
 
 # Tools for working with configurations declared in files.
 module Optify
+  # 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`
   # because they will have an implementation of `from_hash` that works recursively.
   # This class is a work in progress with minimal error handling
   # and doesn't handle certain cases such as nilable types yet.
   # It may be moved to another gem in the future.
-  class BaseConfig
+  class BaseConfig < FromHashable
     abstract!
-
-    # Create a new instance of the class from a hash.
-    #
-    # This is a class method that so that it can set members with private setters.
-    # @param hash The hash to create the instance from.
-    # @return The new instance.
-    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
-    def self.from_hash(hash); end
-
-    # Convert this object to a Hash recursively.
-    # This is mostly the reverse operation of `from_hash`,
-    # as keys will be symbols
-    # and `from_hash` will convert strings to symbols if that's how the attribute is declared.
-    # @return The hash representation of this object.
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-    def to_h; end
-
-    # Compare this object with another object for equality.
-    # @param other The object to compare.
-    # @return [Boolean] true if the objects are equal; otherwise, false.
-    sig { params(other: T.untyped).returns(T::Boolean) }
-    def ==(other); end
   end
 
   # Options for caching.
   # Only enabling or disabling caching is supported for now.
-  class CacheOptions < BaseConfig
+  class CacheOptions < FromHashable
   end
 
   # Information about a feature.
-  class OptionsMetadata < BaseConfig
+  class OptionsMetadata < FromHashable
     sig { returns(T.nilable(T::Array[String])) }
     def aliases; end
 
@@ -163,6 +142,13 @@ module Optify
     sig { returns(T::Hash[String, OptionsMetadata]) }
     def features_with_metadata; end
 
+    # @return All of the keys and values for the the features.
+    sig do
+      params(feature_names: T::Array[String], preferences: GetOptionsPreferences)
+        .returns(T::Hash[String, T.untyped])
+    end
+    def get_all_options_hash(feature_names, preferences); end
+
     # @return All of the keys and values for the the features.
     sig do
       params(feature_names: T::Array[String], preferences: GetOptionsPreferences)
@@ -214,7 +200,7 @@ module Optify
     # @param feature_names The enabled feature names to use to build the options.
     # @param config_class The class of the configuration to return.
     # The class must implement `from_hash` as a class method to convert a hash to an instance of the class.
-    # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
+    # It is recommended to use a class that extends `Optify::FromHashable` because it implements `from_hash`.
     # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
     # @param preferences The preferences to use when getting options.
     # @return The options.
@@ -231,6 +217,26 @@ module Optify
     end
     def get_options(key, feature_names, config_class, cache_options = nil, preferences = nil); 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.
+    # @return [Hash[String, T.untyped]] the options.
+    sig { params(key: String, feature_names: T::Array[String]).returns(T::Hash[String, T.untyped]) }
+    def get_options_hash(key, feature_names); 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 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(T::Hash[String, T.untyped])
+    end
+    def get_options_hash_with_preferences(key, feature_names, preferences); end
+
     # Fetches options in JSON format based on the provided key and feature names.
     #
     # @param key [String] the key to fetch options for.

data/sig/optify.rbs

@@ -2,40 +2,23 @@
 module Optify
 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`
 # because they will have an implementation of `from_hash` that works recursively.
 # This class is a work in progress with minimal error handling
 # and doesn't handle certain cases such as nilable types yet.
 # It may be moved to another gem in the future.
-class Optify::BaseConfig
-  # Create a new instance of the class from a hash.
-  #
-  # This is a class method that so that it can set members with private setters.
-  # @param hash The hash to create the instance from.
-  # @return The new instance.
-  def self.from_hash: (::Hash[untyped, untyped] hash) -> instance
-
-  # Convert this object to a Hash recursively.
-  # This is mostly the reverse operation of `from_hash`,
-  # as keys will be symbols
-  # and `from_hash` will convert strings to symbols if that's how the attribute is declared.
-  # @return The hash representation of this object.
-  def to_h: () -> ::Hash[Symbol, untyped]
-
-  # Compare this object with another object for equality.
-  # @param other The object to compare.
-  # @return [Boolean] true if the objects are equal; otherwise, false.
-  def ==: (untyped other) -> bool
+class Optify::BaseConfig < FromHashable
 end
 
 # Options for caching.
 # Only enabling or disabling caching is supported for now.
-class Optify::CacheOptions < BaseConfig
+class Optify::CacheOptions < FromHashable
 end
 
 # Information about a feature.
-class Optify::OptionsMetadata < BaseConfig
+class Optify::OptionsMetadata < FromHashable
   def aliases: () -> ::Array[String]?
 
   # The canonical names of features that import this one.
@@ -127,6 +110,8 @@ class Optify::OptionsRegistry
   # @return All of the keys and values for the the features.
   def features_with_metadata: () -> ::Hash[String, OptionsMetadata]
 
+  def get_all_options_hash: (::Array[String] feature_names, GetOptionsPreferences preferences) -> ::Hash[String, untyped]
+
   def get_all_options_json: (::Array[String] feature_names, GetOptionsPreferences preferences) -> String
 end
 
@@ -156,6 +141,15 @@ module Optify::ProviderModule
 
   def get_options: [Config] (String key, ::Array[String] feature_names, T::Class[Config] config_class, ?CacheOptions? cache_options, ?Optify::GetOptionsPreferences? preferences) -> Config
 
+  # 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.
+  # @return [Hash[String, T.untyped]] the options.
+  def get_options_hash: (String key, ::Array[String] feature_names) -> ::Hash[String, untyped]
+
+  def get_options_hash_with_preferences: (String key, ::Array[String] feature_names, GetOptionsPreferences preferences) -> ::Hash[String, untyped]
+
   # Fetches options in JSON format based on the provided key and feature names.
   #
   # @param key [String] the key to fetch options for.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 1.17.4
+  version: 1.17.8
 platform: ruby
 authors:
 - Justin D. Harris
 bindir: exe
 cert_chain: []
-date: 2025-10-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.117
+- !ruby/object:Gem::Dependency
+  name: optify-from_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -71,6 +85,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.0.0.dev.4
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.76.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.76.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -160,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Configure your Ruby project using JSON and YAML files that can be combined
   at runtime.