optify-from_hash 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323fea346213dffe7e7b35edf19d78d2fa2f8ad7febff0dcb43d6982c48e6732
-  data.tar.gz: c85f2f191f33306858d91855ae8a32ad0de373d565dca8227250f9c20d59e2fe
+  metadata.gz: 23bb51f6e184777cad52c5ee7555c00a74e981b13c34fbc13133e80e4dd8b447
+  data.tar.gz: 80d4b0194cabc3202e60199ee7473f176e00795c9d2d07906cafca0cf0d9efe9
 SHA512:
-  metadata.gz: 274a651a061c8ac9840de8c75a46391e78ac599ba71135dbd9b748045567f7c957fe8e9ce87b3c43ddf969868d149aa6526327ed26f16204e3a0404413ff7a35
-  data.tar.gz: 7b8793ab933e2478b798a06557d812bca70fd9c031394076b06790672162187261cb2f0801bf6f27320ec55b434bf1c827414de65f6804085acc529d3900ca3c
+  metadata.gz: d51c60abe1041073c0090b6759824963af316248b858608ce7be0f8cf101f74d8207e2d25dbaab274868548c34dd2f4f067cf7807d732f34d0c91fae157afd59
+  data.tar.gz: db3e5143e8ca29bf947043d9cfaffd6d840bf8dc7295d546daefa7a65373b53a0606c48ea770338aaa7079e2652e94b5f24cc4baf877a05b2b2cd3cac41e6d1d

data/lib/optify_from_hash/from_hashable.rb

@@ -13,6 +13,41 @@ module Optify
     extend T::Helpers
     abstract!
 
+    @key_to_type = {} #: Hash[Symbol, T::Types::Base]
+
+    class << self
+      #: Hash[Symbol, T::Types::Base]
+      attr_reader :key_to_type
+    end
+
+    #: [T < Optify::FromHashable] (Class[T]) -> void
+    def self.inherited(subclass)
+      super
+
+      # Trace the execution after the subclass finishes loading to capture its methods.
+      TracePoint.trace(:end) do |tp|
+        if tp.self == subclass
+          subclass.instance_variable_set(:@key_to_type, _build_key_to_type(subclass))
+          tp.disable
+        end
+      end
+    end
+
+    #: [Type < Optify::FromHashable] (Class[Type]) -> Hash[Symbol, T::Types::Base]
+    private_class_method def self._build_key_to_type(subclass)
+      result = {}
+
+      subclass.public_instance_methods(false).each do |method_name|
+        method = subclass.instance_method(method_name)
+        sig = T::Utils.signature_for_method(method)
+        next if sig.nil?
+
+        result[method_name] = sig.return_type
+      end
+
+      result.freeze
+    end
+
     # Create a new immutable instance of the class from a hash.
     #
     # @param hash The hash to create the instance from.
@@ -22,34 +57,43 @@ module Optify
       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)
+        value_type = _get_value_type(key)
+        value = _convert_value(value, value_type)
         instance.instance_variable_set("@#{key}", value)
       end
 
       instance.freeze
     end
 
+    #: (untyped) -> T::Types::Base
+    private_class_method def self._get_value_type(key)
+      key = key.to_sym
+      @key_to_type.fetch(key) do
+        parent = superclass #: untyped
+        while parent != Object
+          if parent.respond_to?(:key_to_type)
+            result = parent.key_to_type[key]
+            return result if result
+          end
+          parent = parent.superclass
+        end
+        raise ArgumentError,
+              "Error converting hash to `#{name}` because no type was found for key \"#{key}\". " \
+              "Perhaps \"#{key}\" is not a valid attribute for `#{name}`. " \
+              "Types exist for #{@key_to_type.keys.sort!}"
+      end
+    end
+
     #: (Array[untyped], untyped) -> (Array[untyped] | Set[untyped])
-    def self._convert_array(value, unwrapped_type)
+    private_class_method def self._convert_array(value, unwrapped_type)
       inner_type = unwrapped_type.type
       return value.map { |v| _convert_value(v, inner_type) }.freeze if unwrapped_type.is_a?(T::Types::TypedArray)
 
-      Set.new(value.map { |v| _convert_value(v, inner_type) }).freeze
+      value.each_with_object(Set.new) { |v, set| set.add(_convert_value(v, inner_type)) }.freeze
     end
 
     #: (untyped, T::Types::Base) -> untyped
-    def self._convert_value(value, type)
+    private_class_method 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
@@ -84,7 +128,7 @@ module Optify
     end
 
     #: (Hash[untyped, untyped], T::Types::Base) -> untyped
-    def self._convert_hash(hash, type)
+    private_class_method 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.
@@ -94,15 +138,14 @@ module Optify
       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
+        type_for_values = type.values
 
-        convert_key = if type_for_keys.is_a?(T::Types::Simple) && type_for_keys.raw_type == Symbol
-                        lambda(&:to_sym)
-                      else
-                        lambda(&:itself)
-                      end
+        result = 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
+        return result.transform_keys!(&:to_sym) if type_for_keys.is_a?(T::Types::Simple) && type_for_keys.raw_type == Symbol
+
+        return result
       end
 
       raise TypeError, "Could not convert hash #{hash} to `#{type}`."
@@ -110,7 +153,7 @@ module Optify
 
     # Unwrap `T.nilable(...)` to get the inner type, or return the type as-is.
     #: (T::Types::Base) -> T::Types::Base
-    def self._unwrap_nilable(type)
+    private_class_method def self._unwrap_nilable(type)
       if type.respond_to?(:unwrap_nilable)
         type #: as untyped
           .unwrap_nilable
@@ -119,8 +162,6 @@ module Optify
       end
     end
 
-    private_class_method :_convert_array, :_convert_hash, :_convert_value, :_unwrap_nilable
-
     # Compare this object with another object for equality.
     # @param other The object to compare.
     # @return [Boolean] true if the objects are equal; otherwise, false.
@@ -177,9 +218,9 @@ module Optify
     end
 
     #: (untyped) -> untyped
-    def self._convert_value_for_to_h(value)
+    private_class_method def self._convert_value_for_to_h(value)
       case value
-      # Treat sets like arrays for JSON serialization.
+      # Treat sets like arrays for JSON serialization; otherwise, the elements are not shown.
       when Array, Set
         value.map { |v| _convert_value_for_to_h(v) }
       when Hash
@@ -194,7 +235,5 @@ module Optify
         end
       end
     end
-
-    private_class_method :_convert_value_for_to_h
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: optify-from_hash
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Justin D. Harris