syntropy 0.36.0 → 0.38.0

data/lib/syntropy/routing_tree.rb

@@ -339,8 +339,8 @@ module Syntropy
           target: { kind:, fn: },
           # In case we're at the tree root, we need to copy over the hook and
           # error refs.
-          hook: !parent[:parent] && parent[:hook],
-          error: !parent[:parent] && parent[:error]
+          hook: parent[:hook],
+          error: parent[:error]
         }
       end
       nil
@@ -458,9 +458,9 @@ module Syntropy
         emit_router_proc_prelude(buffer)
         segment_idx = 1
         if @root[:path] != '/'
-          root_parts = @root[:path].split('/')
-          segment_idx = root_parts.size
-          emit_root_validate_guard(buffer:, root_parts:)
+          root_segments = @root[:path].split('/')
+          segment_idx = root_segments.size
+          emit_root_validate_guard(buffer:, root_segments:)
         end
 
         visit_routing_tree_entry(buffer:, entry: @root, segment_idx:)
@@ -492,18 +492,18 @@ module Syntropy
     def emit_router_proc_prelude(buffer)
       emit_code_line(buffer, '->(path, params) {')
       emit_code_line(buffer, '  entry = @static_map[path]; return entry if entry')
-      emit_code_line(buffer, '  parts = path.split("/")')
+      emit_code_line(buffer, '  segments = path.split("/")')
     end
 
     # Emits root path validation guard code.
     #
     # @param buffer [String] output buffer
-    # @param root_parts [Array<String>] root path parts
+    # @param root_segments [Array<String>] root path segments
     # @return [void]
-    def emit_root_validate_guard(buffer:, root_parts:)
+    def emit_root_validate_guard(buffer:, root_segments:)
       validate_parts = []
-      (1...root_parts.size).each do |i|
-        validate_parts << "(parts[#{i}] != #{root_parts[i].inspect})"
+      (1...root_segments.size).each do |i|
+        validate_parts << "(segments[#{i}] != #{root_segments[i].inspect})"
       end
       emit_code_line(buffer, "  return nil if #{validate_parts.join(' || ')}")
     end
@@ -568,7 +568,7 @@ module Syntropy
 
       # Get next segment
       if !case_buffer.empty?
-        emit_code_line(buffer, "#{ws}case (p = parts[#{segment_idx}])")
+        emit_code_line(buffer, "#{ws}case (s = segments[#{segment_idx}])")
         buffer << case_buffer
         emit_code_line(buffer, "#{ws}end")
       end
@@ -630,7 +630,7 @@ module Syntropy
           next if child_entry[:static]
 
           emit_code_line(buffer, "#{ws}when #{k.inspect}")
-          if_clause = child_entry[:handle_subtree] ? '' : " if !parts[#{segment_idx + 1}]"
+          if_clause = child_entry[:handle_subtree] ? '' : " if !segments[#{segment_idx + 1}]"
 
           child_path = child_entry[:path]
           route_value = "@dynamic_map[#{child_path.inspect}]"
@@ -657,12 +657,12 @@ module Syntropy
       # parametric route
       if param_entry
         if when_count == 0
-          emit_code_line(buffer, "#{ws}when p")
+          emit_code_line(buffer, "#{ws}when s")
         else
           emit_code_line(buffer, "#{ws}else")
         end
 
-        emit_code_line(buffer, "#{ws}  params[#{param_entry[:param].inspect}] = p")
+        emit_code_line(buffer, "#{ws}  params[#{param_entry[:param].inspect}] = s")
         visit_routing_tree_entry(buffer:, entry: param_entry, indent: indent + 1, segment_idx: segment_idx + 1)
       # wildcard route
       elsif entry[:handle_subtree]

data/lib/syntropy/storage/schema.rb

@@ -81,10 +81,10 @@ module Syntropy
       end
 
       def set_schema_version(db, version)
-        db.execute <<~SQL, v: version
+        db.execute <<~SQL, version
           insert into __syntropy_schema__ (k, v)
-          values ('version', :v)
-          on conflict(k) do update set v = :v
+          values ('version', $1)
+          on conflict(k) do update set v = $1
         SQL
       end
     end

data/lib/syntropy/test.rb

@@ -11,12 +11,9 @@ module Syntropy
   class Test < Minitest::Test
     HTTP = Syntropy::HTTP
 
-    # Sets the app environment for all Syntropy tests.
-    #
-    # @param env [Hash] app environment hash
-    # @return [void]
-    def self.env=(env)
-      @@env = env
+    class << self
+      # Gets/sets app environment for tests
+      attr_accessor :env
     end
 
     attr_reader :machine, :app
@@ -25,7 +22,7 @@ module Syntropy
     #
     # @return [Hash] test app environment
     def env
-      @@env
+      self.class.env
     end
 
     # Loads and returns a module with the given reference.
@@ -101,17 +98,38 @@ module Syntropy
       post(path, 'application/x-www-form-urlencoded', URI.encode_www_form(data), **)
     end
 
+    # Makes an HTTP PATCH request to the test app.
+    #
+    # @param path [String] request path
+    # @param content_type [String, nil] content MIME type
+    # @param body [String] request body
+    # @param headers [Hash] request headers
+    # @return [Syntropy::Request]
+    def patch(path, content_type, body, **headers)
+      headers = headers.merge('content-type' => content_type) if content_type
+      http_request(
+        headers.merge(
+          {
+            ':method' => 'PATCH',
+            ':path'   => path
+          }
+        ),
+        body
+      )
+    end
+
     # Sets up a test instance.
     #
     # @return [void]
     def setup
-      raise 'Environment not set' if !@@env
+      env = self.class.env
+      raise 'Environment not set' if !env
 
-      Syntropy.load_config(@@env)
+      Syntropy.load_config(env)
 
       @machine = UM.new
       @app = Syntropy::App.new(
-        **@@env.merge(
+        **env.merge(
           machine: @machine,
           test_mode: true
         )
@@ -119,7 +137,7 @@ module Syntropy
       @test_harness = Syntropy::TestHarness.new(@app)
 
       @db = load_module('/_lib/storage', raise_on_missing: false)
-      @db&.migrate!
+      @db&.migrate! if @db.respond_to?(:migrate!)
     end
 
     # Cleans up a test instance.

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.36.0'
+  VERSION = '0.38.0'
 end

data/lib/syntropy.rb

@@ -17,15 +17,12 @@ require 'syntropy/papercraft_extensions'
 require 'syntropy/routing_tree'
 require 'syntropy/json_api'
 require 'syntropy/side_run'
-require 'syntropy/utils'
 require 'syntropy/version'
 
 # Syntropy is a web framework for building web apps in Ruby. Syntropy uses
 # UringMachine for I/O and concurrency, and provides a comprehensive and
 # flexible solution for writing web apps with minimal boilerplate.
 module Syntropy
-  extend Utilities
-
   class << self
     attr_accessor :machine, :dev_mode, :test_mode
 
@@ -83,9 +80,9 @@ module Syntropy
         logger: nil
       )
       loader = ModuleLoader.new(loader_env)
-      config = loader.load(env[:mode])
-
-      env[:config] = config
+      if (config = loader.load(env[:mode], raise_on_missing: false))
+        env[:config] = config
+      end
     end
 
     private

data/test/bm_router_proc.rb

@@ -138,8 +138,8 @@ def make_tmp_file_tree(dir, spec)
   dir
 end
 
-app_root = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
-make_tmp_file_tree(app_root, {
+$app_root = "/tmp/#{__FILE__.gsub('/', '-')}-#{SecureRandom.hex}"
+make_tmp_file_tree($app_root, {
   'index.rb': "export ->(req) { req.redirect('/hello') }",
   'hello': {
     'index.rb': "export ->(req) { req.respond('Hello!', 'Content-Type' => 'text/html') }",
@@ -147,13 +147,13 @@ make_tmp_file_tree(app_root, {
   }
 })
 
-machine = UM.new
-syntropy_app = Syntropy::App.new(
-  app_root: app_root,
-  mount_path: '/',
-  machine: machine
-)
-proc = ->(req) { syntropy_app.(req) }
+# machine = UM.new
+# syntropy_app = Syntropy::App.new(
+#   app_root: app_root,
+#   mount_path: '/',
+#   machine: machine
+# )
+# proc = ->(req) { syntropy_app.(req) }
 
 module ::Kernel
   def mock_req(headers, body = nil)
@@ -161,11 +161,11 @@ module ::Kernel
   end
 end
 
-puts '*' * 40
+# puts '*' * 40
 
-req = mock_req(':method' => 'GET', ':path' => '/hello/world')
-proc.(req)
-p [req.response_status, req.response_headers, req.response_body]
+# req = mock_req(':method' => 'GET', ':path' => '/hello/world')
+# proc.(req)
+# p [req.response_status, req.response_headers, req.response_body]
 
 ################################################################################
 
@@ -185,9 +185,8 @@ BM.run do
     def setup
       machine = UM.new
       syntropy_app = Syntropy::App.new(
-        app_root: app_root,
+        app_root: $app_root,
         mount_path: '/',
-        # watch_files: 0.05,
         machine: machine
       )
       @app = ->(req) { syntropy_app.(req) }

data/test/fixtures/app/_lib/klass.rb

@@ -12,4 +12,4 @@ class Klass
   end
 end
 
-export Klass
+export Klass.new(@env)

data/test/fixtures/app/api+.rb

@@ -21,4 +21,4 @@ class API < Syntropy::JSONAPI
   end
 end
 
-export API
+export API.new(@env)

data/test/fixtures/app/bad_mod_arity.rb

@@ -0,0 +1,3 @@
+export ->(req, blah) {
+  req.respond('foobar')
+}

data/test/fixtures/app/by_method.rb

@@ -1,4 +1,4 @@
-export http_methods
+export dispatch_by_http_method
 
 def get(req)
   req.respond('foo')

data/test/fixtures/app/post_ct.rb

@@ -1,4 +1,4 @@
-export http_methods
+export dispatch_by_http_method
 
 def post(req)
   req.respond("#{req.content_type}:#{req.read}")

data/test/fixtures/app_errors/_error.rb

@@ -0,0 +1,3 @@
+export ->(req, error) {
+  req.respond("root: #{error.message}", ':status' => Error.http_status(error))
+}

data/test/fixtures/app_errors/foo/_error.rb

@@ -0,0 +1,3 @@
+export ->(req, error) {
+  req.respond("foo: #{error.message}", ':status' => Error.http_status(error))
+}

data/test/fixtures/app_errors/foo/bar/_error.rb

@@ -0,0 +1,3 @@
+export ->(req, error) {
+  req.respond("bar: #{error.message}", ':status' => Error.http_status(error))
+}

data/test/fixtures/app_errors/foo/bar/baz/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  raise Error.teapot('baz')
+}

data/test/fixtures/app_errors/foo/bar/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  raise Error.teapot('bar')
+}

data/test/fixtures/app_errors/foo/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  raise Error.teapot('foo')
+}

data/test/fixtures/app_errors/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  raise Error.teapot('root')
+}

data/test/fixtures/app_hooks/_hook.rb

@@ -0,0 +1,4 @@
+export ->(req, app) {
+  (req.ctx[:hooks] ||= []) << :root
+  app.(req)
+}

data/test/fixtures/app_hooks/foo/_hook.rb

@@ -0,0 +1,4 @@
+export ->(req, app) {
+  (req.ctx[:hooks] ||= []) << :foo
+  app.(req)
+}

data/test/fixtures/app_hooks/foo/bar/_hook.rb

@@ -0,0 +1,4 @@
+export ->(req, app) {
+  (req.ctx[:hooks] ||= []) << :bar
+  app.(req)
+}

data/test/fixtures/app_hooks/foo/bar/baz/_hook.rb

@@ -0,0 +1,4 @@
+export ->(req, app) {
+  (req.ctx[:hooks] ||= []) << :baz
+  app.(req)
+}

data/test/fixtures/app_hooks/foo/bar/baz/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond("baz: #{req.ctx[:hooks].join(' ')}")
+}

data/test/fixtures/app_hooks/foo/bar/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond("bar: #{req.ctx[:hooks].join(' ')}")
+}

data/test/fixtures/app_hooks/foo/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond("foo: #{req.ctx[:hooks].join(' ')}")
+}

data/test/fixtures/app_hooks/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond("root: #{req.ctx[:hooks].join(' ')}")
+}

data/test/fixtures/app_multi_site/_site.rb

@@ -1 +1 @@
-export Syntropy.route_by_host(@env)
+export dispatch_by_host('.')

data/test/fixtures/controllers/by_host/bar.com/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond('bar')
+}

data/test/fixtures/controllers/by_host/foo.com/index.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond('foo')
+}

data/test/fixtures/controllers/by_host_dir.rb

@@ -0,0 +1 @@
+export dispatch_by_host('by_host')

data/test/fixtures/controllers/by_host_dir_map.rb

@@ -0,0 +1,4 @@
+export dispatch_by_host('by_host', {
+  'foofoo' => 'by_host/foo.com',
+  'barbar' => 'by_host/bar.com'
+})

data/test/fixtures/controllers/by_host_map.rb

@@ -0,0 +1,4 @@
+export dispatch_by_host(nil, {
+  'foofoo' => 'by_host/foo.com',
+  'barbar' => 'by_host/bar.com'
+})

data/test/fixtures/controllers/by_http_method.rb

@@ -0,0 +1,9 @@
+export dispatch_by_http_method
+
+def get(req)
+  req.respond('get')
+end
+
+def post(req)
+  req.respond('post')
+end

data/test/test_app.rb

@@ -119,6 +119,11 @@ class AppTest < Minitest::Test
     }
     assert_equal HTTP::INTERNAL_SERVER_ERROR, req.response_status
 
+    req = @test_harness.no_raise_internal_server_error {
+      @test_harness.request(':method' => 'GET', ':path' => '/test/bad_mod_arity')
+    }
+    assert_equal HTTP::INTERNAL_SERVER_ERROR, req.response_status
+
     req = @test_harness.request(':method' => 'GET', ':path' => '/test/.well-known/foo')
     assert_equal HTTP::OK, req.response_status
     assert_equal 'foo', req.response_body
@@ -183,6 +188,86 @@ class AppTest < Minitest::Test
   end
 end
 
+class MiddlewareHooksTest < Minitest::Test
+  HTTP = Syntropy::HTTP
+
+  APP_ROOT = File.join(__dir__, 'fixtures/app_hooks')
+
+  def setup
+    @machine = UM.new
+
+    @tmp_path = '/test/tmp'
+    @tmp_fn = File.join(APP_ROOT, 'tmp.rb')
+
+    @app = Syntropy::App.new(
+      app_root: APP_ROOT,
+      mount_path: '/',
+      watch_files: 0.05,
+      machine: @machine
+    )
+
+    @test_harness = Syntropy::TestHarness.new(@app)
+  end
+
+  def test_middleware_composition
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'root: root', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo: root foo', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo/bar')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar: root foo bar', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo/bar/baz')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'baz: root foo bar baz', req.response_body
+  end
+end
+
+class ErrorHandlerTest < Minitest::Test
+  HTTP = Syntropy::HTTP
+
+  APP_ROOT = File.join(__dir__, 'fixtures/app_errors')
+
+  def setup
+    @machine = UM.new
+
+    @tmp_path = '/test/tmp'
+    @tmp_fn = File.join(APP_ROOT, 'tmp.rb')
+
+    @app = Syntropy::App.new(
+      app_root: APP_ROOT,
+      mount_path: '/',
+      watch_files: 0.05,
+      machine: @machine
+    )
+
+    @test_harness = Syntropy::TestHarness.new(@app)
+  end
+
+  def test_error_handlers
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    assert_equal HTTP::TEAPOT, req.response_status
+    assert_equal 'root: root', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo')
+    assert_equal HTTP::TEAPOT, req.response_status
+    assert_equal 'foo: foo', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo/bar')
+    assert_equal HTTP::TEAPOT, req.response_status
+    assert_equal 'bar: bar', req.response_body
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/foo/bar/baz')
+    assert_equal HTTP::TEAPOT, req.response_status
+    assert_equal 'bar: baz', req.response_body
+  end
+end
+
 class CustomAppTest < Minitest::Test
   HTTP = Syntropy::HTTP
 
@@ -220,7 +305,7 @@ class MultiSiteAppTest < Minitest::Test
     @test_harness = Syntropy::TestHarness.new(@app)
   end
 
-  def test_route_by_host
+  def test_dispatch_by_host
     req = @test_harness.request(':method' => 'GET', ':path' => '/', 'host' => 'blah')
     assert_nil req.response_body
     assert_equal HTTP::BAD_REQUEST, req.response_status

data/test/test_controller.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'syntropy/test'
+
+class DispatchByHostTest < Syntropy::Test
+  self.env = {
+    app_root: File.join(__dir__, 'fixtures/controllers'),
+    mount_path: '/'
+  }
+
+  def test_dispatch_by_host_dir
+    req = get('/by_host_dir', 'host' => 'sqdf')
+    assert_equal HTTP::BAD_REQUEST, req.response_status
+
+    req = get('/by_host_dir', 'host' => 'foo.com')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
+
+    req = get('/by_host_dir', 'host' => 'bar.com')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar', req.response_body
+  end
+
+  def test_dispatch_by_host_map
+    req = get('/by_host_map', 'host' => 'sqdf')
+    assert_equal HTTP::BAD_REQUEST, req.response_status
+
+    req = get('/by_host_map', 'host' => 'foofoo')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
+
+    req = get('/by_host_map', 'host' => 'barbar')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar', req.response_body
+  end
+
+  def test_dispatch_by_host_dir_map
+    req = get('/by_host_dir_map', 'host' => 'sqdf')
+    assert_equal HTTP::BAD_REQUEST, req.response_status
+
+    req = get('/by_host_dir_map', 'host' => 'foo.com')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
+
+    req = get('/by_host_dir_map', 'host' => 'foofoo')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
+
+    req = get('/by_host_dir_map', 'host' => 'bar.com')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar', req.response_body
+
+    req = get('/by_host_dir_map', 'host' => 'barbar')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar', req.response_body
+  end
+
+  def test_dispatch_by_http_method
+    req = get('/by_http_method')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'get', req.response_body
+
+    req = post('/by_http_method', nil, nil)
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'post', req.response_body
+
+    req = patch('/by_http_method', nil, nil)
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
+  end
+end

data/test/test_http_protocol.rb

@@ -248,3 +248,57 @@ class HTTPProtocolResponseTest < HTTPProtocolTest
     assert_raises(Syntropy::ProtocolError) { @io.http_read_response_headers }
   end
 end
+
+class PipelineTest < HTTPProtocolTest
+  def test_pipeline_post_zero_content_length
+    msg = "POST /counter_api?q=incr HTTP/1.1\r\n" +
+          "Host: localhost:1234\r\n" +
+          "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:151.0) Gecko/20100101 Firefox/151.0\r\n" +
+          "Accept: */*\r\n" +
+          "Accept-Language: en-US,en;q=0.9\r\n" +
+          "Accept-Encoding: gzip, deflate, br, zstd\r\n" +
+          "Referer: http://localhost:1234/counter\r\n" +
+          "Origin: http://localhost:1234\r\n" +
+          "Connection: keep-alive\r\n" +
+          "Sec-Fetch-Dest: empty\r\n" +
+          "Sec-Fetch-Mode: cors\r\n" +
+          "Sec-Fetch-Site: same-origin\r\n" +
+          "Priority: u=0\r\nPragma: no-cache\r\n" +
+          "Cache-Control: no-cache\r\n" +
+          "Content-Length: 0\r\n\r\n"
+
+    write(msg * 3)
+    3.times {
+      h = @io.http_read_request_headers
+      assert_equal '*/*', h['accept']
+      assert_nil @io.http_read_body_chunk(h)
+    }
+  end
+
+  def test_pipeline_post_with_body
+    msg = "POST /counter_api?q=incr HTTP/1.1\r\n" +
+          "Host: localhost:1234\r\n" +
+          "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:151.0) Gecko/20100101 Firefox/151.0\r\n" +
+          "Accept: */*\r\n" +
+          "Accept-Language: en-US,en;q=0.9\r\n" +
+          "Accept-Encoding: gzip, deflate, br, zstd\r\n" +
+          "Referer: http://localhost:1234/counter\r\n" +
+          "Origin: http://localhost:1234\r\n" +
+          "Connection: keep-alive\r\n" +
+          "Sec-Fetch-Dest: empty\r\n" +
+          "Sec-Fetch-Mode: cors\r\n" +
+          "Sec-Fetch-Site: same-origin\r\n" +
+          "Priority: u=0\r\nPragma: no-cache\r\n" +
+          "Cache-Control: no-cache\r\n" +
+          "Content-Length: 3\r\n\r\n" +
+          "abc"
+
+    write(msg * 3)
+    3.times {
+      h = @io.http_read_request_headers
+      assert_equal '*/*', h['accept']
+      assert_equal 'abc', @io.http_read_body_chunk(h)
+    }
+
+  end
+end