low_type 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b01f96320aa0543e44d8b4b40430903af4966174fb9ae1533ddf7240c1919ec1
-  data.tar.gz: 87094ba39f9755fce4befa350b7ce33d7bd807a9774f1366340a0c9003788933
+  metadata.gz: 4ec90c752620d94c2f38e287ce6927684bb77b17caf65c9551765a37b031d2ab
+  data.tar.gz: 6d6106390f7286f5d1812c4de79fe1a72f021db0d0b0f62c1dce5bf5a4cfc02c
 SHA512:
-  metadata.gz: 2b4ff1cca9f7763084b3283a13b34955863a81074a6161703c3993aa6d0916180804f8b6058ee35779be159eec7000d9c2f676c656254a67039cb3548073f10d
-  data.tar.gz: 39aad0e4a488963333b31c8ec21fc6586e78e5d0ebf76a6546997183ada9ce6baacbd0107ecd0ed71ce5e5c9fa14d8597936b5db874edc48fdc6c082651ea72e
+  metadata.gz: 791da36eca530ac38f459cbdb25253089be16e1d2c544f478c3c0fc80a7249f5c942706ec93cc4ef5340779d746f5c3be559d435f8bbdb25f2d092c6d9128681
+  data.tar.gz: a92a680924fd3219cc5b88e6097aaadb12fb0f0f26d175591bbcd27c5d045286dd5c392d3218f5ed1600b639a79be5be643d6c0784212a7c72e6dde945946625

data/lib/low_type.rb

@@ -16,12 +16,20 @@ module LowType
     # Hash[] class method returns a type expression only for the duration of this "included" hook.
     hash_class_method = Hash.method('[]').unbind
     Hash.define_singleton_method('[]') do |expression|
+      # Support Pry which uses Hash[].
+      unless LowType.type?(expression)
+        Hash.define_singleton_method('[]', hash_class_method)
+        result = Hash[expression]
+        Hash.method('[]').unbind
+        return result
+      end
+
       TypeExpression.new(type: expression)
     end
 
     class << klass
-      def low_params
-        @low_params ||= {}
+      def low_methods
+        @low_methods ||= {}
       end
 
       def type(expression)
@@ -51,7 +59,7 @@ module LowType
     end
 
     def type?(expression)
-      expression.respond_to?(:new) || expression == Integer
+      expression.respond_to?(:new) || expression == Integer || (expression.is_a?(Hash) && expression.keys.first.respond_to?(:new) && expression.values.first.respond_to?(:new))
     end
 
     def value?(expression)

data/lib/method_proxy.rb

@@ -0,0 +1,11 @@
+module LowType
+  class MethodProxy
+    attr_reader :name, :params, :return_expression
+
+    def initialize(name:, params: [], return_expression: nil)
+      @name = name
+      @params = params
+      @return_expression = return_expression
+    end
+  end
+end

data/lib/parser.rb

@@ -18,6 +18,15 @@ module LowType
       @class_methods = method_visitor.class_methods
       @private_start_line = method_visitor.private_start_line
     end
+
+    def self.return_node(method_node:)
+      # Only a lambda defined immediately after a method's parameters is considered a return type expression.
+      node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }.body.first
+
+      return node if node.is_a?(Prism::LambdaNode)
+
+      nil
+    end
   end
 
   class MethodVisitor < Prism::Visitor

data/lib/redefiner.rb

@@ -1,3 +1,4 @@
+require_relative 'method_proxy'
 require_relative 'param_proxy'
 require_relative 'parser'
 require_relative 'type_expression'
@@ -8,31 +9,52 @@ module LowType
       def redefine_methods(method_nodes:, private_start_line:, klass:)
         Module.new do
           method_nodes.each do |method_node|
-            klass.low_params[method_node.name] = Redefiner.param_proxy_with_type_expressions(method_node)
-            next if klass.low_params[method_node.name].empty?
-
-            define_method(method_node.name) do |*args, **kwargs|
-              klass.low_params[method_node.name].each do |param_proxy|
-                arg = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
-                arg = param_proxy.type_expression.default_value if arg.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
-                param_proxy.type_expression.validate!(arg:, name: param_proxy.name)
-                param_proxy.position ? args[param_proxy.position] = arg : kwargs[param_proxy.name] = arg
+            name = method_node.name
+            params = Redefiner.params_with_type_expressions(method_node:)
+            return_expression = Redefiner.return_type_expression(method_node:)
+
+            klass.low_methods[name] = MethodProxy.new(name:, params:, return_expression:)
+
+            define_method(name) do |*args, **kwargs|
+              klass.low_methods[name].params.each do |param_proxy|
+                value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
+                value = param_proxy.type_expression.default_value if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
+                param_proxy.type_expression.validate!(value:, name: param_proxy.name)
+                param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
+              end
+
+              if return_expression
+                return_value = super(*args, **kwargs)
+                return_expression.validate!(value: return_value, name:)
+                return return_value
               end
 
               super(*args, **kwargs)
             end
 
             if private_start_line && method_node.start_line > private_start_line
-              private method_node.name
+              private name
             end
           end
         end
       end
 
-      def param_proxy_with_type_expressions(method_node)
+      def return_type_expression(method_node:)
+        return_node = Parser.return_node(method_node:)
+        return nil if return_node.nil?
+
+        expression = eval(return_node.slice).call
+
+        return expression if expression.class == TypeExpression
+        TypeExpression.new(type: expression)
+      end
+
+      def params_with_type_expressions(method_node:)
+        return [] if method_node.parameters.nil?
+
         params = method_node.parameters.slice
         proxy_method = eval("-> (#{params}) {}")
-        required_args, required_kwargs = Redefiner.required_args(proxy_method)
+        required_args, required_kwargs = Redefiner.required_args(proxy_method:)
 
         typed_method = eval(
           <<~RUBY
@@ -65,7 +87,7 @@ module LowType
         raise ArgumentError, "Incorrect param syntax"
       end
 
-      def required_args(proxy_method)
+      def required_args(proxy_method:)
         required_args = []
         required_kwargs = {}
 

data/lib/type_expression.rb

@@ -1,10 +1,10 @@
 module LowType
   class TypeExpression
-    attr_reader :type, :default_value
+    attr_reader :types, :default_value
 
-    def initialize(type:)
+    def initialize(type:, default_value: :LOW_TYPE_UNDEFINED)
       @types = [type]
-      @default_value = :LOW_TYPE_UNDEFINED
+      @default_value = default_value
     end
 
     def |(expression)
@@ -24,21 +24,22 @@ module LowType
       @default_value == :LOW_TYPE_UNDEFINED
     end
 
-    def validate!(arg:, name:)
-      if arg.nil? && required?
-        raise ArgumentError, "Missing required argument of type '#{@types.join(', ')}' for '#{name}'"
+    def validate!(value:, name:)
+      if value.nil?
+        return true if @default_value.nil?
+        raise ArgumentError, "Missing required argument of type '#{@types.join(', ')}' for '#{name}'" if required?
       end
 
       @types.each do |type|
-        return true if LowType.type?(type) && type == arg.class 
+        return true if LowType.type?(type) && type == value.class 
         # TODO: Shallow validation of enumerables could be made deeper with user config.
-        return true if type.class == Array && arg.class == Array && type.first == arg.first.class
-        if type.class == Hash && arg.class == Hash && type.keys[0] == arg.keys[0].class && type.values[0] == arg.values[0].class
+        return true if type.class == Array && value.class == Array && type.first == value.first.class
+        if type.class == Hash && value.class == Hash && type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
           return true
         end
       end
 
-      raise TypeError, "Invalid type '#{arg.class}' for '#{name}'"
+      raise TypeError, "Invalid type '#{value.class}' for '#{name}'"
     end
   end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LowType
-  VERSION = '0.3.0'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - maedi
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/low_type.rb
+- lib/method_proxy.rb
 - lib/param_proxy.rb
 - lib/parser.rb
 - lib/redefiner.rb