syntropy 0.30.0 → 0.31.0

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 export ->(req) {
-  req.json_response({
+  req.respond_json({
     headers: req.headers
   })
 }

data/lib/syntropy/dev_mode.rb

@@ -4,7 +4,7 @@ TAG_DEBUG_PROC = ->(level, fn, line, col) {
   {
     'data-syntropy-level' => level,
     'data-syntropy-fn'    => fn,
-    'data-syntropy-loc'   => "vscode://file/#{fn}:#{line}:#{col}"
+    'data-syntropy-loc'   => "zed://file/#{fn}:#{line}:#{col}"
   }
 }
 

data/lib/syntropy/errors.rb

@@ -84,4 +84,10 @@ module Syntropy
 
   class BadRequestError < Error
   end
+
+  class InvalidRequestContentTypeError < Error
+    def http_status
+      HTTP::UNSUPPORTED_MEDIA_TYPE
+    end
+  end
 end

data/lib/syntropy/http/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'syntropy/http/client_connection'
+require 'uri'
+
+module Syntropy
+  module HTTP
+    class Client
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def get(url, **headers, &)
+        uri = URI.parse(url)
+        headers = headers.merge(
+          ':method' => 'GET',
+          ':path' => uri.request_uri
+        )
+        req(uri, **headers, &)
+      end
+
+      private
+
+      # @param uri [URI]
+      def req(uri, **headers)
+        connection = make_connection(uri.scheme, uri.host, uri.port)
+        response_headers = connection.req(**headers)
+        if block_given?
+          yield(response_headers, connection)
+        else
+          [response_headers, connection.get_response_body(response_headers)]
+        end
+      end
+
+      def make_connection(_scheme, host, port)
+        ip = (host =~ /^\d+\.\d+\.\d+\.\d+$/) ? host : @machine.resolve(host)[0]
+
+        fd = @machine.tcp_connect(ip, port)
+        Syntropy::HTTP::ClientConnection.new(@machine, fd)
+      end
+    end
+  end
+end

data/lib/syntropy/http/client_connection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+require 'syntropy/http/io_extensions'
+
+module Syntropy
+  module HTTP
+    class ClientConnection
+      attr_reader :fd, :response_headers, :logger
+
+      def initialize(machine, fd, io_mode: :socket)
+        @machine = machine
+        @fd = fd
+        @io = machine.io(fd, io_mode)
+      end
+
+      def req(body: nil, **headers)
+        if body
+          headers = headers.merge(
+            'Content-Length' => body.bytesize
+          )
+        end
+        @io.http_write_request_headers(**headers)
+        if body
+          @io.write(body)
+        end
+
+        @io.http_read_response_headers
+      end
+
+      def get_response_body(headers)
+        @io.http_read_body(headers)
+      end
+    end
+  end
+end

data/lib/syntropy/http/io_extensions.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'syntropy/errors'
+
+module Syntropy
+  module HTTP
+    module ProtocolMethods
+      RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+HTTP\/([019\.]{1,3})/i
+      RE_RESPONSE_LINE = /^HTTP\/1\.1\s+(\d{3})(\s+.+)?$/i
+      RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
+
+      MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
+      MAX_RESPONSE_LINE_LEN = 1 << 8 # 256
+      MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
+      MAX_CHUNK_SIZE_LEN = 16
+
+      # @return [Hash] headers
+      def http_read_request_headers
+        line = read_line(MAX_REQUEST_LINE_LEN)
+        return nil if !line
+
+        m = line.match(RE_REQUEST_LINE)
+        raise ProtocolError, 'Invalid request line' if !m
+
+        http_version = m[3]
+        raise UnsupportedHTTPVersionError, 'HTTP version not supported' if http_version != '1.1'
+
+        headers = {
+          ':method'   => m[1].downcase,
+          ':path'     => m[2],
+          ':protocol' => 'http/1.1'
+        }
+
+        loop do
+          line = read_line(MAX_HEADER_LINE_LEN)
+          break if line.nil? || line.empty?
+
+          m = line.match(RE_HEADER_LINE)
+          raise ProtocolError, "Invalid header: #{line[0..2047].inspect}" if !m
+
+          headers[m[1].downcase] = m[2]
+        end
+
+        headers
+      end
+
+      def http_read_response_headers
+        line = read_line(MAX_RESPONSE_LINE_LEN)
+        return nil if !line
+
+        m = line.match(RE_RESPONSE_LINE)
+        raise ProtocolError, 'Invalid response line' if !m
+
+        headers = {
+          ':status'   => m[1].to_i
+        }
+
+        loop do
+          line = read_line(MAX_HEADER_LINE_LEN)
+          break if line.nil? || line.empty?
+
+          m = line.match(RE_HEADER_LINE)
+          raise ProtocolError, "Invalid header: #{line[0..2047].inspect}" if !m
+
+          k = m[1].downcase
+          if (h = headers[k])
+            (h = headers[k] = [h]) if !h.is_a?(Array)
+            h << m[2]
+          else
+            headers[k] = m[2]
+          end
+        end
+
+        headers
+      end
+
+      def http_read_body(headers)
+        content_length = headers['content-length']
+        if content_length
+          chunk = read(content_length.to_i)
+          return chunk
+        end
+
+        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+        if chunked_encoding
+          buf = +''
+          while (chunk = http_read_cte_chunk(nil))
+            buf << chunk
+          end
+          return buf
+        end
+
+        nil
+      end
+
+      def http_read_body_chunk(headers)
+        content_length = headers['content-length']
+        if content_length
+          chunk = read(content_length.to_i)
+          return chunk
+        end
+
+        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+        return http_read_cte_chunk(nil) if chunked_encoding
+
+        nil
+      end
+
+      def http_write_request_headers(headers)
+        method = headers[':method'] || (raise BadRequestError)
+        path = headers[':path'] || (raise BadRequestError)
+
+        lines = ["#{method} #{path} HTTP/1.1\r\n"]
+        headers.each do |k, v|
+          next if k =~ /^\:/
+
+          if v.is_a?(Array)
+            v.each { lines << "#{k}: #{it}\r\n" }
+          else
+            lines << "#{k}: #{v}\r\n"
+          end
+        end
+        lines << "\r\n"
+        write(*lines)
+      end
+
+      private
+
+      def http_read_cte_chunk(buffer)
+        chunk_size_str = read_line(MAX_CHUNK_SIZE_LEN)
+        return nil if !chunk_size_str
+
+        chunk_size = chunk_size_str.to_i(16)
+        if chunk_size == 0
+          read_line(0)
+          return nil
+        end
+
+        chunk = read(chunk_size)
+        read_line(0)
+
+        buffer ? (buffer << chunk) : chunk
+      end
+    end
+  end
+end
+
+UringMachine::IO.include(Syntropy::HTTP::ProtocolMethods)

data/lib/syntropy/http/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'syntropy/http/connection'
+require 'syntropy/http/server_connection'
 
 module Syntropy
   module HTTP
@@ -119,13 +119,13 @@ module Syntropy
       end
 
       def accept_incoming(listen_fd)
-        @machine.accept_each(listen_fd) { start_client_connection(it) }
+        @machine.accept_each(listen_fd) { start_connection(it) }
       rescue UM::Terminate
-        # terminated
+        @machine.shutdown(listen_fd, UM::SHUT_RD)
       end
 
-      def start_client_connection(fd)
-        conn = Connection.new(self, @machine, fd, @env, &@app)
+      def start_connection(fd)
+        conn = ServerConnection.new(@machine, fd, @env, &@app)
         f = @machine.spin(conn) do
           it.run
         ensure

data/lib/syntropy/http/{connection.rb → server_connection.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'syntropy/errors'
+require 'syntropy/http/io_extensions'
 
 module Syntropy
   module HTTP
@@ -9,16 +10,15 @@ module Syntropy
     # body is sent exclusively using chunked transfer encoding. Request bodies are
     # accepted using either fixed length (Content-Length header) or chunked
     # transfer encoding.
-    class Connection
+    class ServerConnection
       attr_reader :fd, :response_headers, :logger
 
-      def initialize(server, machine, fd, env, &app)
-        @server = server
+      def initialize(machine, fd, env, io_mode: :socket, &app)
         @machine = machine
         @fd = fd
         @env = env
         @logger = env[:logger]
-        @io = machine.io(fd, :socket)
+        @io = machine.io(fd, io_mode)
         @app = app
 
         @done = nil
@@ -96,46 +96,17 @@ module Syntropy
         headers = req.headers
         return nil if headers[':body-done-reading']
 
-        content_length = headers['content-length']
-        if content_length
-
-          chunk = @io.read(content_length.to_i)
-          headers[':body-done-reading'] = true
-          return chunk
-        end
-
-        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
-        if chunked_encoding
-          buf = +''
-          while (chunk = read_chunk(headers, nil))
-            buf << chunk
-          end
-          headers[':body-done-reading'] = true
-          return buf
-        end
-
-        nil
+        body = @io.http_read_body(headers)
+        headers[':body-done-reading'] = true if body
+        body
       end
 
       def get_body_chunk(req)
         headers = req.headers
-        content_length = headers['content-length']
-        if content_length
-          return nil if headers[':body-done-reading']
-
-          chunk = @io.read(content_length.to_i)
-          headers[':body-done-reading'] = true
-          return chunk
-        end
-
-        chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
-        return read_chunk(headers, nil) if chunked_encoding
-
         return nil if headers[':body-done-reading']
 
-        # if content-length is not specified, we read to EOF, up to max 1MB size
-        chunk = read(1 << 20, nil, false)
-        headers[':body-done-reading'] = true
+        chunk = @io.http_read_body_chunk(headers)
+        headers[':body-done-reading'] = true if !chunk
         chunk
       end
 

data/lib/syntropy/http.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 require 'syntropy/http/status'
-require 'syntropy/http/connection'
+require 'syntropy/http/client_connection'
+require 'syntropy/http/client'
+require 'syntropy/http/server_connection'
 require 'syntropy/http/server'

data/lib/syntropy/logger.rb

@@ -67,7 +67,7 @@ module Syntropy
       request = o[:request]
       request_headers = request.headers
       response_headers = o[:response_headers]
-      elapsed = request.adapter.monotonic_clock - request.start_stamp
+      elapsed = monotonic_clock - request.start_stamp
       {
         level: level.to_s,
         ts: (t = Time.now; t.to_i),
@@ -82,6 +82,10 @@ module Syntropy
       }
     end
 
+    def monotonic_clock
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
     def make_hash_entry(level, hash)
       {
         level: level.to_s,

data/lib/syntropy/papercraft_extensions.rb

@@ -3,7 +3,7 @@
 require 'papercraft'
 
 Papercraft.extension(
-  'auto_refresh_watch!': ->(loc = '/.syntropy') {
+  'auto_refresh!': ->(loc = '/.syntropy') {
     if $syntropy_dev_mode
       script(src: File.join(loc, 'auto_refresh/watch.js'), type: 'module')
     end

data/lib/syntropy/request/mock_adapter.rb

@@ -42,6 +42,8 @@ module Syntropy
     end
 
     def status
+      raise 'No response' if !response_headers
+
       response_headers[':status'] || HTTP::OK
     end
 

data/lib/syntropy/request/request_info.rb

@@ -34,6 +34,16 @@ module Syntropy
       @scheme ||= @headers[':scheme']
     end
 
+    def content_type
+      ct = @headers['content-type']
+      return nil if !ct
+
+      m = ct.match(/^([^;]+)/)
+      return nil if !m
+
+      m[1].strip
+    end
+
     # Rewrites the request path by replacing the given src with the given
     # replacement.
     #
@@ -77,7 +87,7 @@ module Syntropy
     def parse_query(query)
       query.split('&').each_with_object({}) do |kv, h|
         k, v = kv.match(QUERY_KV_REGEXP)[1..2]
-        h[k.to_sym] = v ? URI.decode_www_form_component(v) : true
+        h[k] = v ? URI.decode_www_form_component(v) : true
       end
     end
 
@@ -147,6 +157,15 @@ module Syntropy
       @accept_parts.include?(mime_type)
     end
 
+    def auth_bearer_token
+      auth = headers['authorization']
+      if (m = auth.match(/Bearer\s+([^\w]+)/))
+        return m[1]
+      end
+
+      nil
+    end
+
     private
 
     def parse_accept_parts(accept)

data/lib/syntropy/request/response.rb

@@ -179,7 +179,7 @@ module Syntropy
       end
     end
 
-    def html_response(html, **headers)
+    def respond_html(html, **headers)
       respond(
         html,
         'Content-Type' => 'text/html; charset=utf-8',
@@ -187,7 +187,7 @@ module Syntropy
       )
     end
 
-    def json_response(obj, **headers)
+    def respond_json(obj, **headers)
       respond(
         JSON.dump(obj),
         'Content-Type' => 'application/json; charset=utf-8',

data/lib/syntropy/request/validation.rb

@@ -18,6 +18,13 @@ module Syntropy
       raise Syntropy::Error.method_not_allowed
     end
 
+    def validate_content_type(*accepted)
+      ct = content_type
+      return ct if accepted.include?(ct)
+
+      raise Syntropy::InvalidRequestContentTypeError
+    end
+
     # Validates and optionally converts request parameter value for the given
     # parameter name against the given clauses. If no clauses are given,
     # verifies the parameter value is not nil. A clause can be a class, such as
@@ -47,12 +54,12 @@ module Syntropy
     # @param value [any] value
     # @clauses [Array] one or more validation clauses
     # @return [any] validated value
-    def validate(value, *clauses)
-      raise Syntropy::ValidationError, 'Validation error' if clauses.empty? && !value
+    def validate(value, *clauses, message: 'Validation error')
+      raise Syntropy::ValidationError, message if clauses.empty? && !value
 
       clauses.each do |c|
         valid = param_is_valid?(value, c)
-        raise(Syntropy::ValidationError, 'Validation error') if !valid
+        raise(Syntropy::ValidationError, message) if !valid
 
         value = param_convert(value, c)
       end

data/lib/syntropy/routing_tree.rb

@@ -260,7 +260,8 @@ module Syntropy
     # @param dir [String] directory path
     # @return [Array<String>] array of file entries
     def file_search(dir)
-      Dir[File.join(dir.gsub(/[\[\]]/) { "\\#{it}"}, '*')]
+      spec = File.join(dir.gsub(/[\[\]]/) { "\\#{it}"}, '{*,.*}')
+      Dir[spec].reject { it =~ /\/\.$/ }
     end
 
     # Computes a route entry and/or target for the given file path.

data/lib/syntropy/test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'syntropy'
+require 'syntropy/request/mock_adapter'
+require 'minitest'
+
+module Syntropy
+  class TestHarness
+    def initialize(app)
+      @app = app
+      @app.test_mode = true
+    end
+
+    def request(headers, body = nil)
+      req = mock_req(headers, body)
+      @app.call(req)
+      req
+    end
+
+    private
+
+    def mock_req(headers, body = nil)
+      Syntropy::MockAdapter.mock(headers, body)
+    end
+  end
+
+  class Request
+    def response_headers
+      adapter.response_headers
+    end
+
+    def response_status
+      adapter.status
+    end
+
+    def response_body
+      adapter.response_body
+    end
+
+    def response_json
+      raise if response_content_type != 'application/json'
+      JSON.parse(response_body)
+    end
+
+    def response_content_type
+      ct = response_headers['Content-Type']
+      return nil if !ct
+
+      m = ct.match(/^([^;]+)/)
+      return nil if !m
+
+      m[1]
+    end
+
+    def response_cookie(name)
+      sc = response_headers['Set-Cookie']
+      return nil if !sc
+
+      m = sc.match(/#{name}=([^\s]+)$/)
+      return nil if !m
+
+      m[1]
+    end
+  end
+end

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -32,25 +32,6 @@ module Syntropy
     end
   end
 
-  def colorize(color_code)
-    "\e[#{color_code}m#{self}\e[0m"
-  end
-
-  GREEN = "\e[32m"
-  CLEAR = "\e[0m"
-  YELLOW = "\e[33m"
-
-  BANNER =
-    "\n"\
-    "  #{GREEN}\n"\
-    "  #{GREEN} ooo\n"\
-    "  #{GREEN}ooooo\n"\
-    "  #{GREEN} ooo vvv       #{CLEAR}Syntropy - a web framework for Ruby\n"\
-    "  #{GREEN}  o vvvvv     #{CLEAR}--------------------------------------\n"\
-    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/digital-fabric/syntropy\n"\
-    "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
-    "#{YELLOW}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\e[0m\n\n"
-
   class << self
     def run(env = {}, &app)
       if @in_run
@@ -63,11 +44,10 @@ module Syntropy
       begin
         @in_run = true
         machine = env[:machine] || UM.new
-        machine.puts(env[:banner]) if env[:banner]
 
         env[:logger]&.info(message: "Running Syntropy #{Syntropy::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
 
-        server = Server.new(machine, env, &app)
+        server = HTTP::Server.new(machine, env, &app)
 
         setup_signal_handling(machine, Fiber.current)
         server.run

data/syntropy.gemspec

@@ -23,8 +23,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'extralite',     '~>2.14'
   s.add_dependency 'papercraft',    '~>3.2.0'
-  s.add_dependency 'uringmachine',  '~>1.0.0'
-  s.add_dependency 'cgi'
+  s.add_dependency 'uringmachine',  '~>1.0.2'
   s.add_dependency 'escape_utils',  '1.3.0'
 
   s.add_dependency 'json'

data/test/app/.well-known/foo.rb

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

data/test/helper.rb

@@ -4,7 +4,7 @@ require 'bundler/setup'
 require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
 require 'syntropy'
-require 'syntropy/request/mock_adapter'
+require 'syntropy/test'
 require 'minitest/autorun'
 require 'fileutils'
 
@@ -96,27 +96,3 @@ module Minitest::Assertions
     assert_equal exp_content_type, actual
   end
 end
-
-# Extensions to be used in conjunction with `Syntropy::TestAdapter`
-class Syntropy::Request
-  def response_headers
-    adapter.response_headers
-  end
-
-  def response_status
-    adapter.status
-  end
-
-  def response_body
-    adapter.response_body
-  end
-
-  def response_json
-    raise if response_content_type != 'application/json'
-    JSON.parse(response_body, symbolize_names: true)
-  end
-
-  def response_content_type
-    response_headers['Content-Type']
-  end
-end