low_type 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f39ec6a2c5d0986b75bd52a8bec8033b38bd5ba094515994fa655e253b47a669
-  data.tar.gz: f7aa54e8ce075b121a8e8fed025ea5a60e13a151a6891cb6aaedbe63432f8769
+  metadata.gz: efc284f18360245938c679ce476f0588ea31560da0b75a1076d080d8d687e07c
+  data.tar.gz: 7839a82ee075a6436203aaf991be31267a180e9b35f94a4a444365506f4700d8
 SHA512:
-  metadata.gz: 021eec0aae1a09604d45f5911647000f1620a0d1482cd743ee5066ae660b7e425af246a4806b7ef50763bc1dad3587631eeeea5e428abb7cc20308dec043d9f1
-  data.tar.gz: a238797c74dbe741db04a104ebad2f081d197bd5cea38dde2ae4ee5cb4a6735de183d1722b08229691d063c14e2f8ffd2662957fb19573f840bb19bc01cc4626
+  metadata.gz: b2260394d54e93340450d2d4cfccd93e3d462f91c39fec4778205c52699590f4467639ac847cf9faa697b5e468308ee1d917c077670b30a4e9d41ca3413bc7b7
+  data.tar.gz: 521ee18436fac4d04caa4a2787e93b65367ccbe0fdd69eee7b7479316e2d7642e0a99628fedc8fc93996c28f2620a91d51407143c4ec1baa02040a0478d5a4e8

data/lib/low_type.rb

@@ -6,9 +6,30 @@ require_relative 'type_expression'
 module LowType
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
   def self.included(klass)
+
+    # Array[] class method returns a type expression only for the duration of this "included" hook.
+    array_class_method = Array.method('[]').unbind
+    Array.define_singleton_method('[]') do |expression|
+      TypeExpression.new(type: [(expression)])
+    end
+
+    # 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)
@@ -24,8 +45,12 @@ module LowType
 
     parser = Parser.new(file_path: LowType.file_path(klass:))
     private_start_line = parser.private_start_line
+
     klass.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.instance_methods, private_start_line:, klass:)
     klass.singleton_class.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.class_methods, private_start_line:, klass:)
+  ensure
+    Array.define_singleton_method('[]', array_class_method)
+    Hash.define_singleton_method('[]', hash_class_method)
   end
 
   class << self
@@ -34,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)
@@ -44,6 +69,4 @@ module LowType
 
   class ValueExpression; end
   class Boolean; end # TrueClass or FalseClass
-  class KeyValue; end # KeyValue[String => Hash]
-  class MixedTypes; end # MixedTypes[String | Integer]
 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,54 +9,56 @@ module LowType
       def redefine_methods(method_nodes:, private_start_line:, klass:)
         Module.new do
           method_nodes.each do |method_node|
-            args = method_node.parameters.slice
-
-            proxy_method = eval("-> (#{args}) {}")
-            required_args, required_kwargs = Redefiner.required_args(proxy_method)
-
-            klass.low_params[method_node.name] = Redefiner.type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
-            next if klass.low_params[method_node.name].empty?
+            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
 
-            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
+              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 required_args(proxy_method)
-        required_args = []
-        required_kwargs = {}
+      def return_type_expression(method_node:)
+        return_node = Parser.return_node(method_node:)
+        return nil if return_node.nil?
 
-        proxy_method.parameters.each do |param|
-          param_type, param_name = param
-
-          case param_type
-          when :req
-            required_args << nil
-          when :keyreq
-            required_kwargs[param_name] = nil
-          end
-        end
+        expression = eval(return_node.slice).call
 
-        [required_args, required_kwargs]
+        return expression if expression.class == TypeExpression
+        TypeExpression.new(type: expression)
       end
 
-      def type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
+      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:)
+
         typed_method = eval(
           <<~RUBY
-            -> (#{args}) {
+            -> (#{params}) {
               param_proxies = []
 
               proxy_method.parameters.each_with_index do |param, position|
@@ -78,6 +81,28 @@ module LowType
 
         # Call method with only its required args to evaluate type expressions (which are stored as default values).
         typed_method.call(*required_args, **required_kwargs)
+
+      # TODO: Write spec for this.
+      rescue ArgumentError => e
+        raise ArgumentError, "Incorrect param syntax"
+      end
+
+      def required_args(proxy_method:)
+        required_args = []
+        required_kwargs = {}
+
+        proxy_method.parameters.each do |param|
+          param_type, param_name = param
+
+          case param_type
+          when :req
+            required_args << nil
+          when :keyreq
+            required_kwargs[param_name] = nil
+          end
+        end
+
+        [required_args, required_kwargs]
       end
     end
   end

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,12 +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
 
-      raise TypeError, "Invalid type '#{arg.class}' for '#{name}'" unless @types.include?(arg.class)
+      @types.each do |type|
+        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 && 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 '#{value.class}' for '#{name}'"
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - maedi