low_type 0.8.6 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef26c686d314eec78cc49419d8f13d502d0a167f5b059961805754d38fd79a78
-  data.tar.gz: df781758ab9e3bb9a5d9a7c2119cd6dd3d080ec2cc123cf78aa9a90b75b660fd
+  metadata.gz: b542b5e282a1c49db5ff50843ca16eae7ad0a6f50c143dd2568b4eed77b951ce
+  data.tar.gz: deeb4c06c3e78041eefd69ddb0ab16c5317c2b4ec28306092cbd0a608d6b862b
 SHA512:
-  metadata.gz: 941cd854ce780919c11335896b727eb8e4084e42d4c75ca2c4e563507d1ba7c2a580c19e8056e2cb45c093b76387921df1eeba71f82e4a176e57478d73c492e2
-  data.tar.gz: d47aa4998fd2154703359e382564321ad4dcd1cf6107990d5a7ec5b18634e8b1440d77fab5e0b165bfd6640ac114a771ed5e9a7dadcac284cc6941a43aaf0de4
+  metadata.gz: 7518519f80e3ba2edc2cd114a6fef9676e3866ac6c5032f983867cd8ab70a62de7e20113ed076c223e027c517654bd3538187eebd88a11964f46d8bdced623f0
+  data.tar.gz: d6fee3d4fd5a7135e91eeafe090ed844fbde9bfb5b495e1022352910544f76d0c5074d2c7cb04657d18d421b50977b0194cd7a6f546bb4dbec37c8483023c849

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,57 +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:)
-                  status(500)
-                  body(proxy.error_message(value: value.inspect))
-                  break
-                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 },
-
-        # 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(' | ')}"
+          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
 
@@ -98,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/type_expression.rb

@@ -7,6 +7,7 @@ module LowType
     attr_reader :types, :default_value
 
     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
@@ -83,7 +84,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

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.8
 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