low_type 1.1.9 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 372ec6574de86edfe13eba87a457e290934635e88b092a711798df69d04aaa30
-  data.tar.gz: 3afaccd3fed8508ca0064cc9552b80bd05cf7b09ecfdd1906a93a043034ec978
+  metadata.gz: 54e1e267e4ef98dc2364738a169dee20cb6364d9cb597c8f7c46084309b2296f
+  data.tar.gz: 1c1b44d5b7ba03b955d039bf62a7898897d2d04230dc89ff58df055de719d37d
 SHA512:
-  metadata.gz: d59f9cf98881584fb19d3ca79748d67fdc71c5a9b55ff4ff3c4324c5658cedc88567b4037876e1d8ed5a087aafb76deff459f9493f2194ccbf002ff855a1f88b
-  data.tar.gz: be0a567f9212cb628c7efe852f71901ea4495cb9eb75681a259e68e7ef2fa545cfdfa8df0b01e4774872158db607f57fd950f274a4dcad32910c87f743de6208
+  metadata.gz: 39b512c4ff8c250659bdce0bb1be51c5f3e46e7a8ac30fa607deabdf9c933b7459bb78542211aafebf483dff3ecd8600ebb589dd4b91fb0d410c4dd9206e74fb
+  data.tar.gz: 0d4840867f0454b51b82f64807b691c4a4e4ac1380f5de113862ca8964f12fd18a62e0accaa51fad1105b94be403659ed5a80f486b4fc3ad4a1cddaf72abbf59

data/lib/adapters/adapter_loader.rb

@@ -7,14 +7,11 @@ module Low
     class Loader
       class << self
         def load(klass:, class_proxy:)
-          adaptor = nil
-
           ancestors = klass.ancestors.map(&:to_s)
-          adaptor = Sinatra.new(klass:, class_proxy:) 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,66 +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:, class_proxy:)
-        @klass = klass
-        @class_proxy = class_proxy
-        @file_path = class_proxy.file_path
-      end
-
-      def process # rubocop:disable Metrics/AbcSize
-        method_calls = @class_proxy.method_calls(%i[get post patch put delete options query])
-
-        # Type check return values.
-        method_calls.each do |method_node|
-          arguments_node = method_node.compact_child_nodes.first
-          next unless arguments_node.is_a?(Prism::ArgumentsNode)
-
-          pattern = arguments_node.arguments.first.content
-          name = "#{method_node.name.upcase} #{pattern}"
-          scope = name
-          start_line = method_node.start_line
-
-          next unless (return_proxy = ProxyFactory.return_proxy(method_node:, name:, file_path:, scope: pattern))
-
-          route = "#{method_node.name.upcase} #{pattern}"
-          name = method_node.name
-          param_proxies = [ParamProxy.new(expression: nil, name: :route, type: :req, file_path:, start_line:, scope:, position: 0)]
-          @klass.low_methods[route] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:, return_proxy:)
-        end
-      end
-
-      private
-
-      attr_reader :file_path
-    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,35 +1,46 @@
 # 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:, klass:)
-        method_proxies = build_methods(method_nodes:, klass:, file_path: class_proxy.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:, klass:)
+          typed_methods(method_proxies:, class_proxy:)
         else
-          untyped_methods(method_proxies:, class_proxy:, klass:)
+          untyped_methods(method_proxies:, class_proxy:)
         end
       end
 
-      def redefinable?(method_proxy:, class_proxy:, klass:)
-        method_has_types?(method_proxy:, klass:) && method_within_class_bounds?(method_proxy:, class_proxy:, klass:)
-      end
-
       def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
-        method_proxy.param_proxies.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,96 +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
-            name = method_node.name
-            scope = name
-
-            param_proxies = ProxyFactory.param_proxies(method_node:, file_path:, scope:)
-            return_proxy = ProxyFactory.return_proxy(method_node:, name:, file_path:, scope:)
-            method_proxy = MethodProxy.new(file_path:, start_line: method_node.start_line, scope:, name:, param_proxies:, return_proxy:)
-
-            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:, klass:) # rubocop:disable Metrics
+      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:, klass:)
-
-            # 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.param_proxies.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:, klass:)
+      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:, klass:)
-
-            # 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:, klass:)
-        if method_proxy.param_proxies == [] && method_proxy.return_proxy.nil?
-          Low::Repository.delete(name: method_proxy.name, klass:)
-          return false
-        end
-
-        true
-      end
-
-      def method_within_class_bounds?(method_proxy:, class_proxy:, klass:)
-        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.start_line <= class_proxy.end_line
-
-        unless within_bounds
-          Low::Repository.delete(name: method_proxy.name, klass:)
-          return false
-        end
-
-        true
-      end
     end
   end
 end

data/lib/definitions/type_accessors.rb

@@ -9,37 +9,35 @@ module Low
     def type_reader(named_expressions)
       named_expressions.each do |name, exp|
         last_caller = caller_locations(1, 1).first
+
         file_path = last_caller.path
         start_line = last_caller.lineno
         scope = "#{self}##{name}"
 
-        type_expression = type_expression(exp)
-        return_proxy = ReturnProxy.new(type_expression:, name:, file_path:, start_line:, scope:)
-
-        @low_methods[name] = MethodProxy.new(file_path:, start_line:, scope:, name:, return_proxy:)
+        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}")
-          type_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
+    def type_writer(named_expressions)
       named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
+
         file_path = last_caller.path
         start_line = last_caller.lineno
         scope = "#{self}##{name}"
 
-        param_proxies = [ParamProxy.new(expression: type_expression(expression), name:, type: :hashreq, file_path:, start_line:, scope:)]
-        @low_methods["#{name}="] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:)
+        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.param_proxies.first.expression.validate!(value:, proxy: method_proxy.param_proxies.first)
+          expression.validate!(value:, proxy:)
           instance_variable_set("@#{name}", value)
         end
       end
@@ -54,10 +52,10 @@ module Low
 
     private
 
-    def type_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/{expressions.rb → expression_helpers.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../factories/expression_factory'
+require_relative 'type_expression'
+require_relative 'value_expression'
 require_relative '../proxies/local_proxy'
-require_relative '../types/error_types'
 
 module Low
-  module Expressions
+  module ExpressionHelpers
     def type(type_expression)
       value = type_expression.default_value
 
@@ -20,12 +20,12 @@ module Low
 
       value
     rescue NoMethodError
-      raise ConfigError, "Invalid type expression, likely because you didn't add 'using LowType::Syntax'"
+      raise ConfigError, "Invalid type expression. Did you add 'using LowType::Syntax'?"
     end
     alias low_type type
 
     def value(type)
-      ExpressionFactory.type_expression_with_value(type:)
+      TypeExpression.new(default_value: ValueExpression.new(value: type))
     end
     alias low_value value
   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}

@@ -2,18 +2,7 @@
 
 module Low
   # Used by proxies to output errors.
-  class ErrorInterface
-    attr_reader :file_path, :start_line, :scope
-
-    def initialize(file_path:, start_line:, scope:)
-      @file_path = file_path
-      @start_line = start_line
-      @scope = scope
-
-      @output_mode = LowType.config.output_mode
-      @output_size = LowType.config.output_size
-    end
-
+  module ErrorHandling
     def error_type
       raise NotImplementedError
     end
@@ -23,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

data/lib/low_type.rb

@@ -5,38 +5,49 @@ require 'lowkey'
 require_relative 'adapters/adapter_loader'
 require_relative 'definitions/redefiner'
 require_relative 'definitions/type_accessors'
-require_relative 'expressions/expressions'
+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.definitions[klass.name]
+    class_proxy = file_proxy[klass.name]
+
+    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: class_proxy.instance_methods, class_proxy:, klass:)
-    klass.singleton_class.prepend Low::Redefiner.redefine(method_nodes: class_proxy.class_methods, class_proxy:, klass:)
-
-    if (adapter = Low::Adapter::Loader.load(klass:, class_proxy:))
-      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
@@ -49,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,14 +1,18 @@
 # 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
+
+    attr_reader :type_expression, :name, :file_path, :start_line, :scope
 
     def initialize(type_expression:, name:, file_path:, start_line:, scope:)
-      super(file_path:, start_line:, scope:)
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
 
       @type_expression = type_expression
       @name = name

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
-
-    # TODO: Refactor file path, start line and scope into "meta scope" model.
-    def initialize(expression:, name:, type:, file_path:, start_line:, scope:, position: nil) # rubocop:disable Metrics/ParameterLists
-      super(file_path:, start_line:, scope:)
+require 'lowkey'
 
-      @expression = expression
-      @name = name
-      @type = type
-      @position = position
-    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,25 +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_path:, start_line:, scope:)
-      super(file_path:, start_line:, scope:)
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
 
-      @type_expression = type_expression
-      @name = name
-    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.9'
+    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.9
+  version: 1.1.10
 platform: ruby
 authors:
 - maedi
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 description: An elegant and simple way to define types in Ruby, only when you need
   them.
 email:
@@ -47,20 +47,17 @@ 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/local_proxy.rb
-- lib/proxies/method_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/queries/file_query.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/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,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'expressions'
-require 'lowkey'
-
-require_relative '../expressions/expressions'
-require_relative '../expressions/type_expression'
-require_relative '../proxies/param_proxy'
-require_relative '../proxies/return_proxy'
-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
-
-      # 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_path:, scope:)
-        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_path: __lt_file, start_line: method_node.start_line, scope:, 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_path)
-
-      # TODO: Unit test this.
-      rescue ArgumentError => e
-        raise ArgumentError, "Incorrect param syntax: #{e.message}"
-      end
-
-      def return_proxy(method_node:, name:, file_path:, scope:)
-        return_type = Lowkey::ClassProxy.return_type(method_node:)
-        return nil if return_type.nil?
-
-        start_line = method_node.start_line
-
-        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 #{scope} at #{file_path}:#{start_line}"
-        end
-
-        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
-
-        ReturnProxy.new(type_expression: expression, name:, file_path:, start_line:, scope:)
-      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_path:, start_line:, scope:, 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:, file_path:, start_line:, scope:, position:) if expression
-        end
-
-        param_proxies
-      end
-    end
-  end
-end

data/lib/proxies/method_proxy.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Low
-  class MethodProxy
-    attr_reader :file_path, :start_line, :scope, :name, :param_proxies, :return_proxy
-
-    # TODO: Refactor file path, start line and scope into "meta scope" model.
-    def initialize(file_path:, start_line:, scope:, name:, param_proxies: [], return_proxy: nil) # rubocop:disable Metrics/ParameterLists
-      @file_path = file_path
-      @start_line = start_line
-      @scope = scope
-
-      @name = name
-      @param_proxies = param_proxies
-      @return_proxy = return_proxy
-    end
-  end
-end