low_type 1.1.8 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295c067ff64ba1d3ddb26243c1676a7bbe7d3a41fb65c4c51e868462a44e4f1b
-  data.tar.gz: 2cff7d3f4f7f1dd8f6df9ab48e34737f562929cb802f798cf497a377034eee16
+  metadata.gz: 54e1e267e4ef98dc2364738a169dee20cb6364d9cb597c8f7c46084309b2296f
+  data.tar.gz: 1c1b44d5b7ba03b955d039bf62a7898897d2d04230dc89ff58df055de719d37d
 SHA512:
-  metadata.gz: 1f697cb2610e1acb2bc89a41ec35cd1f78a381fea7f3fed90c1984166d4ae514cffb8adf4ba6ef4916cd32897b85ba22e4ee84d26e4b187cb21657d7dedc6553
-  data.tar.gz: 54725a86fa96ac6bbf286d6c28d8a1af06090b64f1d75e5fe4ee21e398078d592aae71dd39b6c9d6170584f9ca4bd86175c827bf6d9ea1aaa0240540035080f7
+  metadata.gz: 39b512c4ff8c250659bdce0bb1be51c5f3e46e7a8ac30fa607deabdf9c933b7459bb78542211aafebf483dff3ecd8600ebb589dd4b91fb0d410c4dd9206e74fb
+  data.tar.gz: 0d4840867f0454b51b82f64807b691c4a4e4ac1380f5de113862ca8964f12fd18a62e0accaa51fad1105b94be403659ed5a80f486b4fc3ad4a1cddaf72abbf59

data/lib/adapters/adapter_loader.rb

@@ -6,15 +6,12 @@ module Low
   module Adapter
     class Loader
       class << self
-        def load(klass:, parser:, file_path:)
-          adaptor = nil
-
+        def load(klass:, class_proxy:)
           ancestors = klass.ancestors.map(&:to_s)
-          adaptor = Sinatra.new(klass:, parser:, file_path:) if ancestors.include?('Sinatra::Base')
 
-          return if adaptor.nil?
+          return unless ancestors.include?('Sinatra::Base')
 
-          adaptor
+          klass.prepend SinatraAdapter.new.module(file_path: class_proxy.file_path)
         end
       end
     end

data/lib/adapters/sinatra_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'prism'
+require 'lowkey'
 
-require_relative '../factories/proxy_factory'
 require_relative '../interfaces/adapter_interface'
 require_relative '../proxies/return_proxy'
 require_relative '../types/error_types'
@@ -10,70 +10,38 @@ require_relative '../types/error_types'
 module Low
   module Adapter
     # We don't use https://sinatrarb.com/extensions.html because we need to type check all Ruby methods (not just Sinatra) at a lower level.
-    class Sinatra < AdapterInterface
-      def initialize(klass:, parser:, file_path:)
-        @klass = klass
-        @parser = parser
-        @file_path = file_path
-      end
-
-      def process # rubocop:disable Metrics/AbcSize
-        method_calls = @parser.method_calls(method_names: %i[get post patch put delete options query])
-
-        # Type check return values.
-        method_calls.each do |method_call|
-          arguments_node = method_call.compact_child_nodes.first
-          next unless arguments_node.is_a?(Prism::ArgumentsNode)
-
-          pattern = arguments_node.arguments.first.content
-
-          file = ProxyFactory.file_proxy(node: method_call, path: @file_path, scope: "#{@klass}##{method_call.name}")
-          next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
-
-          route = "#{method_call.name.upcase} #{pattern}"
-          params = [ParamProxy.new(expression: nil, name: :route, type: :req, position: 0, file:)]
-          @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
-        end
-      end
-
-      def return_proxy(method_node:, pattern:, file:)
-        return_type = FileParser.return_type(method_node:)
-        return nil if return_type.nil?
-
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        expression = eval(return_type.slice).call # rubocop:disable Security/Eval
-        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
-
-        ReturnProxy.new(type_expression: expression, name: "#{method_node.name.upcase} #{pattern}", file:)
-      end
-    end
-
-    module Methods
-      # Unfortunately overriding invoke() is the best way to validate types for now. Though direct it's also very compute efficient.
-      # I originally tried an after filter and it mostly worked but it only had access to Response which isn't the raw return value.
-      # I suggest that Sinatra provide a hook that allows us to access the raw return value of a route before it becomes a Response.
-      def invoke(&block)
-        res = catch(:halt, &block)
-
-        low_validate!(value: res) if res
-
-        res = [res] if res.is_a?(Integer) || res.is_a?(String)
-        if res.is_a?(::Array) && res.first.is_a?(Integer)
-          res = res.dup
-          status(res.shift)
-          body(res.pop)
-          headers(*res)
-        elsif res.respond_to? :each
-          body res
-        end
-
-        nil # avoid double setting the same response tuple twice
-      end
-
-      def low_validate!(value:)
-        route = "#{request.request_method} #{request.path}"
-        if (method_proxy = self.class.low_methods[route]) && (proxy = method_proxy.return_proxy)
-          proxy.type_expression.validate!(value:, proxy:)
+    class SinatraAdapter < AdapterInterface
+      def module(file_path:) # rubocop:disable Metrics/AbcSize
+        Module.new do
+          @@file_path = file_path # rubocop:disable Style/ClassVars
+
+          # Unfortunately overriding invoke() is the best way to validate types for now. Though direct it's also very compute efficient.
+          # I originally tried an after filter and it mostly worked but it only had access to Response which isn't the raw return value.
+          # I suggest that Sinatra provide a hook that allows us to access the raw return value of a route before it becomes a Response.
+          def invoke(&block)
+            res = catch(:halt, &block)
+
+            lowtype_validate!(value: res) if res
+
+            res = [res] if res.is_a?(Integer) || res.is_a?(String)
+            if res.is_a?(::Array) && res.first.is_a?(Integer)
+              res = res.dup
+              status(res.shift)
+              body(res.pop)
+              headers(*res)
+            elsif res.respond_to? :each
+              body res
+            end
+
+            nil # avoid double setting the same response tuple twice
+          end
+
+          def lowtype_validate!(value:)
+            route = "#{request.request_method} #{request.path}"
+            if (method_proxy = Lowkey[@@file_path][self.class.name][route]) && (proxy = method_proxy.return_proxy)
+              proxy.expression.validate!(value:, proxy:)
+            end
+          end
         end
       end
     end

data/lib/definitions/evaluator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'expressions'
+require 'lowkey'
+
+require_relative '../expressions/expression_helpers'
+require_relative '../expressions/type_expression'
+require_relative '../syntax/syntax'
+require_relative '../types/complex_types'
+require_relative '../types/status'
+
+module Low
+  # Evaluate code stored in strings into constants and values.
+  # ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+  # │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+  # └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+  #      │              │                 │                 │               │
+  #      │ Parses AST   │                 │                 │               │
+  #      ├─────────────►│                 │                 │               │
+  #      │              │                 │                 │               │
+  #      │              │ Stores          │                 │               │
+  #      │              ├────────────────►│                 │               │
+  #      │              │                 │                 │               │
+  #      │              │                 │ Evaluates <-- YOU ARE HERE.     |
+  #      │              │                 │◄────────────────┤               │
+  #      │              │                 │                 │               │
+  #      │              │                 │                 │ Redefines     │
+  #      │              │                 │                 ├──────────────►│
+  #      │              │                 │                 │               │
+  #      │              │                 │ Validates       │               │
+  #      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+  #      │              │                 │                 │               │
+  class Evaluator
+    include ExpressionHelpers
+    include Types
+    using LowType::Syntax
+
+    def instance_evaluate(proxy:)
+      # Not a security risk because the code comes from a trusted source; the file that included lowtype.
+      eval(proxy.value, binding, proxy.file_path, proxy.start_line) # rubocop:disable Security/Eval
+    end
+
+    class << self
+      def evaluate(method_proxies:)
+        require_relative '../syntax/union_types' if LowType.config.union_type_expressions
+
+        method_proxies.each_value do |method_proxy|
+          evaluate_param_proxy_expressions(method_proxy:)
+          evaluate_return_proxy_expression(return_proxy: method_proxy.return_proxy) if method_proxy.return_proxy
+        end
+      end
+
+      def evaluate_param_proxy_expressions(method_proxy:)
+        begin # rubocop:disable Style/RedundantBegin
+          method_proxy.tagged_params(:value).each do |param_proxy|
+            # TODO: Evaluate in the binding of the class that included LowType if not a type managed by LowType.
+            expression = new.instance_evaluate(proxy: param_proxy)
+            param_proxy.expression = cast_type_expression(expression:, method_proxy:)
+          end
+        rescue NameError
+          mp = method_proxy
+          raise NameError, "Unknown type '#{mp.value}' for #{mp.scope} at #{mp.file_path}:#{mp.start_line}"
+        end
+      end
+
+      def evaluate_return_proxy_expression(return_proxy:)
+        begin
+          expression = new.instance_evaluate(proxy: return_proxy)
+        rescue NameError
+          rp = return_proxy
+          raise NameError, "Unknown return type '#{rp.value}' for #{rp.scope} at #{rp.file_path}:#{rp.start_line}"
+        end
+
+        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
+
+        return_proxy.expression = expression
+      end
+
+      private
+
+      def cast_type_expression(expression:, method_proxy:)
+        if expression.is_a?(::Expressions::Expression)
+          return expression
+        elsif expression.instance_of?(Class) && expression.name == 'Low::Dependency'
+          return expression.new(provider_key: method_proxy.name)
+        elsif TypeQuery.type?(expression)
+          return TypeExpression.new(type: expression)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/definitions/redefiner.rb

@@ -1,18 +1,33 @@
 # frozen_string_literal: true
 
 require_relative '../expressions/value_expression'
-require_relative '../factories/proxy_factory'
-require_relative '../proxies/method_proxy'
-require_relative '../queries/type_query'
-require_relative 'repository'
+require_relative '../definitions/evaluator'
 
 module Low
   # Redefine methods to have their arguments and return values type checked.
+  # ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+  # │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+  # └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+  #      │              │                 │                 │               │
+  #      │ Parses AST   │                 │                 │               │
+  #      ├─────────────►│                 │                 │               │
+  #      │              │                 │                 │               │
+  #      │              │ Stores          │                 │               │
+  #      │              ├────────────────►│                 │               │
+  #      │              │                 │                 │               │
+  #      │              │                 │ Evaluates       │               │
+  #      │              │                 │◄────────────────┤               │
+  #      │              │                 │                 │               │
+  #      │              │                 │                 │ Redefines <-- YOU ARE HERE.
+  #      │              │                 │                 ├──────────────►│
+  #      │              │                 │                 │               │
+  #      │              │                 │ Validates       │               │
+  #      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+  #      │              │                 │                 │               │
   class Redefiner
     class << self
-      def redefine(method_nodes:, class_proxy:, file_path:)
-        method_proxies = build_methods(method_nodes:, klass: class_proxy.klass, file_path:)
-
+      # TODO: Pass in "klass" and use it to class_eval/eval methods in the binding of the class that included LowType.
+      def redefine(method_proxies:, class_proxy:)
         if LowType.config.type_checking
           typed_methods(method_proxies:, class_proxy:)
         else
@@ -20,16 +35,12 @@ module Low
         end
       end
 
-      def redefinable?(method_proxy:, class_proxy:)
-        method_has_types?(method_proxy:, class_proxy:) && method_within_class_bounds?(method_proxy:, class_proxy:)
-      end
-
       def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
-        method_proxy.params.each do |param_proxy|
+        method_proxy.params_with_expressions.each do |param_proxy|
           value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
 
           next unless value.nil?
-          raise param_proxy.error_type, param_proxy.error_message(value:) if param_proxy.required?
+          raise param_proxy.error_type, param_proxy.error_message(value:) if param_proxy.expression.required?
 
           value = param_proxy.expression.default_value # Default value can still be `nil`.
           value = value.value if value.is_a?(ValueExpression)
@@ -41,94 +52,51 @@ module Low
 
       private
 
-      def build_methods(method_nodes:, klass:, file_path:)
-        method_nodes.each do |name, method_node|
-          begin # rubocop:disable Style/RedundantBegin
-            file = ProxyFactory.file_proxy(path: file_path, node: method_node, scope: "#{klass}##{name}")
-
-            param_proxies = ProxyFactory.param_proxies(method_node:, file:)
-            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
-            method_proxy = MethodProxy.new(name:, params: param_proxies, return_proxy:, file:)
-
-            Repository.save(method: method_proxy, klass:)
-          # When we can't parse the method's params or return type then skip it.
-          rescue SyntaxError
-            next
-          end
-        end
-
-        Repository.all(klass:)
-      end
-
       def typed_methods(method_proxies:, class_proxy:) # rubocop:disable Metrics
         Module.new do
-          method_proxies.each do |name, method_proxy|
-            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
-
-            # You are now in the binding of the includer class (`name` is also available here).
-            define_method(name) do |*args, **kwargs|
-              # Inlined version of Repository.load() for performance increase.
-              method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
-
-              method_proxy.params.each do |param_proxy|
-                value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
-                value = param_proxy.expression.default_value if value.nil? && !param_proxy.required?
+          method_proxies.values.filter(&:expressions?).each do |method_proxy|
+            define_method(method_proxy.name) do |*args, **kwargs|
+              method_proxy.params_with_expressions.each do |param_proxy|
+                positional = %i[pos_req pos_opt].include?(param_proxy.type)
 
+                value = positional ? args[param_proxy.position] : kwargs[param_proxy.name]
+                value = param_proxy.expression.default_value if value.nil? && !param_proxy.expression.required?
                 param_proxy.expression.validate!(value:, proxy: param_proxy)
                 value = value.value if value.is_a?(ValueExpression)
-                param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
+
+                positional ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
               end
 
               if (return_proxy = method_proxy.return_proxy)
                 return_value = super(*args, **kwargs)
-                return_proxy.type_expression.validate!(value: return_value, proxy: return_proxy)
+                return_proxy.expression.validate!(value: return_value, proxy: return_proxy)
                 return return_value
               end
 
               super(*args, **kwargs)
             end
 
-            private name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
+            private method_proxy.name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
           end
         end
       end
 
       def untyped_methods(method_proxies:, class_proxy:)
         Module.new do
-          method_proxies.each do |name, method_proxy|
-            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
-
-            # You are now in the binding of the includer class (`name` is also available here).
-            define_method(name) do |*args, **kwargs|
+          method_proxies.values.filter(&:expressions?).each do |method_proxy|
+            # You are now in the binding of the includer class.
+            define_method(method_proxy.name) do |*args, **kwargs|
               # NOTE: Type checking is currently disabled. See 'config.type_checking'.
-              method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
+              method_proxy = Lowkey[class_proxy.file_path][class_proxy.namespace][__method__]
+
               args, kwargs = Low::Redefiner.untyped_args(args:, kwargs:, method_proxy:)
               super(*args, **kwargs)
             end
 
-            private name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
+            private method_proxy.name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
           end
         end
       end
-
-      def method_has_types?(method_proxy:, class_proxy:)
-        if method_proxy.params == [] && method_proxy.return_proxy.nil?
-          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
-          return false
-        end
-
-        true
-      end
-
-      def method_within_class_bounds?(method_proxy:, class_proxy:)
-        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.end_line <= class_proxy.end_line
-        if method_proxy.lines? && class_proxy.lines? && !within_bounds
-          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
-          return false
-        end
-
-        true
-      end
     end
   end
 end

data/lib/definitions/type_accessors.rb

@@ -9,31 +9,35 @@ module Low
     def type_reader(named_expressions)
       named_expressions.each do |name, exp|
         last_caller = caller_locations(1, 1).first
-        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
-        expression = expression(exp)
-        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression: expression, name:, file:))
+        file_path = last_caller.path
+        start_line = last_caller.lineno
+        scope = "#{self}##{name}"
+
+        expression = cast_type_expression(exp)
+        proxy = ::Lowkey::ReturnProxy.new(file_path:, start_line:, scope:, name:, expression:)
 
         define_method(name) do
-          method_proxy = self.class.low_methods[name]
           value = instance_variable_get("@#{name}")
-          expression.validate!(value:, proxy: method_proxy.return_proxy)
+          expression.validate!(value:, proxy:)
           value
         end
       end
     end
 
-    def type_writer(named_expressions) # rubocop:disable Metrics/AbcSize
-      named_expressions.each do |name, exp|
+    def type_writer(named_expressions)
+      named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
-        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
-        params = [ParamProxy.new(expression: expression(exp), name:, type: :hashreq, file:)]
-        @low_methods["#{name}="] = MethodProxy.new(name:, params:)
+        file_path = last_caller.path
+        start_line = last_caller.lineno
+        scope = "#{self}##{name}"
+
+        expression = cast_type_expression(expression)
+        proxy = ::Lowkey::ParamProxy.new(file_path:, start_line:, scope:, name:, type: :key_req, expression:)
 
         define_method("#{name}=") do |value|
-          method_proxy = self.class.low_methods["#{name}="]
-          method_proxy.params.first.expression.validate!(value:, proxy: method_proxy.params.first)
+          expression.validate!(value:, proxy:)
           instance_variable_set("@#{name}", value)
         end
       end
@@ -48,10 +52,10 @@ module Low
 
     private
 
-    def expression(expression)
+    def cast_type_expression(expression)
       if expression.is_a?(::Expressions::Expression)
         expression
-      elsif ::Low::TypeQuery.type?(expression)
+      elsif TypeQuery.type?(expression)
         TypeExpression.new(type: expression)
       end
     end

data/lib/expressions/expression_helpers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'type_expression'
+require_relative 'value_expression'
+require_relative '../proxies/local_proxy'
+
+module Low
+  module ExpressionHelpers
+    def type(type_expression)
+      value = type_expression.default_value
+
+      last_caller = caller_locations(1, 1).first
+      file_path = last_caller.path
+      start_line = last_caller.lineno
+      proxy = LocalProxy.new(type_expression:, name: self, file_path:, start_line:, scope: 'local type')
+
+      type_expression.validate!(value:, proxy:)
+
+      return value.value if value.is_a?(ValueExpression)
+
+      value
+    rescue NoMethodError
+      raise ConfigError, "Invalid type expression. Did you add 'using LowType::Syntax'?"
+    end
+    alias low_type type
+
+    def value(type)
+      TypeExpression.new(default_value: ValueExpression.new(value: type))
+    end
+    alias low_value value
+  end
+end

data/lib/expressions/type_expression.rb

@@ -22,7 +22,7 @@ module Low
       @types << type unless type.nil?
       @default_value = default_value
       # TODO: Override per type expression with a config expression.
-      @deep_type_check = LowType.config.deep_type_check
+      @deep_type_check = nil
     end
 
     def required?
@@ -76,7 +76,7 @@ module Low
 
     # Override Expressions as LowType supports complex types which are implemented as values.
     def value?(expression)
-      ::Low::TypeQuery.value?(expression) || expression.nil?
+      TypeQuery.value?(expression) || expression.nil?
     end
 
     def valid_subtype(subtype:)
@@ -141,7 +141,9 @@ module Low
     end
 
     def deep_type_check?
-      @deep_type_check || LowType.config.deep_type_check || false
+      return @deep_type_check unless @deep_type_check.nil?
+
+      LowType.config.deep_type_check
     end
   end
 end

data/lib/expressions/value_expression.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-# A value expression converts a type to a value in the eyes of LowType.
+# A value expression presents a type as a value:
+# 1. It is an instance
+# 2. It has a class method
 class ValueExpression
   attr_reader :value
 

data/lib/interfaces/adapter_interface.rb

@@ -2,8 +2,8 @@
 
 module Low
   class AdapterInterface
-    def process
-      raise NotImplementedError
+    def module
+      nil
     end
   end
 end

data/lib/interfaces/{error_interface.rb → error_handling.rb}

@@ -1,15 +1,8 @@
 # frozen_string_literal: true
 
 module Low
-  class ErrorInterface
-    attr_reader :file
-
-    def initialize
-      @file = nil
-      @output_mode = LowType.config.output_mode
-      @output_size = LowType.config.output_size
-    end
-
+  # Used by proxies to output errors.
+  module ErrorHandling
     def error_type
       raise NotImplementedError
     end
@@ -19,12 +12,12 @@ module Low
     end
 
     def output(value:)
-      case @output_mode
+      case LowType.config.output_mode
       when :type
         # TODO: Show full type structure in error output instead of just the type of the supertype.
         value.class
       when :value
-        value.inspect[0...@output_size]
+        value.inspect[0...LowType.config.output_size]
       else
         'REDACTED'
       end
@@ -34,8 +27,8 @@ module Low
       # Remove LowType defined method file paths from the backtrace.
       filtered_backtrace = backtrace.reject { |line| hidden_paths.find { |file_path| line.include?(file_path) } }
 
-      # Add the proxied file to the backtrace.
-      proxy_file_backtrace = "#{file.path}:#{file.start_line}:in '#{file.scope}'"
+      # Add the proxied entity to the backtrace.
+      proxy_file_backtrace = "#{file_path}:#{start_line}:in '#{scope}'"
       from_prefix = filtered_backtrace.first.match(/\s+from /)
       proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
 

data/lib/low_type.rb

@@ -1,40 +1,53 @@
 # frozen_string_literal: true
 
+require 'lowkey'
+
 require_relative 'adapters/adapter_loader'
 require_relative 'definitions/redefiner'
 require_relative 'definitions/type_accessors'
-require_relative 'expressions/expressions'
-require_relative 'queries/file_parser'
+require_relative 'expressions/expression_helpers'
 require_relative 'queries/file_query'
 require_relative 'syntax/syntax'
 require_relative 'types/complex_types'
 
+# Architecture:
+# ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+# │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+# └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+#      │              │                 │                 │               │
+#      │ Parses AST   │                 │                 │               │
+#      ├─────────────►│                 │                 │               │
+#      │              │                 │                 │               │
+#      │              │ Stores          │                 │               │
+#      │              ├────────────────►│                 │               │
+#      │              │                 │                 │               │
+#      │              │                 │ Evaluates       │               │
+#      │              │                 │◄────────────────┤               │
+#      │              │                 │                 │               │
+#      │              │                 │                 │ Redefines     │
+#      │              │                 │                 ├──────────────►│
+#      │              │                 │                 │               │
+#      │              │                 │ Validates       │               │
+#      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+#      │              │                 │                 │               │
 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) # rubocop:disable Metrics/AbcSize
-    require_relative 'syntax/union_types' if LowType.config.union_type_expressions
-
-    class << klass
-      def low_methods
-        @low_methods ||= {}
-      end
-    end
-
+  # We do as much as possible on class load rather than on object instantiation to be thread-safe and efficient.
+  def self.included(klass)
     file_path = Low::FileQuery.file_path(klass:)
-    return unless File.exist?(file_path)
+    file_proxy = Lowkey.load(file_path:)
+    class_proxy = file_proxy[klass.name]
 
-    parser = Low::FileParser.new(klass:, file_path:)
+    Low::Evaluator.evaluate(method_proxies: class_proxy.keyed_methods)
 
+    klass.include Low::ExpressionHelpers
+    klass.extend Low::ExpressionHelpers
     klass.extend Low::TypeAccessors
-    klass.include Low::Types
-    klass.include Low::Expressions
-    klass.prepend Low::Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
-    klass.singleton_class.prepend Low::Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
-
-    if (adapter = Low::Adapter::Loader.load(klass:, parser:, file_path:))
-      adapter.process
-      klass.prepend Low::Adapter::Methods
-    end
+    klass.extend Low::Types
+
+    klass.prepend Low::Redefiner.redefine(method_proxies: class_proxy.instance_methods, class_proxy:)
+    klass.singleton_class.prepend Low::Redefiner.redefine(method_proxies: class_proxy.class_methods, class_proxy:)
+
+    Low::Adapter::Loader.load(klass:, class_proxy:)
   end
 
   class << self
@@ -47,7 +60,7 @@ module LowType
         :deep_type_check,
         :union_type_expressions
       )
-      @config ||= config.new(true, :error, :type, 100, false, true)
+      @config ||= config.new(true, :error, :type, 100, true, true)
     end
 
     def configure

data/lib/proxies/local_proxy.rb

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/error_interface'
+require_relative '../interfaces/error_handling'
 require_relative '../types/error_types'
 
 module Low
-  class LocalProxy < ErrorInterface
-    attr_reader :type_expression, :name
+  class LocalProxy
+    include ErrorHandling
 
-    def initialize(type_expression:, name:, file:)
-      super()
+    attr_reader :type_expression, :name, :file_path, :start_line, :scope
+
+    def initialize(type_expression:, name:, file_path:, start_line:, scope:)
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
 
       @type_expression = type_expression
       @name = name
-      @file = file
     end
 
     def error_type
@@ -20,7 +23,7 @@ module Low
     end
 
     def error_message(value:)
-      "Invalid variable type #{output(value:)} in '#{name.class}:#{@file.start_line}'. Valid types: '#{type_expression.valid_types}'"
+      "Invalid variable type #{output(value:)} in '#{name.class}:#{@start_line}'. Valid types: '#{type_expression.valid_types}'"
     end
   end
 end

data/lib/proxies/param_proxy.rb

@@ -1,28 +1,16 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/error_interface'
-require_relative '../types/error_types'
-
-module Low
-  class ParamProxy < ErrorInterface
-    attr_reader :expression, :name, :type, :position
-
-    def initialize(expression:, name:, type:, file:, position: nil)
-      super()
+require 'lowkey'
 
-      @expression = expression
-      @name = name
-      @type = type
-      @position = position
-      @file = file
-    end
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
 
-    def required?
-      @expression.required?
-    end
+module ::Lowkey
+  class ParamProxy
+    include ::Low::ErrorHandling
 
     def error_type
-      ArgumentTypeError
+      ::Low::ArgumentTypeError
     end
 
     def error_message(value:)

data/lib/proxies/return_proxy.rb

@@ -1,26 +1,20 @@
 # frozen_string_literal: true
 
-require_relative '../interfaces/error_interface'
-require_relative '../types/error_types'
-
-module Low
-  class ReturnProxy < ErrorInterface
-    attr_reader :type_expression, :name
+require 'lowkey'
 
-    def initialize(type_expression:, name:, file:)
-      super()
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
 
-      @type_expression = type_expression
-      @name = name
-      @file = file
-    end
+module ::Lowkey
+  class ReturnProxy
+    include ::Low::ErrorHandling
 
     def error_type
-      ReturnTypeError
+      ::Low::ReturnTypeError
     end
 
     def error_message(value:)
-      "Invalid return type '#{output(value:)}' for method '#{@name}'. Valid types: '#{@type_expression.valid_types}'"
+      "Invalid return type '#{output(value:)}' for method '#{@name}'. Valid types: '#{@expression.valid_types}'"
     end
   end
 end

data/lib/queries/file_query.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
 module Low
+  class MissingFileError < StandardError; end
+
   class FileQuery
     class << self
       def file_path(klass:)
         includer_line = line_from_class(klass:) || line_from_include || ''
-        includer_line.split(':').first || ''
+        file_path = includer_line.split(':').first || ''
+
+        return file_path if File.exist?(file_path)
+
+        raise MissingFileError, "No file found at path '#{file_path}'"
       end
 
       private

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Type
-    VERSION = '1.1.8'
+    VERSION = '1.1.10'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.10
 platform: ruby
 authors:
 - maedi
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: lowkey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: An elegant and simple way to define types in Ruby, only when you need
   them.
 email:
@@ -33,25 +47,19 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
+- lib/definitions/evaluator.rb
 - lib/definitions/redefiner.rb
-- lib/definitions/repository.rb
 - lib/definitions/type_accessors.rb
-- lib/expressions/expressions.rb
+- lib/expressions/expression_helpers.rb
 - lib/expressions/type_expression.rb
 - lib/expressions/value_expression.rb
-- lib/factories/expression_factory.rb
-- lib/factories/proxy_factory.rb
 - lib/factories/type_factory.rb
 - lib/interfaces/adapter_interface.rb
-- lib/interfaces/error_interface.rb
+- lib/interfaces/error_handling.rb
 - lib/low_type.rb
-- lib/proxies/class_proxy.rb
-- lib/proxies/file_proxy.rb
 - lib/proxies/local_proxy.rb
-- lib/proxies/method_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
-- lib/queries/file_parser.rb
 - lib/queries/file_query.rb
 - lib/queries/type_query.rb
 - lib/syntax/syntax.rb

data/lib/definitions/repository.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Low
-  class Repository
-    class << self
-      def all(klass:)
-        klass.low_methods
-      end
-
-      def save(method:, klass:)
-        klass.low_methods[method.name] = method
-      end
-
-      def delete(name:, klass:)
-        klass.low_methods.delete(name)
-      end
-
-      # Redefiner inlines this method in define_method() for better performance. TODO: Test this assumption.
-      def load(name:, object:)
-        singleton(object:).low_methods[name]
-      end
-
-      # TODO: export() to RBS
-
-      private
-
-      def singleton(object:)
-        object.instance_of?(Class) ? object : object.class || Object
-      end
-    end
-  end
-end

data/lib/expressions/expressions.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../factories/expression_factory'
-require_relative '../proxies/file_proxy'
-require_relative '../proxies/local_proxy'
-require_relative '../types/error_types'
-
-module Low
-  module Expressions
-    def type(type_expression)
-      value = type_expression.default_value
-
-      last_caller = caller_locations(1, 1).first
-      file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: 'local type')
-      proxy = LocalProxy.new(type_expression:, name: self, file:)
-
-      type_expression.validate!(value:, proxy:)
-
-      return value.value if value.is_a?(ValueExpression)
-
-      value
-    rescue NoMethodError
-      raise ConfigError, "Invalid type expression, likely because you didn't add 'using LowType::Syntax'"
-    end
-    alias low_type type
-
-    def value(type)
-      ExpressionFactory.type_expression_with_value(type:)
-    end
-    alias low_value value
-  end
-end

data/lib/factories/expression_factory.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../expressions/type_expression'
-require_relative '../expressions/value_expression'
-
-module Low
-  class ExpressionFactory
-    class << self
-      def type_expression_with_value(type:)
-        TypeExpression.new(default_value: ValueExpression.new(value: type))
-      end
-    end
-  end
-end

data/lib/factories/proxy_factory.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'expressions'
-
-require_relative '../expressions/expressions'
-require_relative '../expressions/type_expression'
-require_relative '../proxies/file_proxy'
-require_relative '../proxies/param_proxy'
-require_relative '../proxies/return_proxy'
-require_relative '../queries/file_parser'
-require_relative '../syntax/syntax'
-require_relative '../types/complex_types'
-require_relative '../types/status'
-
-module Low
-  class ProxyFactory
-    using ::LowType::Syntax
-
-    class << self
-      include Low::Expressions
-      include Low::Types
-
-      def file_proxy(node:, path:, scope:)
-        start_line = node.respond_to?(:start_line) ? node.start_line : nil
-        end_line = node.respond_to?(:end_line) ? node.end_line : nil
-
-        FileProxy.new(path:, start_line:, end_line:, scope:)
-      end
-
-      # The evals below aren't a security risk because the code comes from a trusted source; the file itself that did the include.
-      def param_proxies(method_node:, file:)
-        return [] if method_node.parameters.nil?
-
-        params_without_block = method_node.parameters.slice.delete_suffix(', &block')
-
-        ruby_method = eval("-> (#{params_without_block}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
-
-        # Local variable names are prefixed with __lt or __rb where needed to avoid being overridden by method parameters.
-        typed_method = <<~RUBY
-          -> (#{params_without_block}, __rb_method:, __lt_file:) {
-            param_proxies_for_expressions(ruby_method: __rb_method, file: __lt_file, method_binding: binding)
-          }
-        RUBY
-
-        required_args, required_kwargs = required_args(ruby_method:)
-
-        # Called with only required args (as nil) and optional args omitted, to evaluate expressions stored as default values.
-        eval(typed_method, binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
-          .call(*required_args, **required_kwargs, __rb_method: ruby_method, __lt_file: file)
-
-      # TODO: Unit test this.
-      rescue ArgumentError => e
-        raise ArgumentError, "Incorrect param syntax: #{e.message}"
-      end
-
-      def return_proxy(method_node:, file:)
-        return_type = FileParser.return_type(method_node:)
-        return nil if return_type.nil?
-
-        begin
-          # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-          expression = eval(return_type.slice, binding, __FILE__, __LINE__).call # rubocop:disable Security/Eval
-        rescue NameError
-          raise NameError, "Unknown return type '#{return_type.slice}' for #{file.scope} at #{file.path}:#{file.start_line}"
-        end
-
-        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
-
-        ReturnProxy.new(type_expression: expression, name: method_node.name, file:)
-      end
-
-      private
-
-      def required_args(ruby_method:)
-        required_args = []
-        required_kwargs = {}
-
-        ruby_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
-
-      def param_proxies_for_expressions(ruby_method:, file:, method_binding:)
-        param_proxies = []
-
-        ruby_method.parameters.each_with_index do |param, position|
-          type, name = param
-
-          # We don't support splatted *positional and **keyword arguments as by definition they are untyped.
-          next if type == :rest
-
-          position = nil unless %i[opt req].include?(type)
-          local_variable = method_binding.local_variable_get(name)
-
-          expression = nil
-          if local_variable.is_a?(::Expressions::Expression)
-            expression = local_variable
-          elsif local_variable.instance_of?(Class) && local_variable < ::Expressions::Expression
-            expression = local_variable.new(provider_key: name)
-          elsif ::Low::TypeQuery.type?(local_variable)
-            expression = TypeExpression.new(type: local_variable)
-          end
-
-          param_proxies << ParamProxy.new(expression:, name:, type:, position:, file:) if expression
-        end
-
-        param_proxies
-      end
-    end
-  end
-end

data/lib/proxies/class_proxy.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Low
-  class ClassProxy
-    extend Forwardable
-
-    attr_reader :name, :klass, :file, :private_start_line
-
-    def_delegators :@file, :start_line, :end_line, :lines?
-
-    def initialize(klass:, file:, private_start_line:)
-      @name = klass.to_s
-      @klass = klass
-      @file = file
-      @private_start_line = private_start_line
-    end
-  end
-end

data/lib/proxies/file_proxy.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Low
-  class FileProxy
-    attr_reader :path, :scope
-    attr_accessor :start_line, :end_line
-
-    def initialize(path:, scope:, start_line:, end_line: nil)
-      @path = path
-      @start_line = start_line
-      @end_line = end_line || start_line
-      @scope = scope
-    end
-
-    def lines?
-      start_line && end_line
-    end
-  end
-end

data/lib/proxies/method_proxy.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Low
-  class MethodProxy
-    extend Forwardable
-
-    attr_reader :name, :file, :params, :return_proxy
-
-    # File is queried by redefiner but not sinatra adapter nor type accessors.
-    def_delegators :@file, :start_line, :end_line, :lines?
-
-    def initialize(name:, file: nil, params: [], return_proxy: nil)
-      @name = name
-      @file = file
-      @params = params
-      @return_proxy = return_proxy
-    end
-  end
-end

data/lib/queries/file_parser.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'prism'
-require_relative '../proxies/class_proxy'
-
-module Low
-  class FileParser
-    attr_reader :parent_map, :instance_methods, :class_methods, :class_proxy
-
-    def initialize(klass:, file_path:)
-      @root_node = Prism.parse_file(file_path).value
-
-      parent_mapper = ParentMapper.new
-      parent_mapper.visit(@root_node)
-      @parent_map = parent_mapper.parent_map
-
-      method_visitor = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:, file_path:)
-      @root_node.accept(method_visitor)
-
-      @instance_methods = method_visitor.instance_methods
-      @class_methods = method_visitor.class_methods
-      @class_proxy = ClassProxy.new(klass:, file: method_visitor.file_proxy, private_start_line: method_visitor.private_start_line)
-    end
-
-    def method_calls(method_names:)
-      block_visitor = MethodCallVisitor.new(parent_map:, method_names:)
-      @root_node.accept(block_visitor)
-      block_visitor.method_calls
-    end
-
-    class << self
-      # Only a lambda defined immediately after a method's parameters/block is considered a return type expression.
-      def return_type(method_node:)
-        # Method statements.
-        statements_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }
-
-        # Block statements.
-        if statements_node.nil?
-          block_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::BlockNode) }
-          statements_node = block_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) } if block_node
-        end
-
-        return nil if statements_node.nil? # Sometimes developers define methods without code inside them.
-
-        node = statements_node.body.first
-        return node if node.is_a?(Prism::LambdaNode)
-
-        nil
-      end
-    end
-  end
-
-  class MethodDefVisitor < Prism::Visitor
-    attr_reader :class_methods, :instance_methods, :file_proxy, :private_start_line
-
-    def initialize(root_node:, parent_map:, klass:, file_path:)
-      @parent_map = parent_map
-      @klass = klass
-
-      @instance_methods = {}
-      @class_methods = {}
-
-      end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
-      @file_proxy = FileProxy.new(path: file_path, start_line: 0, end_line:, scope: klass.to_s)
-      @private_start_line = nil
-    end
-
-    def visit_def_node(node)
-      if class_method?(node)
-        @class_methods[node.name] = node
-      else
-        @instance_methods[node.name] = node
-      end
-
-      super # Continue walking the tree.
-    end
-
-    def visit_call_node(node)
-      return super unless node.name == :private && node.respond_to?(:start_line) && file_proxy.start_line && file_proxy.end_line
-
-      @private_start_line = node.start_line if node.start_line > file_proxy.start_line && node.start_line < file_proxy.end_line
-
-      super
-    end
-
-    def visit_class_node(node)
-      if node.name == @klass.to_s.to_sym
-        file_proxy.start_line = node.class_keyword_loc.start_line
-        file_proxy.end_line = node.end_keyword_loc.end_line
-      end
-
-      super
-    end
-
-    private
-
-    def class_method?(node)
-      return true if node.is_a?(::Prism::DefNode) && node.receiver.instance_of?(Prism::SelfNode) # self.method_name
-      return true if node.is_a?(::Prism::SingletonClassNode) # class << self
-
-      if (parent_node = @parent_map[node])
-        return class_method?(parent_node)
-      end
-
-      false
-    end
-  end
-
-  class MethodCallVisitor < Prism::Visitor
-    attr_reader :method_calls
-
-    def initialize(parent_map:, method_names:)
-      @parent_map = parent_map
-      @method_names = method_names
-
-      @method_calls = []
-    end
-
-    def visit_call_node(node)
-      @method_calls << node if @method_names.include?(node.name)
-
-      super # Continue walking the tree.
-    end
-  end
-
-  class ParentMapper < Prism::Visitor
-    attr_reader :parent_map
-
-    def initialize
-      @parent_map = {}
-      @current_parent = nil
-    end
-
-    def visit(node)
-      @parent_map[node] = @current_parent
-
-      old_parent = @current_parent
-      @current_parent = node
-
-      node.compact_child_nodes.each do |n|
-        visit(n)
-      end
-
-      @current_parent = old_parent
-    end
-  end
-end