optify-config 1.2.2-arm64-darwin → 1.3.1-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7a42c7153eb6dc141593dc210f95a73864d80ba9052b2e722470377d2260104
-  data.tar.gz: 53aef890037bf869213209018fe50eddc9c8c94f5e156ad63582540cae17c613
+  metadata.gz: 047de527f317e146c8c1a1e0a55fb064fdfbb1deba7244ff1918f7711bc37f58
+  data.tar.gz: e311875d61d5f4eba2b6e94aff241dae276846d981974d872da9d3b60bf4f1fa
 SHA512:
-  metadata.gz: 87ae714ba7d5d6145f86670e81b37197238bdaa8f70577059a4809e85966976d2adc0d348495d9e5ff3bdb987a969c80516d13f140132488254334288250ccc8
-  data.tar.gz: 254162f513c29b2fec59ad9bdf77f94528de55c7f4d50fa8a6b41e9f73c91b86d53868f8bbcddf1c4df07314de3efdbc39e48fb2e0dc8d6cf62fbe99dd7f0173
+  metadata.gz: 2c02a632370d7412f22b2167d9ed854abd39cfee9ece700fa40e425b14869dcd5abcf4e23bfc5e623d3e1586bc56c0387ad452d23c8f12b2b7bbf02957188788
+  data.tar.gz: 6c94214d6397e1003f4ebb800a72ceecae16c9e3da5d0422413d734c08853fe23102bb6c55be889a783eafb969c19ad56bd58f789703cde394df921f5956450f

data/lib/optify_ruby/base_config.rb

@@ -23,19 +23,26 @@ module Optify
     # @return The new instance.
     #: (Hash[untyped, untyped] hash) -> instance
     def self.from_hash(hash)
-      result = new
+      instance = new
 
       hash.each do |key, value|
         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)
+        instance.instance_variable_set("@#{key}", value)
       end
 
-      T.unsafe(result).freeze if T.unsafe(result).respond_to?(:freeze)
+      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[...])`
@@ -43,39 +50,48 @@ module Optify
         inner_type = type.type
         return value.map { |v| _convert_value(v, inner_type) }.freeze
       when Hash
-        # Handle `T.nilable(T::Hash[...])`
-        type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
+        # 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) # rubocop:disable Metrics/PerceivedComplexity
+    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.instance_of?(T::Types::TypedHash)
+      elsif type.is_a?(T::Types::TypedHash)
         # The hash should be a hash, but the values might be objects to convert.
-        type_for_values = type.values
+        type_for_keys = type.keys
 
-        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
+        convert_key = if type_for_keys.is_a?(T::Types::Simple) && type_for_keys.raw_type == Symbol
+                        lambda(&:to_sym)
+                      else
+                        lambda(&:itself)
+                      end
 
-        # The values are not recognized objects.
-        return hash.transform_values { |v| _convert_value(v, type_for_values) }
+        type_for_values = type.values
+        return hash.map { |k, v| [convert_key.call(k), _convert_value(v, type_for_values)] }.to_h
       end
 
-      # Fallback to doing nothing.
-      # This can happen if there are is no type information for a key in the hash.
-      hash
+      raise TypeError, "Could not convert hash #{hash} to `#{type}`."
     end
 
     private_class_method :_convert_hash, :_convert_value

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.1
 platform: arm64-darwin
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime