kino 0.1.0-aarch64-linux

data/lib/kino/templates/kino.rb.tt

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+# Kino configuration.
+# Generated by `kino --init`.
+#
+# Every setting below is shown with its default value, commented out:
+# the file is a valid no-op until you uncomment something. Precedence:
+# explicit Server.new kwargs / CLI flags > this file > built-in defaults.
+
+## Network
+
+# Address to listen on. Use "0.0.0.0" to accept non-local connections.
+# bind "127.0.0.1"
+
+# Port to listen on. 0 picks an ephemeral port (readable via server.port).
+# The `kino` CLI defaults this to 9292 when nothing else sets it.
+# port 9292
+
+# TLS termination (rustls, in Rust; never blocks a Ruby thread).
+# Values are file paths or inline PEM strings. ALPN is http/1.1.
+# tls cert: "config/certs/server.pem", key: "config/certs/server.key"
+
+## Topology
+
+# Puma-style two-level topology: `workers` × `threads`.
+#
+# In :ractor mode, `workers` is the number of worker Ractors: true
+# multi-core parallelism for Ruby CPU work, one per core is a good start.
+# In :threaded mode the same total (workers × threads) runs as plain
+# Threads on the main ractor.
+
+# Defaults to the number of CPU cores (Etc.nprocessors).
+# workers 8
+
+# Threads per worker. Threads inside one ractor share its lock, so they
+# only add concurrency where handlers block on I/O (database calls, HTTP).
+# CPU-bound apps gain nothing past 1 (and pay a lock-handoff tax: threads 1
+# measured +17% on fast handlers). I/O-heavy apps want more SLOTS overall -
+# in :ractor mode prefer raising `workers` over `threads` (slots are cheap,
+# no fork memory): 32 workers x 1 thread beat 8x3 by +35% on waits.
+# threads 3
+
+## Dispatch mode
+#
+# :auto:     :ractor when the app is Ractor-shareable, else :threaded
+#             (with a warning). Note: a Class used as a Rack app always
+#             counts as "shareable" even if calling it touches unshareable
+#             state; force :threaded for those.
+# :ractor:   require a Ractor-shareable app; raises
+#             Kino::UnshareableAppError otherwise. The app must capture
+#             nothing mutable: frozen middleware, Ractor.shareable_proc
+#             endpoints.
+# :threaded: run ANY Rack app (Rails included) on a classic thread pool.
+# mode :auto
+
+## Backpressure
+
+# Bounded request queue between the Rust front-end and Ruby workers.
+# When it stays full past queue_timeout, clients get an immediate 503
+# instead of waiting forever.
+# queue_depth 1024
+
+# Seconds a request may wait for queue space before the 503.
+# queue_timeout 1.0
+
+# Seconds the app gets to produce a response before the client receives a
+# 504 instead. Off by default (nil = wait forever). The handler is NOT
+# killed - its late response is dropped and its slot stays busy until it
+# returns, so size this above your slowest legitimate endpoint.
+# request_timeout 30
+
+# Requests a worker may grab per queue visit. Values above 1 squeeze more
+# throughput out of uniformly fast handlers, but add head-of-line blocking
+# behind slow ones and stretch the effective queue depth - leave at 1
+# unless your handlers are all sub-millisecond.
+# batch 1
+
+# EXPERIMENTAL lane dispatch: per-worker queues with awake-preferring
+# assignment and work stealing. Cuts per-request wakeups for uniformly
+# fast handlers; semantics under overload are slightly different (per-lane
+# caps with brief dispatcher retries instead of one global queue).
+# lanes false
+
+# Native access log: one line per request to stdout, written by a
+# Rust-side flusher thread - request threads never block on the log.
+#
+# On color terminals lines are tinted by status class (2xx green,
+# 3xx yellow, 4xx maroon, 5xx bright red). This is the SERVER's view - it
+# includes the 503 rejections your app never sees - and it interleaves
+# cleanly with your app's own log (e.g. Rails') on stdout. See also
+# Kino::Logger for routing the app log through the same async sink.
+#
+# Try enabling it in the development environment.
+# log_requests false
+
+## Lifecycle
+
+# Graceful-shutdown drain deadline in seconds: in-flight requests get this
+# long to finish; past it, their clients receive 500s and workers are
+# reaped. A second INT/TERM force-exits immediately.
+# shutdown_timeout 30
+
+# Write the master PID here on start; removed on graceful shutdown.
+# pidfile "tmp/pids/kino.pid"
+
+## Runtime
+
+# Threads for the tokio (Rust I/O) runtime. Default (nil) lets tokio use
+# one per core: right for I/O-heavy apps. For CPU-heavy apps this is a
+# real lever: `tokio_threads 1` + `threads 1` measured +26% on a pure-CPU
+# benchmark (every spare thread is Ruby work you didn't run).
+# tokio_threads 4
+
+## App
+
+# Rackup file the `kino` CLI loads (positional CLI argument wins).
+# rackup "config.ru"
+
+# Sets RACK_ENV (unless already set) before the app is loaded by the CLI.
+# environment "production"
+
+## Rails
+#
+# Rails runs on Kino TODAY in :threaded mode; uncomment for a Rails app:
+#
+#   mode :threaded
+#   environment "production"
+#   threads 5                 # match your database pool size
+#
+# Recommended Rails-side settings to pair with Kino:
+#   - config.eager_load = true and no code reloading (production defaults):
+#     Kino's workers serve concurrently; lazy class loading under
+#     concurrency is slow and, in ractor mode, unsafe.
+#   - Database pool >= workers × threads (config/database.yml `pool:`).
+#   - Rails.logger goes to stdout/stderr or a thread-safe device.
+#
+# Rails main is being ractorized, but
+# Rails.application still captures unshareable state at boot; known
+# blockers are documented in Kino's README. Track rails/rails main; when
+# Ractor.make_shareable(Rails.application) succeeds, `mode :ractor` here
+# is all you'll need to change.

data/lib/kino/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Kino
+  # The gem version (single source of truth; ext/kino/Cargo.toml syncs).
+  VERSION = "0.1.0"
+end

data/lib/kino/worker.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Kino
+  # @private
+  # The request loop. Identical for threaded and ractor modes.
+  #
+  # The default (batch 1) hot path allocates one Hash per request: the env
+  # arrives with the native request handle embedded under "kino.request",
+  # and the common complete-body response rides the fused
+  # respond_and_take_one call: ~one FFI crossing per request, no arrays.
+  #
+  # batch > 1 trades fairness for throughput: a worker grabs up to that
+  # many already-queued requests per crossing, adding head-of-line blocking
+  # behind slow handlers and stretching effective queue depth.
+  module Worker
+    RACK_INPUT = "rack.input"
+    KINO_REQUEST = "kino.request"
+
+    module_function
+
+    def run(server_id, worker_id, app, batch_size = 1)
+      if batch_size <= 1
+        env = Native.take_one(server_id, worker_id)
+        env = handle_one(env, server_id, worker_id, app) while env
+      else
+        batch = Native.take_batch(server_id, worker_id, batch_size)
+        batch = process(batch, server_id, worker_id, app, batch_size) while batch
+      end
+    end
+
+    # serve() returns this when the response did NOT ride a fused
+    # respond-and-take (streaming body or app error) and the caller must
+    # take the next request itself. Frozen: worker ractors read it.
+    NOT_FUSED = Object.new.freeze
+
+    # Handle one request; returns the next env (fused take) or nil.
+    def handle_one(env, server_id, worker_id, app)
+      result = serve(env, app) do |request, status, headers, chunks|
+        request.respond_and_take_one(server_id, worker_id, status, headers, chunks)
+      end
+      result.equal?(NOT_FUSED) ? Native.take_one(server_id, worker_id) : result
+    end
+
+    # Handle every env in the batch; returns the next batch (the last
+    # simple response rides the fused respond_and_take) or nil on shutdown.
+    def process(batch, server_id, worker_id, app, batch_size)
+      last = batch.size - 1
+      batch.each_with_index do |env, index|
+        result = serve(env, app) do |request, status, headers, chunks|
+          if index == last
+            request.respond_and_take(server_id, worker_id, batch_size,
+              status, headers, chunks)
+          else
+            request.send_simple(status, headers, chunks)
+            NOT_FUSED
+          end
+        end
+        return result if index == last && !result.equal?(NOT_FUSED)
+      end
+      Native.take_batch(server_id, worker_id, batch_size)
+    end
+
+    # Run one request through the app. Complete bodies are yielded so the
+    # caller picks plain vs fused delivery (the block's return value passes
+    # through after the body is closed); streaming bodies are delivered
+    # here and return NOT_FUSED. App errors must never kill the worker;
+    # hard crashes (Exception) are the supervisor's job; and `abort` does
+    # the right thing whether or not the response head already went out.
+    def serve(env, app)
+      request = env[KINO_REQUEST]
+      env[RACK_INPUT] ||= Input.new(request)
+      status, headers, body = app.call(env)
+
+      if body.respond_to?(:to_ary)
+        result = yield(request, status.to_i, headers, join_chunks(body.to_ary))
+        body.close if body.respond_to?(:close)
+        result
+      else
+        deliver_streaming(request, status.to_i, headers, body, env[RACK_INPUT])
+        NOT_FUSED
+      end
+    rescue => e
+      Native.log_error("#{e.class}: #{e.message}")
+      request.abort
+      NOT_FUSED
+    end
+
+    def deliver_streaming(request, status, headers, body, input)
+      request.send_headers(status, headers)
+      if body.respond_to?(:call) && !body.respond_to?(:each)
+        # Rack 3 streaming body: the app drives a full-duplex stream whose
+        # read side is the request's existing rack.input (a fresh Input
+        # here would strand anything the app already buffered from it).
+        stream = Stream.new(request, input)
+        begin
+          body.call(stream)
+        ensure
+          stream.close
+        end
+      else
+        # Enumerable body: chunked transfer unless the app set content-length.
+        begin
+          body.each { |chunk| request.write_chunk(chunk) }
+        ensure
+          request.finish
+          body.close if body.respond_to?(:close)
+        end
+      end
+    end
+
+    def join_chunks(chunks)
+      # Single-chunk bodies (the common case) skip the join copy entirely:
+      # the native layer reads raw bytes, so encoding doesn't matter.
+      return chunks.first || "" if chunks.size <= 1
+
+      joined = (+"").force_encoding(Encoding::BINARY)
+      chunks.each { |chunk| joined << chunk.b }
+      joined
+    end
+
+    private_class_method :handle_one, :process, :serve, :deliver_streaming,
+      :join_chunks
+  end
+end

data/lib/kino.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "kino/version"
+require "kino/kino"
+
+# A high-performance Ractor web server for Ruby 4.0+: Rack 3-based, with
+# a Rust (tokio + hyper) front-end and Ractor-parallel Ruby workers, plus
+# a threaded fallback mode for apps (such as Rails) that are not
+# Ractor-shareable.
+#
+# The public API is {Kino::Server}, {Kino::Configuration}, {Kino::Check},
+# {Kino::Logger}, and {Kino.sleep}; the `kino` executable is implemented
+# by {Kino::CLI}.
+module Kino
+  # Base class for all errors raised by Kino.
+  class Error < StandardError; end
+
+  # Raised when mode: :ractor is forced but the app is not Ractor-shareable.
+  class UnshareableAppError < Error; end
+
+  # High-resolution sleep that bypasses the VM timer (whose wakeups inside
+  # non-main ractors are coarse: ~+2.5ms on Linux). Sleeps on the OS clock
+  # with the GVL released; chunked so Thread#kill and shutdown interrupts
+  # are honored between chunks.
+  #
+  # @param seconds [Numeric] how long to sleep; must be non-negative
+  # @return [nil]
+  # @raise [ArgumentError] for negative or non-numeric durations
+  def self.sleep(seconds)
+    remaining = Float(seconds)
+    raise ArgumentError, "sleep duration must be non-negative" if remaining.negative?
+
+    remaining = Native.sleep_chunk(remaining) while remaining.positive?
+    nil
+  end
+end
+
+require_relative "kino/cli"
+require_relative "kino/logger"
+require_relative "kino/check"
+require_relative "kino/input"
+require_relative "kino/null_input"
+require_relative "kino/errors_stream"
+require_relative "kino/stream"
+require_relative "kino/configuration"
+require_relative "kino/worker"
+require_relative "kino/ractor_supervisor"
+require_relative "kino/server"
+
+# Hand the frozen shareable singletons to the native layer: it sets them
+# straight into each request's env, so the worker loop allocates neither
+# an errors stream nor (for bodyless requests) an input object.
+Kino::Native.register_defaults(Kino::ErrorsStream::INSTANCE, Kino::NullInput::INSTANCE)

data/sig/kino.rbs

@@ -0,0 +1,178 @@
+# Public interfaces only. Internals (Kino::Worker, Kino::RactorSupervisor,
+# Kino::Input, Kino::NullInput, Kino::ErrorsStream, Kino::Stream,
+# Kino::Native) are deliberately unsigned: they are implementation detail
+# and may change without notice.
+module Kino
+  VERSION: String
+
+  # Any Rack 3 application: responds to #call(env) with [status, headers, body].
+  type rack_app = untyped
+
+  type stats_hash = Hash[Symbol, untyped]
+
+  class Error < StandardError
+  end
+
+  # Raised when mode: :ractor is forced but the app is not Ractor-shareable.
+  class UnshareableAppError < Error
+  end
+
+  # High-resolution sleep on the OS clock with the GVL released.
+  def self.sleep: (Numeric seconds) -> nil
+
+  class Server
+    attr_reader port: Integer?
+    attr_reader mode: Symbol
+    attr_reader bind: String
+
+    def tls?: () -> bool
+
+    # Settings precedence: explicit kwargs > config_file DSL > defaults.
+    def initialize: (rack_app app, ?config_file: String?, **untyped options) -> void
+
+    def start: () -> self
+
+    # Graceful shutdown: drain to the deadline, then abort stragglers.
+    def shutdown: (?timeout: Numeric?) -> nil
+
+    def wait: () -> untyped
+
+    # Live snapshot: config echo plus native counters (queued, in_flight,
+    # served, rejected, timeouts, respawns, lane_depths when lanes are on).
+    def stats: () -> stats_hash
+
+    # Production entry point: start, banner, signal traps, block until done.
+    def self.run: (rack_app app, **untyped opts) -> Server
+
+    # INT/TERM drain gracefully (second signal force-exits); USR1 prints stats.
+    def self.trap_signals: (Server server) -> void
+  end
+
+  class Configuration
+    DEFAULTS: Hash[Symbol, untyped]
+    SETTINGS: Array[Symbol]
+    SAMPLE_TEMPLATE: String
+
+    # The fully commented sample config (see `kino --init`).
+    def self.sample: () -> String
+
+    # Write the sample config to path; raises Kino::Error if it exists
+    # unless force. Returns the path.
+    def self.write_sample: (String path, ?force: bool) -> String
+
+    def initialize: () -> void
+
+    def []: (Symbol key) -> untyped
+
+    # Raises ArgumentError for keys outside DEFAULTS.
+    def set: (Symbol key, untyped value) -> untyped
+
+    def set?: (Symbol key) -> bool
+
+    # Evaluate a Puma-style Ruby DSL config file into this configuration.
+    def load_file: (String path) -> self
+
+    def merge!: (Hash[Symbol, untyped] options) -> self
+
+    def to_h: () -> Hash[Symbol, untyped]
+
+    # to_h minus the CLI-only keys (:rackup, :environment); what Server.new
+    # accepts.
+    def server_options: () -> Hash[Symbol, untyped]
+
+    # The config-file DSL: one method per directive.
+    class DSL
+      def initialize: (Configuration config) -> void
+
+      def bind: (String host) -> untyped
+      def port: (int port) -> untyped
+      def workers: (int count) -> untyped
+      def threads: (int count) -> untyped
+      def mode: (Symbol | String mode) -> untyped
+      def queue_depth: (int depth) -> untyped
+      def queue_timeout: (Numeric seconds) -> untyped
+      def request_timeout: (Numeric? seconds) -> untyped
+      def batch: (int count) -> untyped
+      def lanes: (boolish enabled) -> untyped
+      def log_requests: (boolish enabled) -> untyped
+      def shutdown_timeout: (Numeric seconds) -> untyped
+      def tokio_threads: (int count) -> untyped
+      def tls: (cert: String, key: String) -> untyped
+      def environment: (String | Symbol env) -> untyped
+      def pidfile: (String path) -> untyped
+      def rackup: (String path) -> untyped
+    end
+  end
+
+  # The `kino` executable plus startup presentation shared with Server.run.
+  module CLI
+    MOTD: String
+
+    # Parse argv, then init/check/serve. Returns the process exit status
+    # (-v and -h print and exit in place per optparse convention).
+    def self.start: (Array[String] argv) -> Integer
+
+    # True when output to io may use ANSI styling.
+    def self.color?: (?IO io) -> bool
+
+    # Wrap text in an SGR code, resetting at the end; plain on non-color io.
+    def self.paint: (String code, String text, ?io: IO) -> String
+
+    def self.dim: (String text, ?io: IO) -> String
+
+    def self.bold: (String text, ?io: IO) -> String
+
+    def self.red: (String text, ?io: IO) -> String
+
+    # The banner with a vertical grayscale gradient.
+    def self.motd: (?color: bool) -> String
+
+    # One-line stats dump (the SIGUSR1 handler's output).
+    def self.stats_line: (stats_hash stats) -> String
+
+    # The two banner halves around Server#start.
+    def self.opening_credits: () -> void
+    def self.action!: (Server server) -> void
+
+    # Print a bold "Fin." when the process ends (idempotent).
+    def self.fin_at_exit: () -> void
+  end
+
+  # The shareability doctor behind `kino --check`.
+  module Check
+    MAX_FINDINGS: Integer
+    MAX_NODES: Integer
+
+    class Finding < ::Struct[untyped]
+      attr_accessor path: String
+      attr_accessor message: String
+
+      def to_s: () -> String
+    end
+
+    def self.report: (rack_app app) -> { shareable: bool, findings: Array[Finding] }
+
+    # Pretty-printed report; true when the app is ractor-ready.
+    def self.print_report: (rack_app app, ?io: IO) -> bool
+  end
+
+  # A ::Logger writing through the native async sink.
+  class Logger < ::Logger
+    # path: a file (created/appended) or nil for stdout.
+    def initialize: (?String? path, **untyped options) -> void
+
+    # The raw IO-like device: frozen and Ractor-shareable, one device can
+    # serve every worker.
+    class Device
+      def initialize: (?String? path) -> void
+
+      def write: (untyped message) -> void
+
+      alias << write
+
+      def close: () -> void
+
+      def reopen: (*untyped) -> self
+    end
+  end
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: kino
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: aarch64-linux
+authors:
+- Yaroslav Markin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 'A high-performance Ractor web server for Ruby 4.0+: Rack 3-based, with
+  a Rust tokio/hyper front-end and Ractor-parallel Ruby workers and threaded fallback
+  mode.'
+email:
+- yaroslav@markin.net
+executables:
+- kino
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- doc/README.md
+- doc/architecture.md
+- doc/benchmarks.md
+- doc/rails-on-ractors.md
+- doc/why-kino.md
+- exe/kino
+- lib/kino.rb
+- lib/kino/check.rb
+- lib/kino/cli.rb
+- lib/kino/configuration.rb
+- lib/kino/errors_stream.rb
+- lib/kino/input.rb
+- lib/kino/kino.so
+- lib/kino/logger.rb
+- lib/kino/null_input.rb
+- lib/kino/ractor_supervisor.rb
+- lib/kino/server.rb
+- lib/kino/stream.rb
+- lib/kino/templates/kino.rb.tt
+- lib/kino/version.rb
+- lib/kino/worker.rb
+- sig/kino.rbs
+homepage: https://github.com/yaroslav/kino
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/yaroslav/kino
+  source_code_uri: https://github.com/yaroslav/kino
+  changelog_uri: https://github.com/yaroslav/kino/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/kino
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: High-performance Ractor web server for Ruby.
+test_files: []