syntropy 0.42.0 → 0.44.0

data/examples/gitshabbos/config/development.rb

@@ -0,0 +1,11 @@
+export(
+  {
+    repositories: [
+      {
+        name: 'syntropy',
+        path: File.expand_path(File.join(__dir__, '../../..')),
+        description: 'A web framework for Ruby'
+      }
+    ]
+  }
+)

data/examples/gitshabbos/config/production.rb

@@ -0,0 +1,5 @@
+export(
+  storage: {
+    path: ENV['DATABASE_PATH'] || 'storage/production.db'
+  }
+)

data/examples/gitshabbos/config/test.rb

@@ -0,0 +1,5 @@
+export({
+  storage: {
+    path: ENV['DATABASE_PATH'] || tmp_path('test-db')
+  }
+})

data/examples/gitshabbos/docker-compose.yml

@@ -0,0 +1,71 @@
+#version: "3.8"
+
+services:
+  app_server:
+    build: .
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - .:/syntropy
+    stop_signal: SIGINT
+    stop_grace_period: 10s
+    restart: unless-stopped
+    healthcheck:
+      test: "curl 'http://localhost:1234/'"
+      interval: "30s"
+      timeout: "3s"
+      start_period: "5s"
+      retries: 3
+    networks:
+      - proxy_network
+
+  console:
+    build: .
+    command: bundle exec syntropy console
+    stdin_open: true # docker run -i
+    tty: true
+    security_opt:
+      - seccomp:unconfined
+    profiles:
+      - dev
+    volumes:
+      - .:/syntropy
+    stop_signal: SIGINT
+    restart: never
+
+  test:
+    build: .
+    command: bundle exec syntropy test -w
+    stdin_open: true # docker run -i
+    tty: true
+    security_opt:
+      - seccomp:unconfined
+    profiles:
+      - dev
+    volumes:
+      - .:/syntropy
+    stop_signal: SIGINT
+    restart: never
+
+  proxy:
+    depends_on:
+      - app_server
+    image: caddy:2-alpine
+    build:
+      context: ./proxy
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+      - "443:443/udp"
+    volumes:
+      - ./config/Caddyfile:/etc/caddy/Caddyfile
+      - ./storage/caddy/data:/data
+      - ./storage/caddy/config:/config
+    networks:
+      - proxy_network
+
+networks:
+  proxy_network:
+    name: proxy_network

data/examples/gitshabbos/test/test_app.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AppTest < Syntropy::Test
+  def test_routing
+    req = get('/')
+    assert_equal HTTP::OK, req.response_status
+
+    req = get('/test')
+    assert_equal HTTP::OK, req.response_status
+
+    req = get('/foo')
+    assert_equal HTTP::NOT_FOUND, req.response_status
+  end
+end

data/examples/mcp-oauth/app/oauth/consent.rb

@@ -1,7 +1,7 @@
 AuthStore = import '../_lib/auth_store'
 
 export ->(req) {
-  case req.method
+  case req.http_method
   when 'get'
     render_consent_form(req)
   when 'post'

data/examples/mcp-oauth/app/signin.rb

@@ -1,7 +1,7 @@
 AuthStore = import '../_lib/auth_store'
 
 export ->(req) {
-  case req.method
+  case req.http_method
   when 'get'
     render_signin_form(req)
   when 'post'

data/lib/syntropy/app.rb

@@ -120,7 +120,7 @@ module Syntropy
       if Error.log_error?(e)
         @logger&.error(
           message: "Error while serving request: #{e.message}",
-          method: req.method,
+          method: req.http_method,
           path: path,
           error: e
         )
@@ -244,7 +244,7 @@ module Syntropy
       headers = { 'Content-Type' => MimeTypes[File.extname(fn)] }
 
       ->(req) {
-        case req.method
+        case req.http_method
         when 'head'
           req.respond(nil, headers)
         when 'get'
@@ -454,7 +454,7 @@ module Syntropy
       status = Syntropy::Error.http_status(err)
 
       msg = err.message
-      msg = nil if msg.empty? || (req.method == 'head')
+      msg = nil if msg.empty? || (req.http_method == 'head')
       req.respond(msg, ':status' => status) rescue nil
     }
 
@@ -463,7 +463,7 @@ module Syntropy
       raise if status == HTTP::INTERNAL_SERVER_ERROR
 
       msg = err.message
-      msg = nil if msg.empty? || (req.method == 'head')
+      msg = nil if msg.empty? || (req.http_method == 'head')
       req.respond(msg, ':status' => status) rescue nil
     }
 

data/lib/syntropy/applets/builtin/default_error_handler.rb

@@ -62,7 +62,7 @@ def error_response_raw(req, error)
     message: error.message,
     backtrace: error.backtrace
   }
-  req.json_pretty_response(response, ':status' => status)
+  req.respond_json_pretty(response, ':status' => status)
 end
 
 export ->(req, error) {

data/lib/syntropy/controller_extensions.rb

@@ -109,7 +109,7 @@ module Syntropy
     # the request's HTTP method. If no method is found, raises a
     # method_not_allowed error.
     def route_by_http_method(req)
-      sym = req.method.to_sym
+      sym = req.http_method.to_sym
       raise Syntropy::Error.method_not_allowed if !respond_to?(sym)
 
       send(sym, req)

data/lib/syntropy/errors.rb

@@ -43,6 +43,8 @@ module Syntropy
     # @return [Syntropy::Error]
     def self.teapot(msg = 'I\'m a teapot') = new(msg, HTTP::TEAPOT)
 
+    def self.bad_request(msg = 'Bad request') = new(msg, HTTP::BAD_REQUEST)
+
     # Initializes a Syntropy error with the given HTTP status and message.
     #
     # @param http_status [Integer, String] HTTP status

data/lib/syntropy/http/server_connection.rb

@@ -11,7 +11,7 @@ module Syntropy
     # accepted using either fixed length (Content-Length header) or chunked
     # transfer encoding.
     class ServerConnection
-      attr_reader :fd, :response_headers, :logger
+      attr_reader :fd, :io, :response_headers, :logger
 
       # Initializes a server connection.
       #

data/lib/syntropy/json_api.rb

@@ -34,7 +34,7 @@ module Syntropy
     # @param req [Syntropy::Request]
     def __invoke__(req)
       q = req.validate_param(:q, String).to_sym
-      case req.method
+      case req.http_method
       when 'get'
         response = __invoke_get__(q, req)
       when 'post'

data/lib/syntropy/logger.rb

@@ -88,8 +88,11 @@ module Syntropy
         message:      o[:message]
       )
 
-      entry.merge!(error_info(error)) if (error = o.delete(:error))
-      entry.merge!(request_info(request)) if (request = o.delete(:request))
+      error = entry.delete(:error)
+      entry.merge!(error_info(error)) if error
+
+      request = entry.delete(:request)
+      entry.merge!(request_info(request)) if request
 
       entry
     end
@@ -111,14 +114,14 @@ module Syntropy
     # @return [Hash] request info
     def request_info(request)
       request_headers = request.headers
-      response_headers = request.response_headers
+      # response_headers = request.response_headers
       elapsed = monotonic_clock - request.start_stamp
       {
         client_ip:    request.forwarded_for || '?',
         http_method:  request_headers[':method'].upcase,
         user_agent:   request_headers['user-agent'],
         uri:          full_uri(request_headers),
-        status:       response_headers[':status'] || '200',
+        # status:       response_headers[':status'] || '200',
         elapsed:      elapsed
       }
     end

data/lib/syntropy/markdown.rb

@@ -26,7 +26,7 @@ module Syntropy
       # @return [Proc] controller proc
       def to_proc
         ->(req) {
-          case req.method
+          case req.http_method
           when 'head'
             req.respond_html(nil)
           when 'get'

data/lib/syntropy/request/request_info.rb

@@ -44,7 +44,7 @@ module Syntropy
     # Returns the HTTP method in lower case.
     #
     # @return [String]
-    def method
+    def http_method
       @method ||= @headers[':method'].downcase
     end
 
@@ -100,11 +100,20 @@ module Syntropy
 
     # Returns the request path.
     #
-    # @return [String]
+    # @return [String] path
     def path
       @path ||= uri.path
     end
 
+    # Returns the relative path for the route. The relative path will be non-nil
+    # only for a sub path of a wildcard route. For example, for a route at
+    # /api+, rel_path returns nil for /api, and "foo/bar" for /api/foo/bar.
+    #
+    # @return [String, nil] relative path or nil
+    def rel_path
+      @route_params[:__rel_path__]
+    end
+
     # Returns the request (unparsed) query string.
     #
     # @return [String, nil]

data/lib/syntropy/request/response.rb

@@ -181,7 +181,7 @@ module Syntropy
     # @param map [Hash] hash mapping HTTP methods to responses
     # @return [void]
     def respond_by_http_method(map)
-      value = map[self.method]
+      value = map[http_method]
       raise Syntropy::Error.method_not_allowed if !value
 
       value = value.() if value.is_a?(Proc)
@@ -196,7 +196,7 @@ module Syntropy
     # @param headers [Hash] response headers
     # @return [void]
     def respond_on_get(body, headers = {})
-      case self.method
+      case http_method
       when 'head'
         respond(nil, headers)
       when 'get'
@@ -213,7 +213,7 @@ module Syntropy
     # @param headers [Hash] response headers
     # @return [void]
     def respond_on_post(body, headers = {})
-      case self.method
+      case http_method
       when 'head'
         respond(nil, headers)
       when 'post'
@@ -254,12 +254,54 @@ module Syntropy
     # @param obj [any] obj to render into JSON
     # @param headers [Hash] additional response headers
     # @return [void]
-    def json_pretty_response(obj, **headers)
+    def respond_json_pretty(obj, **headers)
       respond(
         JSON.pretty_generate(obj),
         'Content-Type' => 'application/json; charset=utf-8',
         **headers
       )
     end
+
+    # Renders the headers for an SSE (text/event-stream) response. If any events
+    # are given, they're rendered into the event stream. If a block is given, it
+    # is evaluated.
+    #
+    # @param events [Array<any>] events to render
+    # @return [void]
+    def respond_sse(*events)
+      send_headers('Content-Type' => 'text/event-stream')
+      send_event(*events) if !events.empty?
+      yield if block_given?
+    rescue SystemCallError => e
+      # swallow system call error, but let server connection know we're done
+      headers['connection'] = 'close'
+    ensure
+      finish if !e
+    end
+
+    # Sends one or more SSE events.
+    #
+    # @param events [Array<Hash, Array, String>] events
+    # @return [void]
+    def send_event(*events)
+      events.each { |e|
+        case e
+        when Hash
+          e.each { |k, v|
+            if v.is_a?(Array)
+              v = v.map { |i| "data: #{i}\n" }.join
+              send_chunk("event: #{k}\n#{v}\n")
+            else
+              send_chunk("event: #{k}\ndata: #{v}\n\n")
+            end
+          }
+        when Array
+          e = e.map { |i| "data: #{i}\n" }.join
+          send_chunk("#{e}\n")
+        else
+          send_chunk("data: #{e}\n\n")
+        end
+      }
+    end
   end
 end

data/lib/syntropy/request/validation.rb

@@ -13,7 +13,8 @@ module Syntropy
     # @param accepted [Array<String>] list of accepted HTTP methods
     # @return [String] request's HTTP method
     def validate_http_method(*accepted)
-      return method if accepted.include?(method)
+      m = http_method
+      return m if accepted.include?(m)
 
       raise Syntropy::Error.method_not_allowed
     end

data/lib/syntropy/routing_tree.rb

@@ -422,6 +422,8 @@ module Syntropy
       @static_map.freeze
       @dynamic_map.freeze
       code = generate_routing_tree_code
+      # puts '*' * 40
+      # puts code
       eval(code, binding, '(router)', 1)
     end
 
@@ -630,11 +632,15 @@ module Syntropy
           next if child_entry[:static]
 
           emit_code_line(buffer, "#{ws}when #{k.inspect}")
-          if_clause = child_entry[:handle_subtree] ? '' : " if !segments[#{segment_idx + 1}]"
 
-          child_path = child_entry[:path]
-          route_value = "@dynamic_map[#{child_path.inspect}]"
-          emit_code_line(buffer, "#{ws}  return #{route_value}#{if_clause}")
+          route_value = "@dynamic_map[#{child_entry[:path].inspect}]"
+          if child_entry[:handle_subtree]
+            emit_code_line(buffer, "#{ws}  params[:__rel_path__] = (rest = segments[#{segment_idx + 1}..-1]).empty? ? nil : rest.join('/')")
+            emit_code_line(buffer, "#{ws}  return #{route_value}")
+          else
+            if_clause = " if !segments[#{segment_idx + 1}]"
+            emit_code_line(buffer, "#{ws}  return #{route_value}#{if_clause}")
+          end
           when_count += 1
 
         elsif has_children
@@ -654,24 +660,26 @@ module Syntropy
         end
       end
 
-      # parametric route
       if param_entry
+        # parametric route
         if when_count == 0
           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}] = s")
+        emit_code_line(buffer, "#{ws}  params[#{param_entry[:param].to_sym.inspect}] = s")
         visit_routing_tree_entry(buffer:, entry: param_entry, indent: indent + 1, segment_idx: segment_idx + 1)
-      # wildcard route
       elsif entry[:handle_subtree]
+        # wildcard route
         emit_code_line(buffer, "#{ws}else")
+        emit_code_line(buffer, "#{ws}  params[:__rel_path__] = segments[#{segment_idx}..-1].join('/')")
         emit_code_line(buffer, "#{ws}  return @dynamic_map[#{entry[:path].inspect}]")
       end
     end
 
     DEBUG = !!ENV['DEBUG']
+    RETURN_NIL_RE = /\sreturn nil\z/
 
     # Emits the given code into the given buffer, with a line break at the end.
     # If the `DEBUG` environment variable is set, adds a source location comment
@@ -681,6 +689,7 @@ module Syntropy
     # @param code [String] code
     # @return [void]
     def emit_code_line(buffer, code)
+      return if buffer =~ RETURN_NIL_RE && code =~ RETURN_NIL_RE
       if DEBUG
         loc = (m = caller[0].match(/^([^\:]+\:\d+)/)) && m[1]
         buffer << "#{code} # #{loc}\n"

data/lib/syntropy/version.rb

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

data/test/fixtures/app/mod/bar/index+.rb

@@ -1,5 +1,9 @@
+export self
+
 def env
   @env
 end
 
-export self
+def call(req)
+  req.respond_json({ rel_path: req.route_params[:__rel_path__]})
+end

data/test/fixtures/app/params/[foo].rb

@@ -1,3 +1,3 @@
 export ->(req) {
-  req.respond_on_get("#{req.route[:path]}-#{req.route_params['foo']}")
+  req.respond_on_get("#{req.route[:path]}-#{req.route_params[:foo]}")
 }

data/test/test_app.rb

@@ -410,3 +410,32 @@ class AppDependenciesTest < Minitest::Test
     assert_equal HTTP::OK, req.response_status
   end
 end
+
+class AppRouteParamsTest < Syntropy::Test
+  self.env = {
+    app_root: File.join(__dir__, 'fixtures/app'),
+    mount_path: '/test'
+  }
+
+  def test_app_route_params
+    req = get('/test/params/abc')
+    assert_equal 'abc', req.route_params[:foo]
+  end
+
+  def test_app_route_params_rel_path
+    req = get('/test/mod/bar')
+    assert_nil req.route_params[:__rel_path__]
+    assert_nil req.rel_path
+    assert_nil req.response_json[:rel_path]
+
+    req = get('/test/mod/bar/foo')
+    assert_equal 'foo', req.route_params[:__rel_path__]
+    assert_equal 'foo', req.rel_path
+    assert_equal 'foo', req.response_json[:rel_path]
+
+    req = get('/test/mod/bar/foo/baz')
+    assert_equal 'foo/baz', req.route_params[:__rel_path__]
+    assert_equal 'foo/baz', req.rel_path
+    assert_equal 'foo/baz', req.response_json[:rel_path]
+  end
+end

data/test/test_response.rb

@@ -121,3 +121,118 @@ class UpgradeTest < Minitest::Test
     ], r.adapter.calls
   end
 end
+
+class SSETest < Minitest::Test
+  def test_respond_sse_block_empty
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse {}
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_block
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse {
+      r.send_event('foo')
+      r.send_event('bar', 'baz')
+      r.send_event('foo' => 'bar')
+      r.send_event(
+        { 'bar' => 'baz' },
+        { 'baz' => 'foo' },
+      )
+    }
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "data: foo\n\n", { done: false }],
+      [:send_chunk, r, "data: bar\n\n", { done: false }],
+      [:send_chunk, r, "data: baz\n\n", { done: false }],
+      [:send_chunk, r, "event: foo\ndata: bar\n\n", { done: false }],
+      [:send_chunk, r, "event: bar\ndata: baz\n\n", { done: false }],
+      [:send_chunk, r, "event: baz\ndata: foo\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_no_block_no_events
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse()
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_no_block_single_arg
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse('foo')
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "data: foo\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_no_block_multi_args
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse('foo', 'bar')
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "data: foo\n\n", { done: false }],
+      [:send_chunk, r, "data: bar\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_no_block_single_hash
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse('foo' => 'bar')
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "event: foo\ndata: bar\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_respond_sse_no_block_multi_hashes
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse({ 'foo' => 'bar' }, { 'bar' => 'baz', 'baz' => 'foo' })
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "event: foo\ndata: bar\n\n", { done: false }],
+      [:send_chunk, r, "event: bar\ndata: baz\n\n", { done: false }],
+      [:send_chunk, r, "event: baz\ndata: foo\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_send_event_multi_data
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse(['foo', 'bar', 'baz'])
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "data: foo\ndata: bar\ndata: baz\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+
+  def test_send_event_multi_data_hash
+    r = Syntropy::MockAdapter.mock
+    r.respond_sse('patch' => ['foo', 'bar', 'baz'])
+
+    assert_equal [
+      [:send_headers, r, { 'Content-Type' => 'text/event-stream'}, {empty_response: false}],
+      [:send_chunk, r, "event: patch\ndata: foo\ndata: bar\ndata: baz\n\n", { done: false }],
+      [:finish, r]
+    ], r.adapter.calls
+  end
+end