nuhttp 0.1.0

data/lib/nuhttp/server.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'socket'
+
+module NuHttp
+  class Server
+    # @rbs skip
+    include Socket::Constants
+
+    RFC9110_REASON_PHRASES = {
+      100 => "Continue",
+      101 => "Switching Protocols",
+      200 => "OK",
+      201 => "Created",
+      202 => "Accepted",
+      203 => "Non-Authoritative Information",
+      204 => "No Content",
+      205 => "Reset Content",
+      206 => "Partial Content",
+      300 => "Multiple Choices",
+      301 => "Moved Permanently",
+      302 => "Found",
+      303 => "See Other",
+      304 => "Not Modified",
+      305 => "Use Proxy",
+      307 => "Temporary Redirect",
+      308 => "Permanent Redirect",
+      400 => "Bad Request",
+      401 => "Unauthorized",
+      402 => "Payment Required",
+      403 => "Forbidden",
+      404 => "Not Found",
+      405 => "Method Not Allowed",
+      406 => "Not Acceptable",
+      407 => "Proxy Authentication Required",
+      408 => "Request Timeout",
+      409 => "Conflict",
+      410 => "Gone",
+      411 => "Length Required",
+      412 => "Precondition Failed",
+      413 => "Content Too Large",
+      414 => "URI Too Long",
+      415 => "Unsupported Media Type",
+      416 => "Range Not Satisfiable",
+      417 => "Expectation Failed",
+      421 => "Misdirected Request",
+      422 => "Unprocessable Content",
+      426 => "Upgrade Required",
+      500 => "Internal Server Error",
+      501 => "Not Implemented",
+      502 => "Bad Gateway",
+      503 => "Service Unavailable",
+      504 => "Gateway Timeout",
+      505 => "HTTP Version Not Supported",
+    }.freeze
+
+    def initialize(app, bind: "127.0.0.1", port: 8080, ractor_mode: false, call_make_shareable: false)
+      @app = app
+      @bind_address = bind
+      @port = port
+      @ractor_mode = ractor_mode
+
+      # When app_make_shareable: true, app will be deep frozen in attempt to
+      # make it Ractor shareable.
+      # Note: the app may not be made shareable, even if this option is specified.
+      Ractor.make_shareable(@app) if call_make_shareable
+      raise "app is not shareable" if @ractor_mode && !Ractor.shareable?(@app)
+    end
+
+    def start
+      socket = Socket.new(AF_INET, SOCK_STREAM, 0)
+      socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, true)
+      sockaddr = Socket.pack_sockaddr_in(@port, @bind_address)
+      socket.bind(sockaddr)
+      socket.listen(64) # backlog
+      puts "Listening on #{@bind_address}:#{@port}"
+
+      loop do
+        connn, _ = socket.accept # chose awkward name to avoid shadowing
+
+        if @ractor_mode
+          # Make sure @app does not get copied on Ractor.new
+          Ractor.new(@app) do |app|
+            conn = Ractor.receive
+            Server.handle(app, conn)
+            nil # reduce implicit copy on #value
+          ensure
+            conn.close
+          end.send(connn, move: true)
+        else
+          Server.handle(@app, connn)
+          connn.close
+        end
+      end
+    ensure
+      socket.close if defined?(socket)
+    end
+
+    def self.handle(app, conn)
+      request = HttpParser.parse_request(conn)
+
+      begin
+        res = app.dispatch(request)
+      rescue => e
+        error_message = [
+          "#{e.class}: #{e.message}",
+          e.backtrace&.map { |line| "\tfrom #{line}" }&.join("\n")
+        ].join("\n")
+        puts error_message
+
+        res = Response.new.tap do |r|
+          r.status = 500
+          r.headers["Content-Type"] = "text/plain"
+          r.body = "Internal Server Error\n"
+        end
+      end
+
+      reason_phrase = RFC9110_REASON_PHRASES[res.status] || "Unknown"
+
+      conn.write "HTTP/1.1 #{res.status} #{reason_phrase}\r\n"
+
+      # Send headers
+      res.headers.each do |header_name, header_body|
+        conn.write "#{header_name}: #{header_body}\r\n"
+      end
+
+      chunked = res.headers["Transfer-Encoding"] == "chunked" # ?
+
+      # Send body
+      body = res.body
+      if !chunked
+        body_str = String.new
+        body_str << body
+
+        conn.write "Content-Length: #{body_str.bytesize}\r\n"
+        conn.write "Connection: Close\r\n" # no keepalive impl (yet)
+        conn.write "\r\n"
+
+        conn.write body_str
+      else
+        conn.write "\r\n"
+
+        body.each do |chunk|
+          conn.write chunk.bytesize.to_s(16) + "\r\n"
+          conn.write chunk
+          conn.write "\r\n"
+        end
+
+        conn.write "0" + "\r\n\r\n"
+      end
+    end
+
+    module HttpParser
+      class << self
+        def parse_request(io)
+          request_line = io.gets("\r\n").chomp
+          method, request_target, _http_version = request_line.split(' ', 3)
+
+          headers = {}
+          while line = io.gets("\r\n").chomp
+          break if line.empty?
+
+            header_name, header_value = line.split(':', 2)
+            headers[header_name] = header_value.strip
+          end
+
+          path, query = request_target.split('?')
+          query ||= ''
+
+          body =
+            if length = headers['Content-Length'] # TODO: match any case
+              io.read(length.to_i)
+            else
+              nil
+            end
+
+
+          Request.new(method:, path:, query:, headers:, body:)
+        end
+      end
+    end
+  end
+end

data/lib/nuhttp/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module NuHttp
+  VERSION = "0.1.0"
+end

data/lib/nuhttp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative 'nuhttp/app'
+require_relative 'nuhttp/builder'
+require_relative 'nuhttp/context'
+require_relative 'nuhttp/router'
+require_relative 'nuhttp/version'
+
+module NuHttp
+  class Error < StandardError; end
+
+  # Entrypoint to define a NuHttp app.
+  # If a block is given, a NuHttp::Builder is yielded.
+  # If not, a bare builder will be returned.
+  # @rbs &block: (Builder) -> void
+  def self.app(&block)
+    builder = Builder.new
+    return builder if block == nil
+    block.call(builder)
+    builder.build
+  end
+
+  # Entrypoint to define a Ractor-compatible NuHttp app.
+  # Note that many features will be restricted in Ractor mode.
+  # See Ruby documentation for details on Ractor limitations.
+  # @rbs &block: (Builder) -> void
+  def self.ractor_app(&block)
+      # Ractor-compatible apps must be frozen at the time of creation
+    raise ArgumentError if block == nil
+
+    builder = Builder.new(ractor_compat: true)
+    block.call(builder)
+    builder.build
+  end
+end

data/sig/generated/nuhttp/app.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/nuhttp/app.rb with RBS::Inline
+
+module NuHttp
+  class App
+    def initialize: (untyped router) -> untyped
+
+    # The entrypoint of the request.
+    # @rbs (NuHttp::Context[untyped]) -> void
+    def dispatch: (NuHttp::Context[untyped]) -> void
+
+    def routes: () -> untyped
+  end
+end

data/sig/generated/nuhttp/builder.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/nuhttp/builder.rb with RBS::Inline
+
+module NuHttp
+  class Builder
+    def initialize: (?ractor_compat: untyped) -> untyped
+
+    def build: () -> untyped
+
+    # : (String, NuHttp::App) -> void
+    def mount: (String, NuHttp::App) -> void
+  end
+end

data/sig/generated/nuhttp/context.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/nuhttp/context.rb with RBS::Inline
+
+module NuHttp
+  # @rbs generic ParamsT
+  class Context[ParamsT]
+    def initialize: (req: untyped, route: untyped) -> untyped
+
+    def req: () -> Request[ParamsT]
+
+    def res: () -> Response
+
+    def status: (untyped code) -> untyped
+
+    def header: (untyped name, untyped value) -> untyped
+
+    # TODO: take IO and allow streaming
+    def body: (untyped str) -> untyped
+
+    # Set response to HTML `str`.
+    # Content-Type header will be set to `text/html; charset=utf-8`.
+    # : (String) -> void
+    def html: (String) -> void
+
+    # Render a template using the provided renderer and set as HTML response.
+    # : (String, ?Hash[Symbol, untyped]) -> void
+    def erb: (String, ?Hash[Symbol, untyped]) -> void
+
+    # Set response to plain text `str`.
+    # Content-Type header will be set to `text/plain; charset=utf-8`.
+    # : (String) -> void
+    def text: (String) -> void
+
+    # Set response to the JSON representation of `obj`.
+    # Content-Type header will be set to `application/json`.
+    # : (Object) -> void
+    def json: (Object) -> void
+  end
+
+  # @rbs generic ParamsT
+  class Request[ParamsT]
+    attr_reader method: untyped
+
+    attr_reader path: untyped
+
+    attr_reader query: untyped
+
+    attr_reader headers: untyped
+
+    attr_reader body: untyped
+
+    attr_accessor params: ParamsT
+
+    def initialize: (method: untyped, path: untyped, query: untyped, body: untyped, ?headers: untyped) -> untyped
+  end
+
+  class Response
+    attr_accessor status: untyped
+
+    attr_accessor headers: untyped
+
+    attr_accessor body: untyped
+
+    def initialize: () -> untyped
+  end
+end

data/sig/generated/nuhttp/herb_renderer.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/nuhttp/herb_renderer.rb with RBS::Inline
+
+module NuHttp
+  class HerbRenderer
+    def render: (untyped template_path, ?untyped locals) -> untyped
+  end
+
+  class EmptyBinding
+    def self.get_binding: () -> Binding
+  end
+end

data/sig/generated/nuhttp/rack_port.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/nuhttp/rack_port.rb with RBS::Inline
+
+module NuHttp
+  class RackPort
+    def initialize: (untyped app) -> untyped
+
+    def call: (untyped env) -> untyped
+
+    private def env_to_request: (untyped env) -> untyped
+  end
+end

data/sig/generated/nuhttp/router.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/nuhttp/router.rb with RBS::Inline
+
+module NuHttp
+  class Router
+    class Route < Data
+      attr_reader method(): untyped
+
+      attr_reader pattern(): untyped
+
+      attr_reader handler(): untyped
+
+      def self.new: (untyped method, untyped pattern, untyped handler) -> instance
+                  | (method: untyped, pattern: untyped, handler: untyped) -> instance
+
+      def self.members: () -> [ :method, :pattern, :handler ]
+
+      def members: () -> [ :method, :pattern, :handler ]
+    end
+
+    NOT_FOUND_ROUTE: untyped
+
+    def initialize: () -> untyped
+
+    def routes: () -> untyped
+
+    # @rbs (Symbol, String) -> void
+    def register_route: (Symbol, String) -> void
+
+    # @rbs (NuHttp::Request[untyped]) -> [Route, Hash[untyped, untyped]]
+    def resolve: (NuHttp::Request[untyped]) -> [ Route, Hash[untyped, untyped] ]
+  end
+end

data/sig/generated/nuhttp/server.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/nuhttp/server.rb with RBS::Inline
+
+module NuHttp
+  class Server
+    RFC9110_REASON_PHRASES: untyped
+
+    def initialize: (untyped app, ?bind: untyped, ?port: untyped, ?ractor_mode: untyped, ?call_make_shareable: untyped) -> untyped
+
+    def start: () -> untyped
+
+    def self.handle: (untyped app, untyped conn) -> untyped
+
+    module HttpParser
+      def self.parse_request: (untyped io) -> untyped
+    end
+  end
+end

data/sig/generated/nuhttp/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/nuhttp/version.rb with RBS::Inline
+
+module NuHttp
+  VERSION: ::String
+end

data/sig/generated/nuhttp.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/nuhttp.rb with RBS::Inline
+
+module NuHttp
+  class Error < StandardError
+  end
+
+  # Entrypoint to define a NuHttp app.
+  # If a block is given, a NuHttp::Builder is yielded.
+  # If not, a bare builder will be returned.
+  # @rbs &block: (Builder) -> void
+  def self.app: () { (Builder) -> void } -> untyped
+
+  # Entrypoint to define a Ractor-compatible NuHttp app.
+  # Note that many features will be restricted in Ractor mode.
+  # See Ruby documentation for details on Ractor limitations.
+  # @rbs &block: (Builder) -> void
+  def self.ractor_app: () { (Builder) -> void } -> untyped
+end

data/sig/nuhttp.rbs

@@ -0,0 +1,4 @@
+module Nuhttp
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/app_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'nuhttp'
+
+class AppTest < Minitest::Test
+  def test_basic_test
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.res.body = "Hello, World!\n"
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "Hello, World!\n", res.body
+  end
+
+  def test_subapp_mounting
+    subapp = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.text "subapp root"
+      end
+
+      b.get '/details' do |c|
+        c.text "subapp details"
+      end
+    end
+
+    app = NuHttp.app do |b|
+      b.mount '/subapp', subapp
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/subapp/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "subapp root", res.body
+
+    req = NuHttp::Request.new(method: :get, path: '/subapp/details', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "subapp details", res.body
+  end
+end

data/test/context_response_test.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'nuhttp'
+
+class ContextResponseTest < Minitest::Test
+  def test_status
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.status(201)
+        c.text("Created")
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal 201, res.status
+    assert_equal "Created", res.body
+  end
+
+  def test_header
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.status(302)
+        c.header('Location', 'https://example.com')
+        c.text("Redirecting")
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal 302, res.status
+    assert_equal 'https://example.com', res.headers['Location']
+  end
+
+  def test_html_helper
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.html("<!DOCTYPE html><html><body><h1>hello, world</h1></body></html>")
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "text/html; charset=utf-8", res.headers['Content-Type']
+    assert_equal "<!DOCTYPE html><html><body><h1>hello, world</h1></body></html>", res.body
+  end
+
+  def test_text_helper
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.text("hello, world")
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "text/plain; charset=utf-8", res.headers['Content-Type']
+    assert_equal "hello, world", res.body
+  end
+
+  def test_json_helper
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.json({hello: "world"})
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+    assert_equal "application/json", res.headers['Content-Type']
+    assert_equal '{"hello":"world"}', res.body
+  end
+end

data/test/herb_renderer_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'nuhttp'
+require 'nuhttp/herb_renderer'
+
+class HerbRendererTest < Minitest::Test
+  def setup
+    @htmlerb_file = Tempfile.open("greeting.html.erb")
+    @htmlerb_file.tap {|f| f.write("<p>hello, <%= name %></p>\n"); f.flush }
+  end
+
+  def teardown
+    @htmlerb_file.close!
+  end
+
+  def test_renders_template
+    html = NuHttp::HerbRenderer.new.render(@htmlerb_file.path, name: "world")
+    assert_equal "<p>hello, world</p>\n", html
+  end
+
+  def test_context_render_sets_html_response
+    app = NuHttp.app do |b|
+      b.get '/' do |c|
+        c.erb(@htmlerb_file.path, { name: "world" })
+      end
+    end
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    res = app.dispatch(req)
+
+    assert_equal "text/html; charset=utf-8", res.headers['Content-Type']
+    assert_equal "<p>hello, world</p>\n", res.body
+  end
+end

data/test/rack_port_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'nuhttp'
+require 'nuhttp/rack_port'
+
+class RackPortTest < Minitest::Test
+  def test_env_to_request_bare_request
+    env = {
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/',
+      'QUERY_STRING' => ''
+    }
+    req = NuHttp::RackPort.new(env).send(:env_to_request, env)
+
+    assert_equal 'GET', req.method
+    assert_equal '/', req.path
+    assert_equal '', req.query
+    assert_equal({}, req.headers)
+  end
+
+  def test_env_to_request_with_headers
+    env = {
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/',
+      'QUERY_STRING' => '',
+      'CONTENT_LENGTH' => '42',
+      'CONTENT_TYPE' => 'text/plain',
+      'HTTP_HOST' => 'example.com',
+      'HTTP_X_CUSTOM_HEADER' => 'CustomValue'
+    }
+    req = NuHttp::RackPort.new(env).send(:env_to_request, env)
+
+    assert_equal 'GET', req.method
+    assert_equal '/', req.path
+    assert_equal '', req.query
+    assert_equal({
+      'Content-Length' => 42,
+      'Content-Type' => 'text/plain',
+      'Host' => 'example.com',
+      'X-Custom-Header' => 'CustomValue'
+    }, req.headers)
+  end
+
+  def test_env_to_request_with_body
+    env = {
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/',
+      'QUERY_STRING' => ''
+    }
+    req = NuHttp::RackPort.new(env).send(:env_to_request, env)
+
+    assert_equal 'GET', req.method
+    assert_equal '/', req.path
+    assert_equal '', req.query
+    assert_equal({}, req.headers)
+  end
+end

data/test/router_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'nuhttp'
+
+class RouterTest < Minitest::Test
+  def test_root_path_routing
+    router = NuHttp::Router.new
+    router.register_route(:get, '/')
+
+    req = NuHttp::Request.new(method: :get, path: '/', query: '', body: nil)
+    resolved = router.resolve(req)[0]
+    assert_equal :get, resolved.method
+    assert_equal '/', resolved.pattern
+  end
+
+  def test_toplevel_path_routing
+    router = NuHttp::Router.new
+    router.register_route(:get, '/top')
+
+    req = NuHttp::Request.new(method: :get, path: '/top', query: '', body: nil)
+    resolved = router.resolve(req)[0]
+    assert_equal :get, resolved.method
+    assert_equal '/top', resolved.pattern
+  end
+
+  def test_notfound_path_routing
+    router = NuHttp::Router.new
+
+    req = NuHttp::Request.new(method: :get, path: '/nonexistent', query: '', body: nil)
+    resolved = router.resolve(req)[0]
+    assert_equal :internal, resolved.method
+    assert_nil resolved.pattern
+  end
+end