low_type 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8dae7f03ed51a1acea72d53deec50af0722e9c57ac8baab72297420bae36f4b
-  data.tar.gz: d7de0927fb139ac7d2b934c01f464224bb30fe2fbba6ca8b62a789955561e602
+  metadata.gz: 31fd9fee4aba001196fa20d6aaf51428121c4512ec85093bd3c68a1103b0ba83
+  data.tar.gz: 6ddc9528e3f5b0b6ac3fb841bf620874ab3ef08f0cd7acb0d6e0f6aebe3d20d7
 SHA512:
-  metadata.gz: f4a91869b8c041091cd2dcadfb5ff931883041f7d57319b6cfb60b8ef7c1607924d81b93fc1a936724a3d577e904ed1d76c5bb03c89d6bf872e6446f0490f52e
-  data.tar.gz: d42d49968af57b0122e76449d01a5ed118bb4394d28fe42a6a9ec9095f6900ec02940e237e75fe3c1c4417b307c0b85497193a492b721e3c139902a15d92be7b
+  metadata.gz: 6eb3e48691817f849f922e5f59af5157eb107b9cf960cdd7e147eb49561a0617ad6e6669d8f7a8319f8b39ea46e98f66cb4ac91e4c4a35fe269b2db115811a2f
+  data.tar.gz: 4ad23e5c8e4c5be264713f4dc6ea6deff8e66019db967ff09bbe92d4b0e7d3d46796bc123fa188a17d3b6904e76268e29a9def75b2c34304d0712c785cfee4ee

data/lib/adapters/sinatra_adapter.rb

@@ -2,8 +2,8 @@
 
 require 'prism'
 
+require_relative '../factories/proxy_factory'
 require_relative '../interfaces/adapter_interface'
-require_relative '../proxies/file_proxy'
 require_relative '../proxies/return_proxy'
 require_relative '../types/error_types'
 
@@ -27,8 +27,7 @@ module LowType
 
           pattern = arguments_node.arguments.first.content
 
-          line = FileParser.line_number(node: method_call)
-          file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
+          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}"

data/lib/definitions/redefiner.rb

@@ -0,0 +1,123 @@
+# 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'
+
+module LowType
+  # Redefine methods to have their arguments and return values type checked.
+  class Redefiner
+    class << self
+      def redefine(method_nodes:, class_proxy:, file_path:)
+        method_proxies = build_methods(method_nodes:, klass: class_proxy.klass, file_path:)
+
+        if LowType.config.type_checking
+          typed_methods(method_proxies:, class_proxy:)
+        else
+          untyped_methods(method_proxies:, class_proxy:)
+        end
+      end
+
+      def redefinable?(method_proxy:, class_proxy:)
+        # Method has no types.
+        if method_proxy.params == [] && method_proxy.return_proxy.nil?
+          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        # Method outside class bounds.
+        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
+          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        true
+      end
+
+      def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
+        method_proxy.params.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?
+
+          value = param_proxy.type_expression.default_value # Default value can still be `nil`.
+          value = value.value if value.is_a?(ValueExpression)
+          param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
+        end
+
+        [args, kwargs]
+      end
+
+      private
+
+      def build_methods(method_nodes:, klass:, file_path:)
+        method_nodes.each do |name, method_node|
+          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:)
+        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 LowType::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.type_expression.default_value if value.nil? && !param_proxy.required?
+
+                param_proxy.type_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
+              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 return_value
+              end
+
+              super(*args, **kwargs)
+            end
+
+            private 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 LowType::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|
+              # 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]
+              args, kwargs = LowType::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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/definitions/repository.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LowType
+  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/{instance_types.rb → definitions/type_accessors.rb}

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'proxies/return_proxy'
-require_relative 'queries/type_query'
-require_relative 'type_expression'
+require_relative '../expressions/type_expression'
+require_relative '../proxies/return_proxy'
+require_relative '../queries/type_query'
 
 module LowType
-  module InstanceTypes
+  module TypeAccessors
     def type_reader(named_expressions)
       named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
         type_expression = type_expression(expression)
-        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
         @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression:, name:, file:))
 
@@ -27,7 +27,7 @@ module LowType
       named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
         type_expression = type_expression(expression)
-        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
         @low_methods["#{name}="] = MethodProxy.new(name:, params: [ParamProxy.new(type_expression:, name:, type: :hashreq, file:)])
 

data/lib/{local_types.rb → expressions/expressions.rb}

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'factories/expression_factory'
-require_relative 'proxies/file_proxy'
-require_relative 'proxies/local_proxy'
-require_relative 'types/error_types'
+require_relative '../factories/expression_factory'
+require_relative '../proxies/file_proxy'
+require_relative '../proxies/local_proxy'
+require_relative '../types/error_types'
 
 module LowType
-  module LocalTypes
+  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, line: last_caller.lineno, scope: 'local type')
+      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:)

data/lib/{type_expression.rb → expressions/type_expression.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'proxies/param_proxy'
-require_relative 'queries/type_query'
+require_relative '../proxies/param_proxy'
+require_relative '../queries/type_query'
 
 module LowType
   root_path = File.expand_path(__dir__)
   adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
-  module_paths = %w[instance_types local_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
+  module_paths = %w[expressions/expressions instance_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
 
   HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
 

data/lib/factories/expression_factory.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../type_expression'
-require_relative '../value_expression'
+require_relative '../expressions/type_expression'
+require_relative '../expressions/value_expression'
 
 module LowType
   class ExpressionFactory

data/lib/factories/proxy_factory.rb

@@ -1,22 +1,108 @@
 # frozen_string_literal: true
 
+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 '../type_expression'
+require_relative '../syntax/syntax'
 
 module LowType
   class ProxyFactory
+    using ::LowType::Syntax
+
     class << self
+      include Expressions
+
+      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
+
+      def param_proxies(method_node:, file:)
+        return [] if method_node.parameters.nil?
+
+        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
+        ruby_method = eval("-> (#{method_node.parameters.slice}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+
+        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
+        # Local variable names are prefixed with __lt or __rb where necessary to avoid being overridden by method parameters.
+        typed_method = <<~RUBY
+          -> (#{method_node.parameters.slice}, __rb_method:, __lt_file:) {
+            param_proxies_for_type_expressions(ruby_method: __rb_method, file: __lt_file, method_binding: binding)
+          }
+        RUBY
+
+        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (from default values).
+        # Passes internal variables with namespaced names to avoid conflicts with the method parameters.
+        required_args, required_kwargs = required_args(ruby_method:)
+        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?
 
-        # 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
+        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_type_expressions(ruby_method:, file:, method_binding:)
+        param_proxies = []
+
+        ruby_method.parameters.each_with_index do |param, position|
+          type, name = param
+          position = nil unless %i[opt req rest].include?(type)
+          expression = method_binding.local_variable_get(name)
+
+          type_expression = nil
+          if expression.is_a?(TypeExpression)
+            type_expression = expression
+          elsif ::LowType::TypeQuery.type?(expression)
+            type_expression = TypeExpression.new(type: expression)
+          end
+
+          param_proxies << ParamProxy.new(type_expression:, name:, type:, position:, file:) if type_expression
+        end
+
+        param_proxies
+      end
     end
   end
 end

data/lib/interfaces/error_interface.rb

@@ -35,7 +35,7 @@ module LowType
       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.line}:in '#{file.scope}'"
+      proxy_file_backtrace = "#{file.path}:#{file.start_line}:in '#{file.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,13 +1,13 @@
 # frozen_string_literal: true
 
 require_relative 'adapters/adapter_loader'
-require_relative 'syntax/syntax'
-require_relative 'types/complex_types'
+require_relative 'definitions/redefiner'
+require_relative 'definitions/type_accessors'
+require_relative 'expressions/expressions'
 require_relative 'queries/file_parser'
 require_relative 'queries/file_query'
-require_relative 'instance_types'
-require_relative 'local_types'
-require_relative 'redefiner'
+require_relative 'syntax/syntax'
+require_relative 'types/complex_types'
 
 module LowType
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
@@ -22,12 +22,11 @@ module LowType
 
     file_path = FileQuery.file_path(klass:)
     parser = FileParser.new(klass:, file_path:)
-    line_numbers = parser.line_numbers
 
-    klass.extend InstanceTypes
-    klass.include LocalTypes
-    klass.prepend Redefiner.redefine(method_nodes: parser.instance_methods, klass:, line_numbers:, file_path:)
-    klass.singleton_class.prepend Redefiner.redefine(method_nodes: parser.class_methods, klass:, line_numbers:, file_path:)
+    klass.extend TypeAccessors
+    klass.include Expressions
+    klass.prepend Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
+    klass.singleton_class.prepend Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
 
     if (adapter = Adapter::Loader.load(klass:, parser:, file_path:))
       adapter.process
@@ -37,8 +36,8 @@ module LowType
 
   class << self
     def config
-      config = Struct.new(:error_mode, :output_mode, :output_size, :deep_type_check, :union_type_expressions)
-      @config ||= config.new(:error, :type, 100, false, true)
+      config = Struct.new(:type_checking, :error_mode, :output_mode, :output_size, :deep_type_check, :union_type_expressions)
+      @config ||= config.new(true, :error, :type, 100, false, true)
     end
 
     def configure

data/lib/proxies/class_proxy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module LowType
+  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

@@ -2,12 +2,18 @@
 
 module LowType
   class FileProxy
-    attr_reader :path, :line, :scope
+    attr_reader :path, :scope
+    attr_accessor :start_line, :end_line
 
-    def initialize(path:, line:, scope:)
+    def initialize(path:, scope:, start_line:, end_line: nil)
       @path = path
-      @line = line
+      @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/local_proxy.rb

@@ -20,7 +20,7 @@ module LowType
     end
 
     def error_message(value:)
-      "Invalid variable type #{output(value:)} in '#{@name.class}' on line #{@file.line}. Valid types: '#{@type_expression.valid_types}'"
+      "Invalid variable type #{output(value:)} in '#{name.class}:#{@file.start_line}'. Valid types: '#{type_expression.valid_types}'"
     end
   end
 end

data/lib/proxies/method_proxy.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module LowType
   class MethodProxy
-    attr_reader :name, :params, :return_proxy
+    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:, params: [], return_proxy: nil)
+    def initialize(name:, file: nil, params: [], return_proxy: nil)
       @name = name
+      @file = file
       @params = params
       @return_proxy = return_proxy
     end

data/lib/proxies/param_proxy.rb

@@ -17,6 +17,10 @@ module LowType
       @file = file
     end
 
+    def required?
+      @type_expression.default_value == :LOW_TYPE_UNDEFINED
+    end
+
     def error_type
       ArgumentTypeError
     end

data/lib/queries/file_parser.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'prism'
+require_relative '../proxies/class_proxy'
 
 module LowType
   class FileParser
-    attr_reader :parent_map, :instance_methods, :class_methods, :line_numbers
+    attr_reader :parent_map, :instance_methods, :class_methods, :class_proxy
 
     def initialize(klass:, file_path:)
       @root_node = Prism.parse_file(file_path).value
@@ -13,12 +14,12 @@ module LowType
       parent_mapper.visit(@root_node)
       @parent_map = parent_mapper.parent_map
 
-      method_visitor = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:)
+      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
-      @line_numbers = method_visitor.line_numbers
+      @class_proxy = ClassProxy.new(klass:, file: method_visitor.file_proxy, private_start_line: method_visitor.private_start_line)
     end
 
     def method_calls(method_names:)
@@ -46,50 +47,46 @@ module LowType
 
         nil
       end
-
-      def line_number(node:)
-        node.respond_to?(:start_line) ? node.start_line : nil
-      end
     end
   end
 
   class MethodDefVisitor < Prism::Visitor
-    attr_reader :class_methods, :instance_methods, :line_numbers
+    attr_reader :class_methods, :instance_methods, :file_proxy, :private_start_line
 
-    def initialize(root_node:, parent_map:, klass:)
+    def initialize(root_node:, parent_map:, klass:, file_path:)
       @parent_map = parent_map
       @klass = klass
 
-      @instance_methods = []
-      @class_methods = []
-      @line_numbers = { class_start: 0, class_end: root_node.respond_to?(:end_line) ? root_node.end_line : nil }
+      @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
+        @class_methods[node.name] = node
       else
-        @instance_methods << node
+        @instance_methods[node.name] = node
       end
 
       super # Continue walking the tree.
     end
 
     def visit_call_node(node)
-      start_line = node.name == :private && node.respond_to?(:start_line) && node.start_line || nil
-      class_start = @line_numbers[:class_start]
-      class_end = @line_numbers[:class_end]
+      return super unless node.name == :private && node.respond_to?(:start_line) && file_proxy.start_line && file_proxy.end_line
 
-      if start_line && class_start && class_end && start_line > class_start && start_line < class_end
-        @line_numbers[:private_start] = node.start_line
-      end
+      @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
-        @line_numbers = { class_start: node.class_keyword_loc.start_line, class_end: node.end_keyword_loc.end_line }
+        file_proxy.start_line = node.class_keyword_loc.start_line
+        file_proxy.end_line = node.end_keyword_loc.end_line
       end
 
       super

data/lib/queries/type_query.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../type_expression'
+require_relative '../expressions/type_expression'
 
 module LowType
   # TODO: Unit test.

data/lib/syntax/union_types.rb

@@ -19,7 +19,7 @@ class Object
         expression | self
         expression
       else
-        # We turn our type into a type expression and pass in their [type_expression/type/value].
+        # We turn our type into a type expression and pass in their type/value.
         type_expression = ::LowType::TypeExpression.new(type: self)
         type_expression | expression
       end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - maedi
@@ -19,14 +19,19 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
+- lib/definitions/redefiner.rb
+- lib/definitions/repository.rb
+- lib/definitions/type_accessors.rb
+- lib/expressions/expressions.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/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
-- lib/local_types.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
@@ -35,13 +40,10 @@ files:
 - lib/queries/file_parser.rb
 - lib/queries/file_query.rb
 - lib/queries/type_query.rb
-- lib/redefiner.rb
 - lib/syntax/syntax.rb
 - lib/syntax/union_types.rb
-- lib/type_expression.rb
 - lib/types/complex_types.rb
 - lib/types/error_types.rb
-- lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type
 licenses: []

data/lib/redefiner.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'factories/expression_factory'
-require_relative 'factories/proxy_factory'
-require_relative 'proxies/file_proxy'
-require_relative 'proxies/method_proxy'
-require_relative 'proxies/param_proxy'
-require_relative 'queries/type_query'
-require_relative 'syntax/syntax'
-require_relative 'type_expression'
-require_relative 'value_expression'
-
-module LowType
-  # Redefine methods to have their arguments and return values type checked.
-  class Redefiner
-    using Syntax
-
-    class << self
-      def redefine(method_nodes:, klass:, line_numbers:, file_path:)
-        create_proxies(method_nodes:, klass:, file_path:)
-        define_methods(method_nodes:, line_numbers:)
-      end
-
-      private
-
-      def create_proxies(method_nodes:, klass:, file_path:)
-        method_nodes.each do |method_node|
-          name = method_node.name
-          line = FileParser.line_number(node: method_node)
-          file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{name}")
-          params = param_proxies(method_node:, file:)
-          return_proxy = ProxyFactory.return_proxy(method_node:, file:)
-
-          klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
-        end
-      end
-
-      def define_methods(method_nodes:, line_numbers:) # rubocop:disable Metrics
-        class_start = line_numbers[:class_start]
-        class_end = line_numbers[:class_end]
-        private_start = line_numbers[:private_start]
-
-        Module.new do
-          method_nodes.each do |method_node|
-            method_start = method_node.respond_to?(:start_line) ? method_node.start_line : nil
-            method_end = method_node.respond_to?(:end_line) ? method_node.end_line : nil
-
-            next if method_start && method_end && class_end && !(method_start > class_start && method_end <= class_end)
-
-            name = method_node.name
-
-            define_method(name) do |*args, **kwargs|
-              method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
-
-              method_proxy.params.each do |param_proxy|
-                # Get argument value or default value.
-                value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
-                if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
-                  value = param_proxy.type_expression.default_value
-                end
-
-                param_proxy.type_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
-              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 return_value
-              end
-
-              super(*args, **kwargs)
-            end
-
-            private name if private_start && method_start > private_start
-          end
-        end
-      end
-
-      def param_proxies(method_node:, file:)
-        return [] if method_node.parameters.nil?
-
-        params = method_node.parameters.slice
-        proxy_method = proxy_method(method_node:)
-        required_args, required_kwargs = required_args(proxy_method:)
-
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        typed_method = <<~RUBY
-          -> (#{params}) {
-            param_proxies = []
-
-            proxy_method.parameters.each_with_index do |param, position|
-              type, name = param
-              position = nil unless [:opt, :req, :rest].include?(type)
-              expression = binding.local_variable_get(name)
-
-              if expression.is_a?(TypeExpression)
-                param_proxies << ParamProxy.new(type_expression: expression, name:, type:, position:, file:)
-              elsif ::LowType::TypeQuery.type?(expression)
-                param_proxies << ParamProxy.new(type_expression: TypeExpression.new(type: expression), name:, type:, position:, file:)
-              end
-            end
-
-            param_proxies
-          }
-        RUBY
-
-        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (from default values).
-        eval(typed_method, binding, __FILE__, __LINE__).call(*required_args, **required_kwargs) # rubocop:disable Security/Eval
-
-      # TODO: Write spec for this.
-      rescue ArgumentError => e
-        raise ArgumentError, "Incorrect param syntax: #{e.message}"
-      end
-
-      def proxy_method(method_node:)
-        params = method_node.parameters.slice
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
-      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
-
-      # Value expressions are eval()'d in the context of this module class (the instance doesn't exist yet) so alias API.
-      def value(type)
-        ExpressionFactory.type_expression_with_value(type:)
-      end
-    end
-  end
-end