low_type 1.1.2 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2ff86050dbdbbaf494210b5ccb0ca36735305cae2a90701d406ee41830eb8b1
-  data.tar.gz: 5345157740d454fa13dbf8d78c37e989b1e1a5a7e0e76cf914b5d9b8da324c58
+  metadata.gz: 2ed9039d493d3be677095a358691d03a7edf2dfd6416b48dfa352d03fec7cef7
+  data.tar.gz: 832ac8f63eec8a4e03d616286bea41f9945e0c30fbe55afe41f88857a82e01e9
 SHA512:
-  metadata.gz: 75b594af3ac1947a5adda7a9b56d1e31a2fecb95098f48be0b0af54f16364d3c43cad27412e19f3f525f06864a9c5e7b74f45f6f41734641287bb76160e4c17d
-  data.tar.gz: 423c63f4242bb7c4bf3fdbea6786eba6fc8408fd1c16ba26cd2400e6963e86e2f5ba38882bbe1cba167e42a334bf8fd85a5b320b7d5a1975b0c8a756886643f8
+  metadata.gz: b3eb8482d26eed780072944c51a00afb5e0d6cb360d754f37208453728102a07ed227ed13d17735e096ff107709b06e61d215ee6b0d89b3b9cdf5099048a643e
+  data.tar.gz: 3710dfca9e28556e2d8a781585adc809992b6469e0f3cd4f7c26fcd82e54d149a303f020522531b1350adaf954e09ffc8f02813c88c83f5718f5b334c59d4939

data/lib/definitions/redefiner.rb

@@ -1,28 +1,23 @@
 # frozen_string_literal: true
 
-require_relative '../expressions/expressions'
-require_relative '../expressions/type_expression'
 require_relative '../expressions/value_expression'
-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 'repository'
 
 module LowType
   # Redefine methods to have their arguments and return values type checked.
   class Redefiner
-    using Syntax
-
     class << self
-      include Expressions
-
       def redefine(method_nodes:, class_proxy:, file_path:)
-        method_proxies = create_method_proxies(method_nodes:, klass: class_proxy.klass, file_path:)
-        define_methods(method_proxies:, class_proxy:)
+        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:)
@@ -42,13 +37,28 @@ module LowType
         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 create_method_proxies(method_nodes:, klass:, file_path:)
+      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 = param_proxies(method_node:, file:)
+          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:)
 
@@ -58,21 +68,19 @@ module LowType
         Repository.all(klass:)
       end
 
-      def define_methods(method_proxies:, class_proxy:) # 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 LowType::Redefiner.redefinable?(method_proxy:, class_proxy:)
 
-            # NOTE: You are now in the binding of the includer class (`name` is also available here).
+            # 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]
-                if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
-                  value = param_proxy.type_expression.default_value
-                end
+                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)
@@ -93,64 +101,22 @@ module LowType
         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)
+      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:)
 
-              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
+            # 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
 
-            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
+            private name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
           end
         end
-
-        [required_args, required_kwargs]
       end
     end
   end

data/lib/factories/proxy_factory.rb

@@ -1,13 +1,20 @@
 # 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 '../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
@@ -15,16 +22,89 @@ module LowType
         FileProxy.new(path:, start_line:, end_line:, scope:)
       end
 
+      def param_proxies(method_node:, file:)
+        return [] if method_node.parameters.nil?
+
+        params_without_block = method_node.parameters.slice.delete_suffix(', &block')
+
+        # 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("-> (#{params_without_block}) {}", 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
+          -> (#{params_without_block}, __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/low_type.rb

@@ -11,7 +11,7 @@ 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.
-  def self.included(klass)
+  def self.included(klass) # rubocop:disable Metrics/AbcSize
     require_relative 'syntax/union_types' if LowType.config.union_type_expressions
 
     class << klass
@@ -21,6 +21,8 @@ module LowType
     end
 
     file_path = FileQuery.file_path(klass:)
+    return unless File.exist?(file_path)
+
     parser = FileParser.new(klass:, file_path:)
 
     klass.extend TypeAccessors
@@ -36,8 +38,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/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/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.2'
+  VERSION = '1.1.4'
 end

metadata

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