low_type 0.8.7 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94ec8cf1ae80a7540248e9a0a97e2e9bbc99fb81724f9a89e3d35de0ccd3dfaa
-  data.tar.gz: f1bf339671b5d17ec247814a08ea665aca64df51f404f625dff5d6bf77cf7c2e
+  metadata.gz: 65c0e662bfe788a1132c9ecf802392285089139cc2d721427a7285d62b87e606
+  data.tar.gz: da9f514df1428147990f55e7bc68a343dff87ce3df86d2e7913414ac97c80e15
 SHA512:
-  metadata.gz: 7a6ff0fa4038f53cd1650f27e7523ec2e0c0ac75c66190d62d976dbaded7887c2dc1900cb514709255af87f1c01545eb7c0748c100cd8133ea947c3d03f0c785
-  data.tar.gz: 141e666816a66e0446b0d9559d288dc24b7e838c200537fbfd5b18297533f8812517e37e29d3bcf7388efbef82fffb1aa90a6407037c4803db8bc6a1b26645f8
+  metadata.gz: 323ed1e9adfe8a07e0e8b6e2ed6fba157caac080611827f32453816db5b0c40cb7631e99c9a004391e1565f05d4ad26f8e1a9ed7b710a13846bf37da1b4290e6
+  data.tar.gz: 7b85c07ee7cfe34c2c004a4c62381627d8f258236d891295a073dd9e4c2b304c35ccba6ef6521faf9e1da52558a8610862fb73ca76e184cbf4c19ea362fcc730

data/lib/adapters/sinatra_adapter.rb

@@ -1,8 +1,8 @@
 require 'prism'
 
-require_relative 'sinatra_return_proxy'
 require_relative '../interfaces/adapter_interface'
 require_relative '../proxies/file_proxy'
+require_relative '../proxies/return_proxy'
 require_relative '../error_types'
 
 module LowType
@@ -17,7 +17,7 @@ module LowType
       @file_path = file_path
     end
 
-    def redefine_methods
+    def process
       method_calls = @parser.method_calls(method_names: [:get, :post, :patch, :put, :delete, :options, :query])
 
       # Type check return values.
@@ -35,54 +35,35 @@ module LowType
 
         route = "#{method_call.name.upcase} #{pattern}"
         @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
+      end
+    end
 
-        # 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
+    def redefine
+      Module.new do
+        def invoke(&block)
+          res = catch(:halt, &block)
 
-            # 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
+          raise AllowedTypeError, 'Did you mean "Response.finish"?' if res.to_s == 'Response'
 
-            # 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:)
-                  halt 500, {}, proxy.error_message(value: value.inspect)
-                end
-              end
+          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
-        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 },
-
-        [String] => -> (response) { response.body }, # Body is stored internally as an array.
-        [Integer, String] => -> (response) { [response.status, response.body.first] },
-        [Integer, Hash, String] => -> (response) { [response.status, response.headers, response.body.first] },
-
-        # TODO: Represent Enumerable[T]. How would we match a Module of a class in a hash key?
-      }
-
-      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(' | ')}"
+          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
       end
     end
 
@@ -95,7 +76,7 @@ module LowType
       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:)
+      ReturnProxy.new(type_expression: expression, name: "#{method_node.name.upcase} #{pattern}", file:)
     end
   end
 end

data/lib/basic_types.rb

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

data/lib/interfaces/adapter_interface.rb

@@ -1,6 +1,6 @@
 module LowType
   class AdapterInterface
-    def redefine_methods
+    def process
       raise NotImplementedError
     end
   end

data/lib/low_type.rb

@@ -43,8 +43,10 @@ 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
+    if (adapter = AdapterLoader.load(klass:, parser:, file_path:))
+      adapter.process
+      klass.prepend adapter.redefine
+    end
   ensure
     Array.define_singleton_method('[]', array_class_method)
     Hash.define_singleton_method('[]', hash_class_method)

data/lib/redefiner.rb

@@ -7,8 +7,6 @@ require_relative 'type_expression'
 
 module LowType
   class Redefiner
-    FILE_PATH = File.expand_path(__FILE__)
-
     class << self
       def redefine_methods(method_nodes:, klass:, private_start_line:, file_path:)
         Module.new do

data/lib/type_expression.rb

@@ -1,13 +1,17 @@
 require_relative 'proxies/param_proxy'
 
 module LowType
-  class TypeExpression
-    FILE_PATH = File.expand_path(__FILE__)
+  root_path = File.expand_path(__dir__)
+  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')]
 
+  class TypeExpression
     attr_reader :types, :default_value
 
+    # @param type - A literal type or an instance representation of a typed structure.
     def initialize(type: nil, default_value: :LOW_TYPE_UNDEFINED)
-      # Types can be instance representations of a structure.
       @types = []
       @types << type unless type.nil?
       @default_value = default_value
@@ -30,26 +34,6 @@ 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.
-        return true if ::Array === type && ::Array === value && array_types_match_values?(types: type, values: value)
-
-        # TODO: Shallow validation of enumerables 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
-      end
-
-      false
-    end
-
     def validate!(value:, proxy:)
       if value.nil?
         return true if @default_value.nil?
@@ -68,8 +52,7 @@ module LowType
 
       raise proxy.error_type, proxy.error_message(value:)
     rescue proxy.error_type => e
-      file_paths = [FILE_PATH, LowType::Redefiner::FILE_PATH]
-      raise proxy.error_type, e.message, backtrace_with_proxy(file_paths:, backtrace: e.backtrace, proxy:)
+      raise proxy.error_type, e.message, backtrace_with_proxy(backtrace: e.backtrace, proxy:)
     end
 
     def valid_types
@@ -84,7 +67,7 @@ module LowType
       # [T, T, T]
       if types.length > 1
         types.each_with_index do |type, index|
-          return false unless type === values[index]
+          return false unless type <= values[index].class # Example: HTML is a subclass of String and should pass as a String.
         end
       # [T]
       elsif types.length == 1
@@ -95,9 +78,9 @@ module LowType
       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) } }
+    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) } }
 
       # Add the proxied file to the backtrace.
       proxy_file_backtrace = "#{proxy.file.path}:#{proxy.file.line}:in '#{proxy.file.scope}'"

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.8.9
 platform: ruby
 authors:
 - maedi
@@ -19,7 +19,6 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
-- lib/adapters/sinatra_return_proxy.rb
 - lib/basic_types.rb
 - lib/error_types.rb
 - lib/interfaces/adapter_interface.rb

data/lib/adapters/sinatra_return_proxy.rb

@@ -1,18 +0,0 @@
-require_relative '../proxies/return_proxy'
-
-module LowType
-  class SinatraReturnProxy < ReturnProxy
-    attr_reader :type_expression, :name
-
-    def initialize(type_expression:, name:, file:)
-      @type_expression = type_expression
-      @name = name
-      @file = file
-    end
-
-    def error_message(value:)
-      value = value[0...20] if value
-      "Invalid return value '#{value}' for method '#{@name}'. Valid types: '#{@type_expression.valid_types}'"
-    end
-  end
-end