optify-from_hash 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f6e409cfccf83b515e84d3cc19713e1897ed53cf4340d66de2843433c355445
-  data.tar.gz: 630ed4471403551570ba2f18d3ec687ba4790dec90332496d6f9d39100f353f5
+  metadata.gz: 23bb51f6e184777cad52c5ee7555c00a74e981b13c34fbc13133e80e4dd8b447
+  data.tar.gz: 80d4b0194cabc3202e60199ee7473f176e00795c9d2d07906cafca0cf0d9efe9
 SHA512:
-  metadata.gz: b9414cd9843a25f5b1ed1ab7f1560d5e73c0f85b3900859daa786c03f02bfd04dbc4947120bf519c8ff5f80b3712947b3b53a20c778b1e8e354c259b7c266e19
-  data.tar.gz: de4275bb6b2300dfa3e154dbc04ec49120d28ec3f20e17e537c51e1cde5a065772eaad10269abdeb8fa7a528043b376a49d2c2655d810b47373137f322a39fdc
+  metadata.gz: d51c60abe1041073c0090b6759824963af316248b858608ce7be0f8cf101f74d8207e2d25dbaab274868548c34dd2f4f067cf7807d732f34d0c91fae157afd59
+  data.tar.gz: db3e5143e8ca29bf947043d9cfaffd6d840bf8dc7295d546daefa7a65373b53a0606c48ea770338aaa7079e2652e94b5f24cc4baf877a05b2b2cd3cac41e6d1d

data/lib/optify_from_hash/from_hashable.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'set'
 require 'sorbet-runtime'
 require 'tapioca'
 
@@ -12,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.
@@ -21,26 +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])
+    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)
+
+      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
@@ -51,9 +104,7 @@ module Optify
 
       case value
       when Array
-        inner_type = unwrapped_type #: as untyped
-                     .type
-        return value.map { |v| _convert_value(v, inner_type) }.freeze
+        return _convert_array(value, unwrapped_type)
       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
@@ -77,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.
@@ -87,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}`."
@@ -103,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
@@ -112,8 +162,6 @@ module Optify
       end
     end
 
-    private_class_method :_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.
@@ -127,6 +175,23 @@ module Optify
       end
     end
 
+    # Support equality by value so that instances can be used in Sets and as Hash keys.
+    #: (untyped) -> bool
+    def eql?(other)
+      return true if other.equal?(self)
+      return false if self.class != other.class
+
+      instance_variables.all? do |name|
+        instance_variable_get(name).eql?(other.instance_variable_get(name))
+      end
+    end
+
+    # @return [Integer] a hash value based on the object's class and instance variables.
+    #: () -> Integer
+    def hash
+      [self.class, *instance_variables.sort.map { |name| instance_variable_get(name) }].hash
+    end
+
     # Convert this object to a JSON string.
     #: (?JSON::State?) -> String
     def to_json(state = nil)
@@ -153,9 +218,10 @@ 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
-      when Array
+      # 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
         value.transform_values { |v| _convert_value_for_to_h(v) }
@@ -169,7 +235,5 @@ module Optify
         end
       end
     end
-
-    private_class_method :_convert_value_for_to_h
   end
 end

data/rbi/optify_from_hash.rbi

@@ -5,6 +5,8 @@
 module Optify
   # A base class for classes that can be created from a hash.
   class FromHashable
+    extend T::Sig
+    extend T::Helpers
     abstract!
 
     # Create a new instance of the class from a hash.
@@ -31,5 +33,13 @@ module Optify
     # @return [Boolean] true if the objects are equal; otherwise, false.
     sig { params(other: T.untyped).returns(T::Boolean) }
     def ==(other); end
+
+    # Support equality by value so that instances can be used in Sets and as Hash keys.
+    sig { params(other: T.untyped).returns(T::Boolean) }
+    def eql?(other); end
+
+    # @return a hash value based on the object's class and instance variables.
+    sig { returns(Integer) }
+    def hash; end
   end
 end

data/sig/optify_from_hash.rbs

@@ -4,6 +4,8 @@ end
 
 # A base class for classes that can be created from a hash.
 class Optify::FromHashable
+  extend T::Helpers
+
   # Create a new instance of the class from a hash.
   #
   # @param hash The hash to create the instance from.
@@ -24,4 +26,10 @@ class Optify::FromHashable
   # @param other The object to compare.
   # @return [Boolean] true if the objects are equal; otherwise, false.
   def ==: (untyped other) -> bool
+
+  # Support equality by value so that instances can be used in Sets and as Hash keys.
+  def eql?: (untyped other) -> bool
+
+  # @return a hash value based on the object's class and instance variables.
+  def hash: () -> Integer
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: optify-from_hash
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Justin D. Harris
@@ -49,14 +49,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.0.dev.4
+        version: 4.0.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.0.dev.4
+        version: 4.0.3
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -83,14 +83,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.7
+        version: 0.19.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.7
+        version: 0.19.1
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement