low_type 0.8.10 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afb83ff40c25644eeb106f67afff8e4f3ab31ae960bf51ec55daa0154dfe2a53
-  data.tar.gz: f57573081ca5725606904a4cfe0e7ba85a937b6639330938975c05d161841df0
+  metadata.gz: a340469d2c2f4945b043ab3cd4973f14cf12f9d80336b7939bdb85b0da5b739e
+  data.tar.gz: 2e51c25e1b944dff67fb85f4582a2f3f38eca299fe58d4cc464c4b8c162a9d8a
 SHA512:
-  metadata.gz: eecb035a898e3e9f0020b619fdbe44460967dc5233023fe7bb4d3e5d950f7d3832b07d6512594ba4ccd74216bd70e739ebb39d0eac8d5b34f5410a67645035b9
-  data.tar.gz: dbcce2c671faceb757b8a549404ec27662a63f1c5df71b2f0d711d023d3c949920e9fa09b17c6ec135d567fbe3cc376218fbfab6028a84339bc2830867b0b2f5
+  metadata.gz: 8857cb2e301aa2e7f4ddf167fe622d3988d7d28ff223361a50a056f28ea248e4ad81ecc48fc2174f2f8845c7af7e8fad072ac9bf3ed4eea5a0bad37a06ab9b6d
+  data.tar.gz: c401324adf4f5aa4b4da5a1c6f19d5b3daa095e7ff28a43a9075f28f4d7a8947a13fcba500bab252eece331b51d65e89fee09efd99e1d61f5e0290faae51dab7

data/lib/adapters/adapter_loader.rb

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 require_relative 'sinatra_adapter'
 
 module LowType
-  class AdapterLoader
-    class << self
-      def load(klass:, parser:, file_path:)
-        adaptor = nil
+  module Adapter
+    class Loader
+      class << self
+        def load(klass:, parser:, file_path:)
+          adaptor = nil
 
-        ancestors = klass.ancestors.map(&:to_s)
-        adaptor = SinatraAdapter.new(klass:, parser:, file_path:) if ancestors.include?('Sinatra::Base')
+          ancestors = klass.ancestors.map(&:to_s)
+          adaptor = Sinatra.new(klass:, parser:, file_path:) if ancestors.include?('Sinatra::Base')
 
-        return if adaptor.nil?
+          return if adaptor.nil?
 
-        adaptor
+          adaptor
+        end
       end
     end
   end

data/lib/adapters/sinatra_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'prism'
 
 require_relative '../interfaces/adapter_interface'
@@ -6,77 +8,72 @@ require_relative '../proxies/return_proxy'
 require_relative '../error_types'
 
 module LowType
-  class Status < Integer; end
-  class Headers < Hash; end
-
-  # 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 SinatraAdapter < AdapterInterface
-    def initialize(klass:, parser:, file_path:)
-      @klass = klass
-      @parser = parser
-      @file_path = file_path
-    end
+  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
-      method_calls = @parser.method_calls(method_names: [:get, :post, :patch, :put, :delete, :options, :query])
+      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)
+        # 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
+          pattern = arguments_node.arguments.first.content
 
-        line = method_call.respond_to?(:start_line) ? method_call.start_line : nil
-        file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
-        params = [ParamProxy.new(type_expression: nil, name: :route, type: :req, position: 0, file:)]
-        return_proxy = return_proxy(method_node: method_call, pattern:, file:)
-        next unless return_proxy
+          line = Parser.line_number(node: method_call)
+          file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
+          next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
 
-        route = "#{method_call.name.upcase} #{pattern}"
-        @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
+          route = "#{method_call.name.upcase} #{pattern}"
+          params = [ParamProxy.new(type_expression: nil, name: :route, type: :req, position: 0, file:)]
+          @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
+        end
       end
-    end
 
-    def redefine
-      Module.new do
-        def invoke(&block)
-          res = catch(:halt, &block)
-
-          raise AllowedTypeError, 'Did you mean "Response.finish"?' if res.to_s == 'Response'
-
-          route = "#{request.request_method} #{request.path}"
-          if (res && (method_proxy = self.class.low_methods[route]) && (proxy = method_proxy.return_proxy))
-            proxy.type_expression.types.each do |type|
-              proxy.type_expression.validate!(value: res, proxy:)
-            end
-          end
-
-          res = [res] if (Integer === res) || (String === res)
-          if (Array === res) && (Integer === res.first)
-            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 return_proxy(method_node:, pattern:, file:)
+        return_type = Parser.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
 
-    private
+    module Methods
+      def invoke(&block)
+        res = catch(:halt, &block)
+
+        low_validate!(value: res) if res
 
-    def return_proxy(method_node:, pattern:, file:)
-      return_type = Parser.return_type(method_node:)
-      return nil if return_type.nil?
+        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
 
-      expression = eval(return_type.slice).call
-      expression = TypeExpression.new(type: expression) unless TypeExpression === expression
+        nil # avoid double setting the same response tuple twice
+      end
 
-      ReturnProxy.new(type_expression: expression, name: "#{method_node.name.upcase} #{pattern}", file:)
+      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:)
+        end
+      end
     end
   end
 end

data/lib/basic_types.rb

@@ -1,6 +1,11 @@
-module LowType
-  class Boolean; end # TrueClass or FalseClass
+# frozen_string_literal: true
 
+module LowType
+  # TrueClass or FalseClass
+  class Boolean; end
+  class Tuple < Array; end
+  class Status < Integer; end
+  class Headers < Hash; end
   class HTML < String; end
   class JSON < String; end
   class XML < String; end

data/lib/error_types.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module LowType
-  class ArgumentTypeError < TypeError; end;
-  class LocalTypeError < TypeError; end;
-  class ReturnTypeError < TypeError; end;
-  class AllowedTypeError < TypeError; end;
+  class ArgumentTypeError < TypeError; end
+  class LocalTypeError < TypeError; end
+  class ReturnTypeError < TypeError; end
+  class AllowedTypeError < TypeError; end
 end

data/lib/factories/proxy_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../proxies/return_proxy'
+require_relative '../parser'
+require_relative '../type_expression'
+
+module LowType
+  class ProxyFactory
+    class << self
+      def return_proxy(method_node:, file:)
+        return_type = Parser.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
+        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
+
+        ReturnProxy.new(type_expression: expression, name: method_node.name, file:)
+      end
+    end
+  end
+end

data/lib/instance_types.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'proxies/return_proxy'
+require_relative 'type_expression'
+
+module LowType
+  module InstanceTypes
+    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}")
+
+        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression:, name:, file:))
+
+        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)
+          value
+        end
+      end
+    end
+
+    def type_writer(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}")
+
+        @low_methods["#{name}="] = MethodProxy.new(name:, params: [ParamProxy.new(type_expression:, name:, type: :hashreq, file:)])
+
+        define_method("#{name}=") do |value|
+          method_proxy = self.class.low_methods["#{name}="]
+          type_expression.validate!(value:, proxy: method_proxy.params.first)
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+
+    def type_accessor(named_expressions)
+      named_expressions.each do |name, expression|
+        type_reader({ name => expression })
+        type_writer({ name => expression })
+      end
+    end
+
+    private
+
+    def type_expression(expression)
+      if expression.instance_of?(TypeExpression)
+        expression
+      elsif ::LowType.type?(expression)
+        TypeExpression.new(type: expression)
+      end
+    end
+  end
+end

data/lib/interfaces/adapter_interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LowType
   class AdapterInterface
     def process

data/lib/interfaces/error_interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LowType
   class ErrorInterface
     attr_reader :file

data/lib/local_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/local_proxy'
 require_relative 'type_expression'
@@ -7,11 +9,9 @@ module LocalTypes
   class AssignmentError < StandardError; end
 
   def type(type_expression)
-    referenced_object = type_expression.default_value
+    referenced_object = type_expression.default_value.dup
 
-    if !LowType.value?(referenced_object)
-      raise AssignmentError, "Single-instance objects like #{referenced_object} are not supported"
-    end
+    raise AssignmentError, "Single-instance objects like #{referenced_object} are not supported" unless LowType.value?(referenced_object)
 
     last_caller = caller_locations(1, 1).first
     file = LowType::FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
@@ -20,36 +20,23 @@ module LocalTypes
 
     type_expression.validate!(value: referenced_object, proxy: local_proxy)
 
-    def referenced_object.with_type=(value)
-      local_proxy = self.instance_variable_get('@local_proxy')
-      type_expression = local_proxy.type_expression
-      type_expression.validate!(value:, proxy: local_proxy)
-
-      # We can't reassign self in Ruby so we reassign instance variables instead.
-      value.instance_variables.each do |variable|
-        self.instance_variable_set(variable, value.instance_variable_get(variable))
-      end
-
-      self
-    end
+    define_with_type(referenced_object:)
 
     return referenced_object.value if referenced_object.is_a?(ValueExpression)
 
     referenced_object
   end
-  alias_method :low_type, :type
+  alias low_type type
 
   def value(type)
     LowType.value(type:)
   end
-  alias_method :low_value, :value
+  alias low_value value
 
   # Scoped to the class that includes LowTypes module.
   class Array < ::Array
     def self.[](*types)
-      if types.all? { |type| LowType.type?(type) }
-        return LowType::TypeExpression.new(type: [*types])
-      end
+      return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
 
       super
     end
@@ -59,7 +46,25 @@ module LocalTypes
   class Hash < ::Hash
     def self.[](type)
       return LowType::TypeExpression.new(type:) if LowType.type?(type)
+
       super
     end
   end
+
+  private
+
+  def define_with_type(referenced_object:)
+    def referenced_object.with_type=(value)
+      local_proxy = instance_variable_get('@local_proxy')
+      type_expression = local_proxy.type_expression
+      type_expression.validate!(value:, proxy: local_proxy)
+
+      # We can't reassign self in Ruby so we reassign instance variables instead.
+      value.instance_variables.each do |variable|
+        instance_variable_set(variable, value.instance_variable_get(variable))
+      end
+
+      self
+    end
+  end
 end

data/lib/low_type.rb

@@ -2,33 +2,19 @@
 
 require_relative 'adapters/adapter_loader'
 require_relative 'basic_types'
+require_relative 'instance_types'
 require_relative 'redefiner'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
+# Include this module into your class to define and check 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)
-
-    # Array[] class method returns a type expression only for the duration of this "included" hook.
+  def self.included(klass) # rubocop:disable Metrics/AbcSize
+    # Array[] and Hash[] class method returns a type expression only for the duration of this "included" hook.
     array_class_method = Array.method('[]').unbind
-    Array.define_singleton_method('[]') do |*types|
-      TypeExpression.new(type: [*types])
-    end
-
-    # Hash[] class method returns a type expression only for the duration of this "included" hook.
     hash_class_method = Hash.method('[]').unbind
-    Hash.define_singleton_method('[]') do |type|
-      # Support Pry which uses Hash[].
-      unless LowType.type?(type)
-        Hash.define_singleton_method('[]', hash_class_method)
-        result = Hash[type]
-        Hash.method('[]').unbind
-        return result
-      end
-
-      TypeExpression.new(type:)
-    end
+    LowType.redefine(hash_class_method:)
 
     class << klass
       def low_methods
@@ -37,15 +23,16 @@ module LowType
     end
 
     file_path = LowType.file_path(klass:)
-    parser = Parser.new(file_path:)
+    parser = LowType::Parser.new(file_path:)
     private_start_line = parser.private_start_line
 
-    klass.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.instance_methods, klass:, private_start_line:, file_path:)
-    klass.singleton_class.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.class_methods, klass:, private_start_line:, file_path:)
+    klass.extend InstanceTypes
+    klass.prepend LowType::Redefiner.redefine(method_nodes: parser.instance_methods, klass:, private_start_line:, file_path:)
+    klass.singleton_class.prepend LowType::Redefiner.redefine(method_nodes: parser.class_methods, klass:, private_start_line:, file_path:)
 
-    if (adapter = AdapterLoader.load(klass:, parser:, file_path:))
+    if (adapter = Adapter::Loader.load(klass:, parser:, file_path:))
       adapter.process
-      klass.prepend adapter.redefine
+      klass.prepend Adapter::Methods
     end
   ensure
     Array.define_singleton_method('[]', array_class_method)
@@ -63,12 +50,12 @@ module LowType
     def configure
       yield(config)
 
-      if config.local_types
-        require_relative 'local_types'
-        include LocalTypes
-      end
+      return unless config.local_types
+
+      require_relative 'local_types'
+      include LocalTypes
     end
-  
+
     # Internal API.
 
     def file_path(klass:)
@@ -78,9 +65,21 @@ module LowType
       caller.find { |callee| callee.end_with?("<class:#{class_name}>'") }.split(':').first
     end
 
-    # TODO: Unit test this.
+    # TODO: Unit test.
     def type?(type)
-      type.respond_to?(:new) || type == Integer || type == Symbol || (type.is_a?(::Hash) && type.keys.first.respond_to?(:new) && type.values.first.respond_to?(:new))
+      LowType.basic_type?(type:) || LowType.complex_type?(type:)
+    end
+
+    def basic_type?(type:)
+      type.respond_to?(:new) || type == Integer || type == Symbol
+    end
+
+    def complex_type?(type:)
+      !basic_type?(type:) && LowType.typed_hash?(type:)
+    end
+
+    def typed_hash?(type:)
+      type.is_a?(::Hash) && LowType.basic_type?(type: type.keys.first) && LowType.basic_type?(type: type.values.first)
     end
 
     def value?(expression)
@@ -90,5 +89,24 @@ module LowType
     def value(type:)
       TypeExpression.new(default_value: ValueExpression.new(value: type))
     end
+
+    # TODO: Unit test.
+    def redefine(hash_class_method:)
+      Array.define_singleton_method('[]') do |*types|
+        TypeExpression.new(type: [*types])
+      end
+
+      Hash.define_singleton_method('[]') do |type|
+        # Support Pry which uses Hash[].
+        unless LowType.type?(type)
+          Hash.define_singleton_method('[]', hash_class_method)
+          result = Hash[type]
+          Hash.method('[]').unbind
+          return result
+        end
+
+        TypeExpression.new(type:)
+      end
+    end
   end
 end

data/lib/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'prism'
 
 module LowType
@@ -25,23 +27,29 @@ module LowType
       block_visitor.method_calls
     end
 
-    # Only a lambda defined immediately after a method's parameters/block is considered a return type expression.
-    def self.return_type(method_node:)
-      # Method statements.
-      statements_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }
+    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
+        # 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.
+        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)
+        node = statements_node.body.first
+        return node if node.is_a?(Prism::LambdaNode)
 
-      nil
+        nil
+      end
+
+      def line_number(node:)
+        node.respond_to?(:start_line) ? node.start_line : nil
+      end
     end
   end
 
@@ -73,7 +81,7 @@ module LowType
     private
 
     def class_method?(node)
-      return true if node.is_a?(::Prism::DefNode) && node.receiver.class == Prism::SelfNode # self.method_name
+      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])

data/lib/proxies/file_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LowType
   class FileProxy
     attr_reader :path, :line, :scope

data/lib/proxies/local_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../interfaces/error_interface'
 require_relative '../error_types'
 

data/lib/proxies/method_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LowType
   class MethodProxy
     attr_reader :name, :params, :return_proxy

data/lib/proxies/param_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../interfaces/error_interface'
 require_relative '../error_types'
 
@@ -5,7 +7,7 @@ module LowType
   class ParamProxy < ErrorInterface
     attr_reader :type_expression, :name, :type, :position
 
-    def initialize(type_expression:, name:, type:, position: nil, file:)
+    def initialize(type_expression:, name:, type:, file:, position: nil)
       @type_expression = type_expression
       @name = name
       @type = type

data/lib/proxies/return_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../interfaces/error_interface'
 require_relative '../error_types'
 

data/lib/redefiner.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'factories/proxy_factory'
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/method_proxy'
 require_relative 'proxies/param_proxy'
-require_relative 'proxies/return_proxy'
-require_relative 'parser'
 require_relative 'type_expression'
 
 module LowType
+  # Redefine methods to have their arguments and return values type checked.
   class Redefiner
     class << self
-      def redefine_methods(method_nodes:, klass:, private_start_line:, file_path:)
+      def redefine(method_nodes:, klass:, private_start_line:, file_path:) # rubocop:disable Metrics
         Module.new do
           method_nodes.each do |method_node|
             name = method_node.name
-            line = method_node.respond_to?(:start_line) ? method_node.start_line : nil
+            line = Parser.line_number(node: method_node)
             file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{method_node.name}")
             params = Redefiner.params_with_type_expressions(method_node:, file:)
-            return_proxy = Redefiner.return_proxy(method_node:, file:)
+            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
 
             klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
 
@@ -23,7 +25,9 @@ module LowType
               klass.low_methods[name].params.each do |param_proxy|
                 # Get argument value or default value.
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
-                value = param_proxy.type_expression.default_value if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
+                if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
+                  value = param_proxy.type_expression.default_value
+                end
                 # Validate argument type.
                 param_proxy.type_expression.validate!(value:, proxy: param_proxy)
                 # Handle value(type) special case.
@@ -41,9 +45,7 @@ module LowType
               super(*args, **kwargs)
             end
 
-            if private_start_line && method_node.start_line > private_start_line
-              private name
-            end
+            private name if private_start_line && method_node.start_line > private_start_line
           end
         end
       end
@@ -52,50 +54,39 @@ module LowType
         return [] if method_node.parameters.nil?
 
         params = method_node.parameters.slice
-        proxy_method = eval("-> (#{params}) {}")
+        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
+        proxy_method = eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
         required_args, required_kwargs = required_args(proxy_method:)
 
-        typed_method = eval(
-          <<~RUBY
-            -> (#{params}) {
-              param_proxies = []
+        # 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)
+            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)
 
-                expression = binding.local_variable_get(name)
-
-                if expression.class == TypeExpression
-                  param_proxies << ParamProxy.new(type_expression: expression, name:, type:, position:, file:)
-                elsif ::LowType.type?(expression)
-                  param_proxies << ParamProxy.new(type_expression: TypeExpression.new(type: expression), name:, type:, position:, file:)
-                end
+              if expression.is_a?(TypeExpression)
+                param_proxies << ParamProxy.new(type_expression: expression, name:, type:, position:, file:)
+              elsif ::LowType.type?(expression)
+                param_proxies << ParamProxy.new(type_expression: TypeExpression.new(type: expression), name:, type:, position:, file:)
               end
+            end
 
-              param_proxies
-            }
-          RUBY
-        )
+            param_proxies
+          }
+        RUBY
 
-        # Called with only required args present (as nil) and optional args omitted, to evaluate type expressions (which are stored as default values).
-        typed_method.call(*required_args, **required_kwargs)
+        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (stored as 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 return_proxy(method_node:, file:)
-        return_type = Parser.return_type(method_node:)
-        return nil if return_type.nil?
-
-        expression = eval(return_type.slice).call
-        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(proxy_method:)

data/lib/type_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'proxies/param_proxy'
 
 module LowType
@@ -5,8 +7,9 @@ module LowType
   file_path = File.expand_path(__FILE__)
   adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
 
-  HIDDEN_PATHS = [file_path, *adapter_paths, File.join(root_path, 'redefiner.rb')]
+  HIDDEN_PATHS = [file_path, *adapter_paths, File.join(root_path, 'redefiner.rb')].freeze
 
+  # Represent types and default values as a series of chainable expressions.
   class TypeExpression
     attr_reader :types, :default_value
 
@@ -18,8 +21,8 @@ module LowType
     end
 
     def |(expression)
-      if expression.class == ::LowType::TypeExpression
-        @types = @types + expression.types
+      if expression.instance_of?(::LowType::TypeExpression)
+        @types += expression.types
         @default_value = expression.default_value
       elsif ::LowType.value?(expression)
         @default_value = expression
@@ -34,20 +37,17 @@ module LowType
       @default_value == :LOW_TYPE_UNDEFINED
     end
 
-    def validate!(value:, proxy:)
+    def validate!(value:, proxy:) # rubocop:disable Metrics
       if value.nil?
         return true if @default_value.nil?
         raise proxy.error_type, proxy.error_message(value:) if required?
       end
 
       @types.each do |type|
-        return true if LowType.type?(type) && type <= value.class # Example: HTML is a subclass of String and should pass as a String.
-        return true if ::Array === type && ::Array === value && array_types_match_values?(types: type, values: value)
-
-        # TODO: Shallow validation of hash could be made deeper with user config.
-        if type.class == ::Hash && value.class == ::Hash && type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
-          return true
-        end
+        # Example: HTML is a subclass of String and should pass as a String.
+        return true if LowType.basic_type?(type:) && type <= value.class
+        return true if type.is_a?(::Array) && value.is_a?(::Array) && array_types_match_values?(types: type, values: value)
+        return true if type.is_a?(::Hash) && value.is_a?(::Hash) && hash_types_match_values?(type:, value:)
       end
 
       raise proxy.error_type, proxy.error_message(value:)
@@ -57,7 +57,7 @@ module LowType
 
     def valid_types
       types = @types.map { |type| type.inspect.to_s }
-      types = types + ['nil'] if @default_value.nil?
+      types += ['nil'] if @default_value.nil?
       types.join(' | ')
     end
 
@@ -67,7 +67,8 @@ module LowType
       # [T, T, T]
       if types.length > 1
         types.each_with_index do |type, index|
-          return false unless type <= values[index].class # Example: HTML is a subclass of String and should pass as a String.
+          # Example: HTML is a subclass of String and should pass as a String.
+          return false unless type <= values[index].class
         end
       # [T]
       elsif types.length == 1
@@ -78,6 +79,11 @@ module LowType
       true
     end
 
+    def hash_types_match_values?(type:, value:)
+      # TODO: Shallow validation of hash could be made deeper with user config.
+      type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
+    end
+
     def backtrace_with_proxy(proxy:, backtrace:)
       # Remove LowType defined method file paths from the backtrace.
       filtered_backtrace = backtrace.reject { |line| HIDDEN_PATHS.find { |file_path| line.include?(file_path) } }
@@ -92,21 +98,21 @@ module LowType
   end
 end
 
+# For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
+# "|" is not defined on Object class and this is the most compute-efficient way to achieve our goal (world peace).
+# "|" is overridable by any child object. While we could def/undef this method, this approach is actually lighter.
+# "|" bitwise operator on Integer is not defined when the receiver is an Integer class, so we are not in conflict.
 class Object
   class << self
-    # For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
-    # "|" is not defined on Object class and this is the most compute-efficient way to achieve our goal (world peace).
-    # "|" is overridable by any child object. While we could def/undef this method, this approach is actually lighter.
-    # "|" bitwise operator on Integer is not defined when the receiver is an Integer class, so we are not in conflict.
     def |(expression)
-      if expression.class == ::LowType::TypeExpression
+      if expression.instance_of?(::LowType::TypeExpression)
         # We pass our type into their type expression.
         expression | self
         expression
       else
         # We turn our type into a type expression and pass in their [type_expression/type/value].
         type_expression = ::LowType::TypeExpression.new(type: self)
-        type_expression | expression        
+        type_expression | expression
       end
     end
   end

data/lib/value_expression.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# A value expression converts a type to a value in the eyes of LowType.
 class ValueExpression
   attr_reader :value
 

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.8.10
+  version: 0.9.0
 platform: ruby
 authors:
 - maedi
@@ -21,6 +21,8 @@ files:
 - lib/adapters/sinatra_adapter.rb
 - lib/basic_types.rb
 - lib/error_types.rb
+- lib/factories/proxy_factory.rb
+- lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
 - lib/local_types.rb