optify-config 1.17.4-x86_64-linux → 1.17.5-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa8769d1492664a0016daf065b78e0dea2fbf8538fa84d4da27518565e54fbee
-  data.tar.gz: 6f264e7f05773d3c7e281b9f9834508dae7eb283eb2d29f4c9170475bdada3be
+  metadata.gz: 76ca75d9f4dc94d5a811cbd541b71ddd1f34ce81dcabaddf28be5b21df0985b9
+  data.tar.gz: 180fd116144308d51f2673599ba2431e731f1f22632a5007fdaf24a0e1d8b024
 SHA512:
-  metadata.gz: a5956f86461f89d3d97db07d0fb038c850d6a747b444c667ec3b83ced3a4b459c474617ce47b89c1d481edff7d1b827c796e42768cedbe01de3965659de4740c
-  data.tar.gz: 2987b14782b7bde058ff1a0b53a855eb052421f70e91bb0af7e07fb02d1903f663d2a5eb0dead02efaeefb6d89a9e311c906f50e8c287ff302569c3c5f6409c0
+  metadata.gz: b4077119ca97e26dd6679db5fd8ae23db3fa3d190adf12266bb7c848b842ec10aafa608f7ca183ab88c2ffd99bde21437e200cc9b78ffdfeaebf16bc8f4cd431
+  data.tar.gz: cf4a5e144d8e14651b75273fe582b4d880d41fa5a5eb86baed964774d2b211df55f60fef0d99dba735e1918c5b7bd08eb38f4375df60a79f3c2364e24000b232

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/implementation.rb

@@ -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

@@ -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

@@ -48,7 +48,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.
@@ -60,7 +60,7 @@ 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

data/rbi/optify.rbi

@@ -3,45 +3,24 @@
 
 # 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
 
@@ -214,7 +193,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.

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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 1.17.4
+  version: 1.17.5
 platform: x86_64-linux
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-10-26 00:00:00.000000000 Z
+date: 2025-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -116,6 +116,7 @@ extra_rdoc_files: []
 files:
 - lib/optify.rb
 - lib/optify_ruby/3.2/optify_ruby.so
+- lib/optify_ruby/3.3/optify_ruby.so
 - lib/optify_ruby/3.4/optify_ruby.so
 - lib/optify_ruby/base_config.rb
 - lib/optify_ruby/get_options_preferences.rb