optify-config 0.4.0-aarch64-linux → 0.4.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80aa089ed4b89d881246babfec79def4e156e0cc3574c49461a1edc0ca4c5d1d
-  data.tar.gz: 53862c20e3009adb89e4c3c02856590ed5ec76c1d76977f1f21bb7714e38ae6a
+  metadata.gz: 108d884c56a8953b283d19cc6c467bfba15bd9c4bc3536735d81e7e72e091b2f
+  data.tar.gz: 57a735915f6d0355c2cbf853c41abad01739c4e4f7fb252326dda14a196d14a3
 SHA512:
-  metadata.gz: ba979c843fc765e5cfa152c0c3715b1f768c56176898453f99006a9f46a545d70583fbfabb98c94b24f8f7733f181646adc4837aa284536084b6d80d2d392276
-  data.tar.gz: 2b09394038fb04536d916ae311c41d626697faed9af92477fd59a9d32384713beff71fce53701de4585c8621d34698b84feb9a43c29dfd5f8d31d017b259ac7f
+  metadata.gz: 4816ac528e2ff724634f81f7b779e7cf1ebff93deff61189711ac2f337c22010848aac8b554b60bf56f5884f8153360f1009a1d8af9bd8aa0e45ff2c8cb7e05c
+  data.tar.gz: fa0b263fa394d6ac2c9d3e542f7b98c11a619529f562f79674b510b64ec99e2aaf65afbc28fdc2cef4cd0e8ce1f263f02dec47b964da0846726ca8081312ddd2

data/lib/optify_ruby/base_config.rb

@@ -18,6 +18,7 @@ module Optify
 
     # 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 [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) }
@@ -25,24 +26,66 @@ module Optify
       result = new
 
       hash.each do |key, value|
-        # TODO: Might need some error handling here, but it should be fine if type signatures are used.
-        # TODO Handle nilable types.
-        case value
-        when Array
-          sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
-          inner_type = sig_return_type.type.raw_type
-          value = value.map { |v| inner_type.from_hash(v) } if inner_type.respond_to?(:from_hash)
-        when Hash
-          sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
-          if sig_return_type.respond_to?(:raw_type)
-            type_for_key = sig_return_type.raw_type
-            value = type_for_key.from_hash(value) if type_for_key.respond_to?(:from_hash)
+        sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
+        value = _convert_value(value, sig_return_type)
+        result.instance_variable_set("@#{key}", value)
+      end
+      result
+    end
+
+    sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
+    def self._convert_value(value, type)
+      case value
+      when Array
+        type = if type.type.respond_to?(:unwrap_nilable)
+                 # Handle nilable array.
+                 type.type.unwrap_nilable
+               else
+                 # Handle array of 1 type.
+                 type.type
+               end
+        return value.map { |v| _convert_value(v, type) }
+      when Hash
+        # Handle nilable hash.
+        type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
+        return _convert_hash(value, type)
+      end
+
+      value
+    end
+
+    sig do
+      params(
+        hash: T::Hash[T.untyped, T.untyped],
+        type: T.untyped
+      ).returns(T.untyped)
+    end
+    def self._convert_hash(hash, type) # rubocop:disable Metrics/PerceivedComplexity
+      if type.respond_to?(:raw_type)
+        # There is an object for the hash.
+        type_for_hash = type.raw_type
+        return type_for_hash.from_hash(hash) if type_for_hash.respond_to?(:from_hash)
+      elsif type.instance_of?(T::Types::TypedHash)
+        # The hash should be a hash, but the values might be objects to convert.
+        type_for_values = type.values
+
+        if type_for_values.respond_to?(:raw_type)
+          raw_type_for_values = type_for_values.raw_type
+          if raw_type_for_values.respond_to?(:from_hash)
+            # Use proper types.
+            return hash.transform_values { |v| raw_type_for_values.from_hash(v) }
           end
         end
 
-        result.instance_variable_set("@#{key}", value)
+        # The values are not recognized objects.
+        return hash.transform_values { |v| _convert_value(v, type_for_values) }
       end
-      result
+
+      # Fallback to doing nothing.
+      # This can happen if there are is no type information for a key in the hash.
+      hash
     end
+
+    private_class_method :_convert_hash, :_convert_value
   end
 end

data/lib/optify_ruby/implementation.rb

@@ -50,15 +50,16 @@ module Optify
     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
 
-      options_json = get_options_json(key, feature_names)
-      h = JSON.parse(options_json, object_class: Hash)
       unless config_class.respond_to?(:from_hash)
         raise NotImplementedError,
               "The provided config class must implement `from_hash` as a class method
-            in order to be converted."
+              in order to be converted.
+              Recommended: extend `Optify::BaseConfig`."
       end
 
-      T.unsafe(config_class).from_hash(h)
+      options_json = get_options_json(key, feature_names)
+      hash = JSON.parse(options_json)
+      T.unsafe(config_class).from_hash(hash)
     end
 
     private
@@ -79,7 +80,7 @@ module Optify
       # 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: Handle aliases. Right now, they are only visible 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]))
       cache_key = [key, feature_names, config_class]
@@ -87,6 +88,7 @@ module Optify
       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)
 
       @cache[cache_key] = result
     end

data/rbi/optify.rbi

@@ -14,6 +14,7 @@ module Optify
 
     # 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 [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) }
@@ -33,6 +34,7 @@ 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.
     # @return [ConfigType] The options.
     sig do
       type_parameters(:Config)
@@ -41,10 +43,10 @@ module Optify
           feature_names: T::Array[String],
           config_class: T::Class[T.type_parameter(:Config)],
           cache_options: T.nilable(CacheOptions)
-          )
-          .returns(T.type_parameter(:Config))
-      end
-      def get_options(key, feature_names, config_class, cache_options = nil); end
+        )
+        .returns(T.type_parameter(:Config))
+    end
+    def get_options(key, feature_names, config_class, cache_options = nil); end
 
     # Fetches options in JSON format based on the provided key and feature names.
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: aarch64-linux
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-08 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -89,9 +89,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/optify.rb
+- lib/optify_ruby/3.1/optify_ruby.so
+- lib/optify_ruby/3.2/optify_ruby.so
+- lib/optify_ruby/3.4/optify_ruby.so
 - lib/optify_ruby/base_config.rb
 - lib/optify_ruby/implementation.rb
-- lib/optify_ruby/optify_ruby.so
 - rbi/optify.rbi
 homepage: https://github.com/juharris/optify
 licenses:
@@ -107,7 +109,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.4'
+      version: '3.1'
   - - "<"
     - !ruby/object:Gem::Version
       version: 3.5.dev