low_type 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5873e2b3ecceaa3a28a589739addeb22c0914c808b0e7edcfbad5b3194c8bc9
-  data.tar.gz: 6a5f1d91ee6307859d743fe0a0958c498d253ea2665aae10d966682019ed7e2b
+  metadata.gz: 98202b31e95d4d9d3e8199ef2a3c20ff2ff455b5267b453cc1eb8c15577dbe89
+  data.tar.gz: 02ede73b6243426beba35b1d03eb9cd0fe9421c8962b585ca7a07901b49fcdf9
 SHA512:
-  metadata.gz: 391d16f40bbaad2191ab9bbe1d98b3a2607af954c57b03d7000af5a94b232a2b43695a344846676725b571e122adce0ca68ee123a809633a4107adbc14aa49ab
-  data.tar.gz: 4bf9a082a30330a929b9190009da152755d45cb8e213203d206305f8a8fcd16fa19b9a893f40de05078cc73bc37809609b7bd9f2cdd1d5224ca1ebb079df9c13
+  metadata.gz: 7e94e2e1a1e69ac8a7f812d6e08ea9bc9fc75be4b7f69f735880ca2a8664fda2a02212a6b49331b035e518d6bbfa8519f2e2eb3926630003b5140885c381b6a0
+  data.tar.gz: 25dfb56ff048028002d9636288314d2fb95d247d2d2b59a8da1fee2aa8b65e46449cc905437e45213e188cdbb7e8fff646e767f69e7fbfbd40f234a79f52d92f

data/lib/adapters/adapter_loader.rb

@@ -0,0 +1,18 @@
+require_relative 'sinatra_adapter'
+
+module LowType
+  class AdapterLoader
+    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')
+
+        return if adaptor.nil?
+
+        adaptor
+      end
+    end
+  end
+end

data/lib/adapters/sinatra_adapter.rb

@@ -0,0 +1,100 @@
+require 'prism'
+
+require_relative 'sinatra_return_proxy'
+require_relative '../interfaces/adapter_interface'
+require_relative '../proxies/file_proxy'
+require_relative '../error_types'
+
+module LowType
+  # 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
+
+    def redefine_methods
+      method_calls = @parser.method_calls(method_names: [:get, :post, :patch, :put, :delete, :options, :query])
+
+      # Type check return values.
+      method_calls.each do |method_call|
+        arguments_node = method_call.compact_child_nodes.first
+        next unless arguments_node.is_a?(Prism::ArgumentsNode)
+
+        pattern = arguments_node.arguments.first.content
+
+        file = FileProxy.new(path: @file_path, line: method_call.start_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
+
+        route = "#{method_call.name.upcase} #{pattern}"
+        @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
+
+        # We're in Sinatra now. Objects request/response are from Sinatra.
+        @klass.after pattern do
+          if (method_proxy = self.class.low_methods["#{request.request_method} #{pattern}"])
+            proxy = method_proxy.return_proxy
+
+            # Inclusive rather than exclusive validation. If one type/value is valid then there's no need to error.
+            valid_type = proxy.type_expression.types.any? do |type|
+              proxy.type_expression.validate(value: SinatraAdapter.reconstruct_return_value(type:, response:), proxy:)
+            end
+
+            # No valid types so let's return a server error to the client.
+            unless valid_type
+              proxy.type_expression.types.each do |type|
+                value = SinatraAdapter.reconstruct_return_value(type:, response:)
+                unless proxy.type_expression.validate(value:, proxy:)
+                  status(500)
+                  body(proxy.error_message(value: value.inspect))
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # The route's String/Array/Enumerable return value populates a Rack::Response object.
+    # This response also contains values added via Sinatra DSL's header()/body() methods.
+    # So reconstruct the return value from the response object, based on the return type.
+    def self.reconstruct_return_value(type:, response:)
+      valid_types = {
+        Integer => -> (response) { response.status },
+        String => -> (response) { response.body.first },
+        HTML => -> (response) { response.body.first },
+        JSON => -> (response) { response.body.first },
+
+        # TODO: Should these be Enumerable[T] instead? How would we match a Module of a class in a hash key?
+        # NOTE: These keys represent types, not type expressions.
+        #       A type lives inside a type expression and is actually an instance representing that type.
+        [String] => -> (response) { response.body },
+        [Integer, String] => -> (response) { [response.status, *response.body] },
+        [Integer, Hash, String] => -> (response) { [response.status, response.headers, *response.body] },
+      }
+
+      raise AllowedTypeError, 'Did you mean "Response.finish"?' if type.to_s == 'Response'
+
+      if (reconstructed_value = valid_types[type])
+        return reconstructed_value.call(response)
+      else
+        raise AllowedTypeError, "Valid Sinatra return types: #{valid_types.keys.map(&:to_s).join(' | ')}"
+      end
+    end
+
+    private
+
+    def return_proxy(method_node:, pattern:, 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 TypeExpression === expression
+
+      SinatraReturnProxy.new(type_expression: expression, name: "#{method_node.name.upcase} #{pattern}", file:)
+    end
+  end
+end

data/lib/basic_types.rb

@@ -0,0 +1,5 @@
+module LowType
+  class Boolean; end # TrueClass or FalseClass
+  class HTML < String; end
+  class JSON < String; end
+end

data/lib/error_types.rb

@@ -2,4 +2,5 @@ module LowType
   class ArgumentTypeError < TypeError; end;
   class LocalTypeError < TypeError; end;
   class ReturnTypeError < TypeError; end;
+  class AllowedTypeError < TypeError; end;
 end

data/lib/interfaces/adapter_interface.rb

@@ -0,0 +1,7 @@
+module LowType
+  class AdapterInterface
+    def redefine_methods
+      raise NotImplementedError
+    end
+  end
+end

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

@@ -3,24 +3,24 @@ require_relative 'proxies/local_proxy'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
-module TypeAssignment
+module LocalTypes
   class AssignmentError < StandardError; end
 
   def type(type_expression)
-    object = type_expression.default_value
+    referenced_object = type_expression.default_value
 
-    if !LowType.value?(object)
-      raise AssignmentError, "Single-instance objects like #{object} are not supported"
+    if !LowType.value?(referenced_object)
+      raise AssignmentError, "Single-instance objects like #{referenced_object} are not supported"
     end
 
     last_caller = caller_locations(1, 1).first
     file = LowType::FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
     local_proxy = LowType::LocalProxy.new(type_expression:, name: self, file:)
-    object.instance_variable_set('@local_proxy', local_proxy)
+    referenced_object.instance_variable_set('@local_proxy', local_proxy)
 
-    type_expression.validate!(value: object, proxy: local_proxy)
+    type_expression.validate!(value: referenced_object, proxy: local_proxy)
 
-    def object.with_type=(value)
+    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)
@@ -33,9 +33,9 @@ module TypeAssignment
       self
     end
 
-    return object.value if object.is_a?(ValueExpression)
+    return referenced_object.value if referenced_object.is_a?(ValueExpression)
 
-    object
+    referenced_object
   end
   alias_method :low_type, :type
 
@@ -43,19 +43,22 @@ module TypeAssignment
     LowType.value(type:)
   end
   alias_method :low_value, :value
-end
 
-module LowType
+  # Scoped to the class that includes LowTypes module.
   class Array < ::Array
-    def self.[](type)
-      return TypeExpression.new(type: [type]) if LowType.type?(type)
+    def self.[](*types)
+      if types.all? { |type| LowType.type?(type) }
+        return LowType::TypeExpression.new(type: [*types])
+      end
+
       super
     end
   end
 
+  # Scoped to the class that includes LowTypes module.
   class Hash < ::Hash
     def self.[](type)
-      return TypeExpression.new(type:) if LowType.type?(type)
+      return LowType::TypeExpression.new(type:) if LowType.type?(type)
       super
     end
   end

data/lib/low_type.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'adapters/adapter_loader'
+require_relative 'basic_types'
 require_relative 'redefiner'
 require_relative 'type_expression'
 require_relative 'value_expression'
@@ -10,22 +12,22 @@ module LowType
 
     # Array[] 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 |expression|
-      TypeExpression.new(type: [(expression)])
+    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 |expression|
+    Hash.define_singleton_method('[]') do |type|
       # Support Pry which uses Hash[].
-      unless LowType.type?(expression)
+      unless LowType.type?(type)
         Hash.define_singleton_method('[]', hash_class_method)
-        result = Hash[expression]
+        result = Hash[type]
         Hash.method('[]').unbind
         return result
       end
 
-      TypeExpression.new(type: expression)
+      TypeExpression.new(type:)
     end
 
     class << klass
@@ -40,6 +42,9 @@ module LowType
 
     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:)
+
+    adapter = AdapterLoader.load(klass:, parser:, file_path:)
+    adapter.redefine_methods if adapter
   ensure
     Array.define_singleton_method('[]', array_class_method)
     Hash.define_singleton_method('[]', hash_class_method)
@@ -49,27 +54,31 @@ module LowType
     # Public API.
 
     def config
-      config = Struct.new(:type_assignment, :deep_type_check)
+      config = Struct.new(:local_types, :deep_type_check)
       @config ||= config.new(false, false)
     end
 
     def configure
       yield(config)
 
-      if config.type_assignment
-        require_relative 'type_assignment'
-        include TypeAssignment
+      if config.local_types
+        require_relative 'local_types'
+        include LocalTypes
       end
     end
   
     # Internal API.
 
     def file_path(klass:)
-      caller.find { |callee| callee.end_with?("<class:#{klass}>'") }.split(':').first
+      # Remove module namespaces from class.
+      class_name = klass.to_s.split(':').last
+      # The first class found regardless of namespace will be the class that did the include.
+      caller.find { |callee| callee.end_with?("<class:#{class_name}>'") }.split(':').first
     end
 
+    # TODO: Unit test this.
     def type?(type)
-      type.respond_to?(:new) || type == Integer || (type.is_a?(::Hash) && type.keys.first.respond_to?(:new) && type.values.first.respond_to?(:new))
+      type.respond_to?(:new) || type == Integer || type == Symbol || (type.is_a?(::Hash) && type.keys.first.respond_to?(:new) && type.values.first.respond_to?(:new))
     end
 
     def value?(expression)
@@ -80,6 +89,4 @@ module LowType
       TypeExpression.new(default_value: ValueExpression.new(value: type))
     end
   end
-
-  class Boolean; end # TrueClass or FalseClass
 end

data/lib/parser.rb

@@ -5,23 +5,37 @@ module LowType
     attr_reader :parent_map, :instance_methods, :class_methods, :private_start_line
 
     def initialize(file_path:)
-      root_node = Prism.parse_file(file_path).value
+      @root_node = Prism.parse_file(file_path).value
 
       parent_mapper = ParentMapper.new
-      parent_mapper.visit(root_node)
+      parent_mapper.visit(@root_node)
       @parent_map = parent_mapper.parent_map
 
-      method_visitor = MethodVisitor.new(@parent_map)
-      root_node.accept(method_visitor)
+      method_visitor = MethodDefVisitor.new(@parent_map)
+      @root_node.accept(method_visitor)
 
       @instance_methods = method_visitor.instance_methods
       @class_methods = method_visitor.class_methods
       @private_start_line = method_visitor.private_start_line
     end
 
-    def self.return_node(method_node:)
-      # Only a lambda defined immediately after a method's parameters is considered a return type expression.
+    def method_calls(method_names:)
+      block_visitor = MethodCallVisitor.new(parent_map: @parent_map, method_names:)
+      @root_node.accept(block_visitor)
+      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) }
+
+      # Block statements.
+      if statements_node.nil?
+        block_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::BlockNode) }
+        statements_node = block_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) } if block_node
+      end
+
       return nil if statements_node.nil? # Sometimes developers define methods without code inside them.
 
       node = statements_node.body.first
@@ -31,7 +45,7 @@ module LowType
     end
   end
 
-  class MethodVisitor < Prism::Visitor
+  class MethodDefVisitor < Prism::Visitor
     attr_reader :class_methods, :instance_methods, :private_start_line
 
     def initialize(parent_map)
@@ -70,6 +84,23 @@ module LowType
     end
   end
 
+  class MethodCallVisitor < Prism::Visitor
+    attr_reader :method_calls
+
+    def initialize(parent_map:, method_names:)
+      @parent_map = parent_map
+      @method_names = method_names
+
+      @method_calls = []
+    end
+
+    def visit_call_node(node)
+      @method_calls << node if @method_names.include?(node.name)
+
+      super # Continue walking the tree.
+    end
+  end
+
   class ParentMapper < Prism::Visitor
     attr_reader :parent_map
 

data/lib/redefiner.rb

@@ -79,7 +79,7 @@ module LowType
           RUBY
         )
 
-        # Call method with only its required args to evaluate type expressions (which are stored as default values).
+        # 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)
 
       # TODO: Write spec for this.
@@ -88,10 +88,10 @@ module LowType
       end
 
       def return_proxy(method_node:, file:)
-        return_node = Parser.return_node(method_node:)
-        return nil if return_node.nil?
+        return_type = Parser.return_type(method_node:)
+        return nil if return_type.nil?
 
-        expression = eval(return_node.slice).call
+        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:)

data/lib/type_expression.rb

@@ -29,6 +29,26 @@ module LowType
       @default_value == :LOW_TYPE_UNDEFINED
     end
 
+    # Called in situations where we want to be inclusive rather than exclusive and pass validation if one of the types is valid.
+    def validate(value:, proxy:)
+      if value.nil?
+        return true if @default_value.nil?
+        return false 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.
+
+        # TODO: Shallow validation of enumerables could be made deeper with user config.
+        return true if type.class == ::Array && value.class == ::Array && type.first == value.first.class
+        if type.class == ::Hash && value.class == ::Hash && type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
+          return true
+        end
+      end
+
+      false
+    end
+
     def validate!(value:, proxy:)
       if value.nil?
         return true if @default_value.nil?
@@ -37,8 +57,9 @@ module LowType
 
       @types.each do |type|
         return true if LowType.type?(type) && type == value.class 
-        # TODO: Shallow validation of enumerables could be made deeper with user config.
-        return true if type.class == ::Array && value.class == ::Array && type.first == value.first.class
+        return true if type.class == ::Array && value.class == ::Array && 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
@@ -50,6 +71,23 @@ module LowType
       raise proxy.error_type, e.message, backtrace_with_proxy(file_paths:, backtrace: e.backtrace, proxy:)
     end
 
+    def valid_types
+      types = @types.map { |type| type.inspect.to_s }
+      types = types + ['nil'] if @default_value.nil?
+      types.join(' | ')
+    end
+
+    private
+
+    def array_types_match_values?(types:, values:)
+      # TODO: Probably better to use an each that breaks early when types run out.
+      types.zip(values) do |type, value|
+        return false unless type === value
+      end
+
+      true
+    end
+
     def backtrace_with_proxy(file_paths:, proxy:, backtrace:)
       # Remove LowType file paths from the backtrace.
       filtered_backtrace = backtrace.reject { |line| file_paths.find { |file_path| line.include?(file_path) } }
@@ -61,13 +99,6 @@ module LowType
 
       [proxy_file_backtrace, *filtered_backtrace]
     end
-
-    def valid_types
-      types = @types.map { |type| type.inspect.to_s }
-      types = types + ['nil'] if @default_value.nil?
-
-      types.join(' | ')
-    end
   end
 end
 

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.0
 platform: ruby
 authors:
 - maedi
@@ -17,8 +17,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/adapters/adapter_loader.rb
+- lib/adapters/sinatra_adapter.rb
+- lib/basic_types.rb
 - lib/error_types.rb
+- lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
+- lib/local_types.rb
 - lib/low_type.rb
 - lib/parser.rb
 - lib/proxies/file_proxy.rb
@@ -27,7 +32,6 @@ files:
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/redefiner.rb
-- lib/type_assignment.rb
 - lib/type_expression.rb
 - lib/value_expression.rb
 - lib/version.rb