RubyGems - nuhttp - Versions diffs - 0.1.0 - Mend

nuhttp 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

checksums.yaml +7 -0
data/LICENSE.txt +21 -0
data/README.md +161 -0
data/Rakefile +8 -0
data/exe/nuhttp-typegen +116 -0
data/lib/nuhttp/app.rb +26 -0
data/lib/nuhttp/builder.rb +57 -0
data/lib/nuhttp/context.rb +98 -0
data/lib/nuhttp/herb_renderer.rb +28 -0
data/lib/nuhttp/rack_port.rb +44 -0
data/lib/nuhttp/router.rb +56 -0
data/lib/nuhttp/server.rb +184 -0
data/lib/nuhttp/version.rb +6 -0
data/lib/nuhttp.rb +36 -0
data/sig/generated/nuhttp/app.rbs +13 -0
data/sig/generated/nuhttp/builder.rbs +12 -0
data/sig/generated/nuhttp/context.rbs +65 -0
data/sig/generated/nuhttp/herb_renderer.rbs +11 -0
data/sig/generated/nuhttp/rack_port.rbs +11 -0
data/sig/generated/nuhttp/router.rbs +32 -0
data/sig/generated/nuhttp/server.rbs +17 -0
data/sig/generated/nuhttp/version.rbs +5 -0
data/sig/generated/nuhttp.rbs +18 -0
data/sig/nuhttp.rbs +4 -0
data/test/app_test.rb +42 -0
data/test/context_response_test.rb +74 -0
data/test/herb_renderer_test.rb +35 -0
data/test/rack_port_test.rb +58 -0
data/test/router_test.rb +35 -0
data/typecheck.png +0 -0
metadata +128 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db78e734229dea342e80d93536d72bd6906242131c5124eaafb9f126e1a00d79
+  data.tar.gz: 04b6a209dbb3e16160ee969794b88a7c73f4b4eecd8d092001aad1f36fbc9d0d
+SHA512:
+  metadata.gz: 973b701098bff442003f20c842cd290178fc4a064dff3f726bcb04d89e2594f7bb9ddc4baea0f5fdacf1070fe98110281c35ed4fc774577ca17f41421183e34f
+  data.tar.gz: df143a6aa9ec6c6c895c856498e810435b66fd86a3c5beeaacbaf09277a9afda0eacd143be275752bcf21116d3352f418663adcfac087bfbc13e96ffec12a364

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2025 Daisuke Aritomo
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,161 @@
+# NuHttp
+A new (_nu_) and compact HTTP server library for Ruby.
+## Features
+- **Compact API.** Good for embedding in tools.
+- **Some typing support.** NuHttp API is (or should be) mostly typed. `params` also recieve types based on path patterns.
+- **Ractor mode.** Explore true concurrency!
+To be implemented: Performance, profiling, benchmarking
+## Usage
+NuHttp apps are defined in `NuHttp.app` blocks.
+```ruby
+require 'nuhttp'
+require 'nuhttp/server'
+world = "World"
+App = NuHttp.app do |b|
+  b.get '/' do |c|
+    c.res.body = "Hello, #{world}!\n"
+  end
+  b.get '/json' do |c|
+    c.json({ message: "Hello, #{world}!" })
+  end
+  b.get '/users/:id' do |c|
+    user_id = c.req.params[:id]
+    c.json({ user_id: user_id })
+  end
+  b.get '/html' do |c|
+    c.html("<!DOCTYPE html><html> ... </html>")
+  end
+  b.get '/erb' do |c|
+    # HTML+ERB support by Herb (https://github.com/marcoroth/herb)
+    # `herb` gem must be installed to use c.erb
+    c.erb("/path/to/view.html.erb", { my_variable: 1 })
+  end
+end
+NuHttp::Server.new(App).start
+```
+### As an Rack app
+While NuHttp ships its own HTTP server, NuHttp apps may be mounted on other servers that implement the Rack spec. Common choices are [Puma](https://github.com/puma/puma), [Unicorn](https://yhbt.net/unicorn/), and [Falcon](https://github.com/socketry/falcon).
+Define a `config.ru` file:
+```ruby
+# config.ru
+App = NuHttp.app do |b|
+  b.get '/' do |c|
+    # ...
+  end
+end
+run NuHttp::RackAdapter.new(App)
+```
+... then run the server of your choice.
+```
+$ puma
+```
+### Typing support on `c.req.params`
+[Steep](https://github.com/soutaro/steep) users may benefit from generated type signatures for `c.req.params`.
+![](/typecheck.png)
+Run `nuhttp-typegen` to scan `*.rb` files and generate types.
+```
+nuhttp-typegen > sig/app.rbs
+```
+### Ractor Mode! (Ruby 4.0+)
+Accept the challenge of making your app _Ractor shareable_! The HTTP server shipped with NuHttp spawns a new Ractor for each request, allowing requests to be served in a truly parallel manner.
+Define your app using`NuHttp.ractor_app` and start the server with `NuHttp::Server.new(app, ractor_mode: true).start`:
+```ruby
+require 'nuhttp'
+require 'nuhttp/server'
+App = NuHttp.ractor_app do |b|
+  # Think of each handlerbeing executed in Ractor.new { }
+  b.get '/' do |c|
+    # ...
+  end
+end
+NuHttp::Server.new(App, ractor_mode: true).start
+```
+Ractor mode brings many restrictions on what can be done in handlers. While you don't have to directly call `Ractor.new` in your code, you should read [ractor.md](https://docs.ruby-lang.org/en/master/language/ractor_md.html) in the Ruby docs for a good understanding of Ractors.
+Ractor mode requires `Ractor.shareable_proc`, a Ruby 4.0+ API ([Feature #21157](https://bugs.ruby-lang.org/issues/21557)).
+## FAQ
+### How is this different from Sinatra?
+One key difference is the context where the handler is evaluated.
+In Sinatra, this code raises:
+```ruby
+x = "world"
+class App < Sinatra::Base
+  get '/' do
+    "hello, #{x}"
+  end
+end
+```
+```
+NameError: undefined local variable or method 'x' for an instance of App (NameError)
+    "hello, #{x}"
+              ^
+```
+## Installation
+Install the gem and add to the application's Gemfile by executing:
+```bash
+bundle add nuhttp
+```
+If bundler is not being used to manage dependencies, install the gem by executing:
+```bash
+gem install nuhttp
+```
+## Development
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/osyoyu/nuhttp.
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile ADDED Viewed

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "minitest/test_task"
+task default: %i[]
+Minitest::TestTask.create(:test)

data/exe/nuhttp-typegen ADDED Viewed

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require 'stringio'
+require 'prism'
+class RouteCollector < Prism::Visitor
+  attr_reader :routes
+  def initialize
+    super()
+    @routes = {
+      get: [],
+      post: [],
+    }
+  end
+  def visit_call_node(node)
+    if node.name == :app
+      block = node.block
+      self.visit(block) if block
+    end
+    if [:get, :post].include?(node.name)
+      http_method = node.name
+      path = node.arguments.arguments.first
+      return nil if !path.is_a?(Prism::StringNode)
+      path_pattern = path.unescaped
+      # Check for dups
+      return if @routes[http_method].any? {|r| r[:path_pattern] == path_pattern }
+      param_names = extract_param_names(path.unescaped)
+      rbs_interface_name = if param_names.size == 0
+        "params_none"
+      else
+        "params_" + path_pattern.gsub(/[:\/]/, '_').gsub(/[^a-zA-Z0-9_]/, '')
+      end
+      @routes[http_method] << {
+        path_pattern:, param_names:, rbs_interface_name:,
+      }
+      nil
+    end
+  end
+  def extract_param_names(path_pattern)
+    param_names = []
+    path_pattern.scan(/:([a-zA-Z_][a-zA-Z0-9_]*)/) do |match|
+      param_names << match.first
+    end
+    param_names
+  end
+end
+class RbsEmitter
+  def initialize(routes, io = $stdout)
+    @routes = routes
+    @io = io
+  end
+  def emit
+    @io.puts <<-__EOS__
+# Type signature generated by nuhttp-typegen. DO NOT EDIT.
+module NuHttp
+  class Builder
+    type params_none = Hash[Symbol, String]
+__EOS__
+    # Interfaces for params
+    (@routes[:get] + @routes[:post]).each do |route|
+      next if route[:param_names].empty?
+      @io.puts <<-__EOS__
+    type #{route[:rbs_interface_name]} = Hash[(#{route[:param_names].map {|n| ":#{n}" }.join(" | ")}), String]
+__EOS__
+    end
+    @io.puts ""
+    # GET
+    types = @routes[:get].map do |route|
+      "(\"#{route[:path_pattern]}\") { (Context[#{route[:rbs_interface_name]}]) -> void } -> untyped"
+    end
+    types << "(untyped path) { (Context[params_none]) -> void } -> untyped"
+    @io.print <<-__EOS__
+    def get: #{types.join("\n           | ")}
+__EOS__
+    @io.puts ""
+    # POST
+    types = @routes[:post].map do |route|
+      "(\"#{route[:path_pattern]}\") { (Context[#{route[:rbs_interface_name]}]) -> void } -> untyped"
+    end
+    types << "(untyped path) { (Context[params_none]) -> void } -> untyped"
+    @io.print <<-__EOS__
+    def post: #{types.join("\n            | ")}
+__EOS__
+    @io.puts ""
+    @io.print <<-__EOS__
+  end
+end
+__EOS__
+  end
+end
+paths = Dir.glob("**/*.rb")
+visitor = RouteCollector.new
+paths.each do |path|
+  parsed = Prism.parse(File.read(path))
+  visitor.visit(parsed.value)
+end
+RbsEmitter.new(visitor.routes).emit

data/lib/nuhttp/app.rb ADDED Viewed

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+module NuHttp
+  class App
+    def initialize(router)
+      @router = router
+    end
+    # The entrypoint of the request.
+    # @rbs (NuHttp::Context[untyped]) -> void
+    def dispatch(req)
+      route, params = @router.resolve(req)
+      # Create a new Context
+      ctx = Context.new(req:, route:)
+      # Populate req.params
+      req.params = params
+      route.handler.call(ctx)
+      ctx.res
+    end
+    def routes
+      @router.routes
+    end
+  end
+end

data/lib/nuhttp/builder.rb ADDED Viewed

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+module NuHttp
+  class Builder
+    def initialize(ractor_compat: false)
+      @router = Router.new
+      @ractor_compat = ractor_compat
+    end
+    def build
+      if @ractor_compat
+        @router.routes.freeze
+        Ractor.make_shareable @router
+        raise if !Ractor.shareable?(@router)
+      end
+      App.new(@router).tap do |app|
+        app.freeze if @ractor_compat
+      end
+    end
+    # The `nuhttp-typegen` tool can be used to generated RBS type signatures
+    # tailored for each app.
+    # @rbs skip
+    def get(path, &block)
+      if @ractor_compat
+        shareable_block = Ractor.shareable_proc(&block)
+        @router.register_route(:get, path, &shareable_block)
+      else
+        @router.register_route(:get, path, &block)
+      end
+    end
+    # The `nuhttp-typegen` tool can be used to generated RBS type signatures
+    # tailored for each app.
+    # @rbs skip
+    def post(path, &block)
+      if @ractor_compat
+        shareable_block = Ractor.shareable_proc(&block)
+        @router.register_route(:post, path, &shareable_block)
+      else
+        @router.register_route(:post, path, &block)
+      end
+    end
+    #: (String, NuHttp::App) -> void
+    def mount(path, subapp)
+      subapp.routes.each do |route|
+        @router.register_route(
+          route.method,
+          path + route.pattern,
+          &route.handler
+        )
+      end
+    end
+  end
+end

data/lib/nuhttp/context.rb ADDED Viewed

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+module NuHttp
+  # @rbs generic ParamsT
+  class Context
+    def initialize(req:, route:)
+      @req = req
+      @res = Response.new
+      @herb_renderer_loaded = false
+      @json_loaded = false
+    end
+    def req #: Request[ParamsT]
+      @req
+    end
+    def res #: Response
+      @res
+    end
+    def status(code)
+      res.status = code
+    end
+    def header(name, value)
+      res.headers[name] = value
+    end
+    # TODO: take IO and allow streaming
+    def body(str)
+      res.body = str
+    end
+    # Set response to HTML `str`.
+    # Content-Type header will be set to `text/html; charset=utf-8`.
+    #: (String) -> void
+    def html(str)
+      res.headers['Content-Type'] = 'text/html; charset=utf-8'
+      res.body = str
+    end
+    # Render a template using the provided renderer and set as HTML response.
+    #: (String, ?Hash[Symbol, untyped]) -> void
+    def erb(template_path, locals = {})
+      require_relative './herb_renderer' if !@herb_renderer_loaded
+      rendered = HerbRenderer.new.render(template_path, locals)
+      html(rendered)
+    end
+    # Set response to plain text `str`.
+    # Content-Type header will be set to `text/plain; charset=utf-8`.
+    #: (String) -> void
+    def text(str)
+      res.headers['Content-Type'] = 'text/plain; charset=utf-8'
+      res.body = str
+    end
+    # Set response to the JSON representation of `obj`.
+    # Content-Type header will be set to `application/json`.
+    #: (Object) -> void
+    def json(obj)
+      require 'json' if !@json_loaded
+      res.headers['Content-Type'] = 'application/json'
+      res.body = JSON.generate(obj)
+    end
+  end
+  # @rbs generic ParamsT
+  class Request
+    attr_reader :method, :path, :query, :headers, :body
+    attr_accessor :params #: ParamsT
+    def initialize(method:, path:, query:, headers: {}, body:)
+      @method = method
+      @path = path
+      @query = query
+      @headers = headers
+      @body = body
+      @params = {}
+    end
+  end
+  class Response
+    attr_accessor :status, :headers, :body
+    def initialize
+      @status = 200
+      @headers = {}
+      @body = ""
+    end
+  end
+end

data/lib/nuhttp/herb_renderer.rb ADDED Viewed

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+require 'herb'
+module NuHttp
+  class HerbRenderer
+    def render(template_path, locals = {})
+      template_src = File.read(template_path)
+      engine = Herb::Engine.new(template_src, filename: template_path)
+      erbctx = EmptyBinding.get_binding
+      locals.each do |name, value|
+        erbctx.local_variable_set(name, value)
+      end
+      # Herb::Engine generates Ruby code that returns the rendered string when evaluated
+      ruby_src = engine.src
+      eval(ruby_src, erbctx)
+    end
+  end
+  class EmptyBinding
+    def self.get_binding #: Binding
+      binding
+    end
+  end
+end

data/lib/nuhttp/rack_port.rb ADDED Viewed

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+require 'rack'
+module NuHttp
+  class RackPort
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      req = env_to_request(env)
+      res = @app.dispatch(req)
+      [res.status, res.headers, [res.body]]
+    end
+    private def env_to_request(env)
+      method = env['REQUEST_METHOD']
+      path = env['PATH_INFO'] || '/'
+      query = env['QUERY_STRING'] || ''
+      # Extract request headers
+      # Racks stores headers in the env with 'HTTP_' prefix, with the
+      # exception of Content-Type and Content-Length
+      headers = {}
+      if env['CONTENT_TYPE']
+        headers['Content-Type'] = env['CONTENT_TYPE']
+      end
+      if env['CONTENT_LENGTH']
+        headers['Content-Length'] = env['CONTENT_LENGTH'].to_i
+      end
+      env.each do |key, value|
+        header_name = key.start_with?('HTTP_') ? key[5..].split('_').map(&:capitalize).join('-') : nil
+        if header_name
+          headers[header_name] = value
+        end
+      end
+      Request.new(method:, path:, query:, headers:, body: '')
+    end
+  end
+end

data/lib/nuhttp/router.rb ADDED Viewed

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+module NuHttp
+  class Router
+    Route = Data.define(:method, :pattern, :handler)
+    NOT_FOUND_ROUTE = Route.new(
+      method: :internal,
+      pattern: nil,
+      handler: Ractor.shareable_proc do |c|
+        c.res.status = 404
+        c.res.body = "Not Found\n"
+      end
+    )
+    def initialize
+      @routes = []
+    end
+    def routes
+      @routes
+    end
+    # @rbs (Symbol, String) -> void
+    def register_route(method, pattern, &block)
+     @routes << Route.new(method:, pattern:, handler: block)
+    end
+    # @rbs (NuHttp::Request[untyped]) -> [Route, Hash[untyped, untyped]]
+    def resolve(req)
+      @routes.each do |route|
+        # Turn the user supplied pattern into a regexp that captures named params.
+        param_names = []
+        regexp = /\A#{route.pattern.gsub(/:[^\/]+/) {|segment|
+          param_names << segment.delete_prefix(':')
+              "([^/]+)"
+        }}\z/
+        # Test if the request path matches the route pattern
+        match = regexp.match(req.path)
+        next unless match
+        params = {}
+        param_names.each.with_index do |name, index|
+          params[name.to_sym] = match.captures[index]
+        end
+        return [route, params]
+      end
+      # If no route matches, return a fixed 404 response
+      [NOT_FOUND_ROUTE, {}]
+    end
+  end
+end