ratalada 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 151b6598952c6c1c73529cae9e85a504fc988a9fb9d2e204b2b676ad152764cd
+  data.tar.gz: 0be2cfa6dec001003c79735dd0cfcba9efa7b009eab66cdaea871e1644337a92
+SHA512:
+  metadata.gz: a64d981797ad742c62841c638ad2d748e2c3f0ea6906db0678f5fd871e8a28d18ec0b655db234bc7950d480f2112d4dff376d275b084207b5d54a9490f310cc4
+  data.tar.gz: d267fee55bb3af866a888539a9f32d6bc3715a5e6091415a2a9523ec6c9eb069603628b7595a5786c1b6f6c5b7281684a936d49570904f52c34f31a1e7ecbb29

data/.envrc

@@ -0,0 +1 @@
+use flake

data/.gitignore

@@ -0,0 +1,11 @@
+*.gem
+/.env
+/.direnv
+/node_modules
+/.bundle/
+/coverage/
+/pkg/
+/tmp/
+/vendor/bundle
+/docs/_site/
+/docs/.jekyll-cache/

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,125 @@
+PATH
+  remote: .
+  specs:
+    ratalada (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    async (2.42.0)
+      console (~> 1.29)
+      fiber-annotation
+      io-event (~> 1.11)
+      metrics (~> 0.12)
+      traces (~> 0.18)
+    async-container (0.37.0)
+      async (~> 2.22)
+    async-http (0.95.1)
+      async (>= 2.10.2)
+      async-pool (~> 0.11)
+      io-endpoint (~> 0.14)
+      io-stream (~> 0.6)
+      metrics (~> 0.12)
+      protocol-http (~> 0.62)
+      protocol-http1 (~> 0.39)
+      protocol-http2 (~> 0.26)
+      protocol-url (~> 0.2)
+      traces (~> 0.10)
+    async-http-cache (0.4.6)
+      async-http (~> 0.56)
+    async-pool (0.11.2)
+      async (>= 2.0)
+    async-service (0.24.1)
+      async
+      async-container (~> 0.34)
+      string-format (~> 0.2)
+    async-utilization (0.4.0)
+      console (~> 1.0)
+    bake (0.25.0)
+      bigdecimal
+      samovar (~> 2.1)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
+    console (1.36.0)
+      fiber-annotation
+      fiber-local (~> 1.1)
+      json
+    falcon (0.55.5)
+      async
+      async-container (~> 0.20)
+      async-http (~> 0.75)
+      async-http-cache (~> 0.4)
+      async-service (~> 0.19)
+      async-utilization (~> 0.3)
+      bundler
+      localhost (~> 1.1)
+      openssl (>= 3.0)
+      protocol-http (~> 0.31)
+      protocol-rack (~> 0.7)
+      samovar (~> 2.3)
+    fiber-annotation (0.2.0)
+    fiber-local (1.1.0)
+      fiber-storage
+    fiber-storage (1.0.1)
+    io-endpoint (0.17.2)
+    io-event (1.19.1)
+    io-stream (0.13.1)
+    json (2.20.0)
+    localhost (1.8.0)
+      bake
+    logger (1.7.0)
+    metrics (0.15.0)
+    minitest (5.27.0)
+    mustermann (3.1.1)
+    nio4r (2.7.5)
+    openssl (4.0.2)
+    protocol-hpack (1.5.1)
+    protocol-http (0.62.2)
+    protocol-http1 (0.39.0)
+      protocol-http (~> 0.62)
+    protocol-http2 (0.26.0)
+      protocol-hpack (~> 1.4)
+      protocol-http (~> 0.62)
+    protocol-rack (0.22.1)
+      io-stream (>= 0.10)
+      protocol-http (~> 0.58)
+      rack (>= 1.0)
+    protocol-url (0.4.0)
+    puma (8.0.2)
+      nio4r (~> 2.0)
+    rack (3.2.6)
+    rack-protection (4.2.1)
+      base64 (>= 0.1.0)
+      logger (>= 1.6.0)
+      rack (>= 3.0.0, < 4)
+    rack-session (2.1.2)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0)
+    rake (13.4.2)
+    samovar (2.5.1)
+      console (~> 1.0)
+    sinatra (4.2.1)
+      logger (>= 1.6.0)
+      mustermann (~> 3.0)
+      rack (>= 3.0.0, < 4)
+      rack-protection (= 4.2.1)
+      rack-session (>= 2.0.0, < 3)
+      tilt (~> 2.0)
+    string-format (0.2.0)
+    tilt (2.8.0)
+    traces (0.18.2)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  falcon
+  minitest (~> 5.0)
+  puma
+  rake (~> 13.0)
+  ratalada!
+  sinatra
+
+BUNDLED WITH
+   2.6.9

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,108 @@
+# ratalada
+
+A DSL for running Rack servers as easily as you can in JavaScript.
+
+```ruby
+require "ratalada/puma"
+
+Server.run do |request|
+  case request
+  in ["GET", "/"] then "hello\n"
+  end
+end
+```
+
+That's a whole app. Run the file, and it's listening on `http://127.0.0.1:9292`.
+
+## Installation
+
+```bash
+gem install ratalada
+```
+
+Ratalada has no runtime dependencies of its own — install whichever server you
+want to run on (`puma`, `falcon`, or `sinatra` for that flavour of DSL).
+
+## Usage
+
+Requiring a backend picks the server and defines the top-level `Server`
+constant:
+
+```ruby
+require "ratalada/puma"    # or
+require "ratalada/falcon"
+```
+
+The `Server.run` block is a router: it receives each request and returns a
+handler for it. A request pattern-matches as `[verb, path]` (or by keys:
+`in {verb:, path:, query:}`), and a handler can be:
+
+- a `String` — sent as a `200 text/plain` response
+- a callable — called with the request, its result handled the same way
+- a `[status, headers, body]` triplet — used as-is
+- nothing (`nil` or a fall-through `case ... in`) — a `404`
+
+```ruby
+require "ratalada/falcon"
+
+Server.run do |request|
+  case request
+  in ["GET", "/"]      then "hello\n"
+  in ["GET", "/up"]    then "ok\n"
+  in ["POST", "/echo"] then ->(req) { [200, { "content-type" => "text/plain" }, req.body] }
+  end
+end
+```
+
+Prefer Sinatra's routing? Swap the frontend and keep whichever backend you
+required:
+
+```ruby
+require "ratalada/falcon"
+require "ratalada/sinatra"
+
+Server.run do
+  get "/" do
+    "hello\n"
+  end
+end
+```
+
+The host and port default to `127.0.0.1:9292`, configurable via the `HOST` and
+`PORT` environment variables or explicitly:
+
+```ruby
+Server.run(host: "0.0.0.0", port: 3000) do |request|
+  # ...
+end
+```
+
+Like node, one process is one event loop: plenty for IO-bound work, but only
+one core of Ruby. To use more cores, `count:` (or the `COUNT` environment
+variable) runs that many forked workers accepting from a shared socket — the
+equivalent of node's `cluster` module, and with the same contract: each worker
+has its own state, so anything shared between requests (sessions, caches)
+needs an external store or `count: 1` (the default).
+
+```ruby
+Server.run(count: 4) do |request|
+  # ...
+end
+```
+
+Currently only the falcon backend forks workers; the puma backend warns and
+ignores `count:`.
+
+See [examples/](examples/) for complete runnable servers.
+
+## Development
+
+```bash
+bin/setup     # install dependencies
+bin/test      # run the tests
+bin/console   # interactive prompt
+```
+
+## License
+
+[MIT](LICENSE)

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ratalada"
+require "irb"
+
+IRB.start(__FILE__)

data/bin/increment-version

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "erb"
+require_relative "../lib/ratalada/version"
+
+USAGE = <<~TEXT
+  Usage: bin/increment-version <major|minor|patch>
+TEXT
+
+segment = ARGV[0]
+
+unless %w[major minor patch].include?(segment)
+  warn USAGE
+  exit 1
+end
+
+current = Ratalada::VERSION
+major, minor, patch = current.split(".").map(&:to_i)
+
+case segment
+when "major"
+  major += 1
+  minor = 0
+  patch = 0
+when "minor"
+  minor += 1
+  patch = 0
+when "patch"
+  patch += 1
+end
+
+version = "#{major}.#{minor}.#{patch}"
+
+template_path = File.expand_path("../lib/ratalada/version.rb.erb", __dir__)
+output_path   = File.expand_path("../lib/ratalada/version.rb", __dir__)
+
+template = ERB.new(File.read(template_path))
+result = template.result(binding)
+
+File.write(output_path, result)
+
+puts "#{current} -> #{version}"
+

data/bin/release-gem

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ratalada/version"
+
+local_version = Ratalada::VERSION
+gem_name = "ratalada"
+gemspec = "ratalada.gemspec"
+
+puts "Local version: #{local_version}"
+
+remote_output = `gem specification #{gem_name} version --remote 2>&1`
+
+if $?.success?
+  remote_version = remote_output[/version: (.+)/, 1]&.strip
+  puts "Remote version: #{remote_version}"
+
+  if Gem::Version.new(local_version) <= Gem::Version.new(remote_version)
+    abort "ERROR: Local version (#{local_version}) has not been incremented past remote (#{remote_version})"
+  end
+else
+  puts "Gem not yet published remotely, proceeding with first release"
+end
+
+puts "Building #{gemspec}..."
+system("gem build #{gemspec}") || abort("ERROR: gem build failed")
+
+gem_file = "#{gem_name}-#{local_version}.gem"
+puts "Pushing #{gem_file}..."
+system("gem push #{gem_file}") || abort("ERROR: gem push failed")
+
+puts "Released #{gem_name} #{local_version}"

data/bin/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+echo "1/2 Installing bundle"
+bundle install
+
+echo "2/2 Updating .gitignore"
+sed -i '/^Gemfile.lock$/d' .gitignore
+sed -i '/^flake.lock$/d' .gitignore

data/bin/tag-version

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ratalada/version"
+
+version = Ratalada::VERSION
+tag = "v#{version}"
+
+existing = `git tag -l #{tag}`.strip
+unless existing.empty?
+  abort "ERROR: Tag #{tag} already exists"
+end
+
+system("git tag #{tag}") || abort("ERROR: Failed to create tag #{tag}")
+
+puts "Tagged #{tag}"
+puts ""
+puts "To push the tag, run:"
+puts "  git push --tags"

data/bin/test

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../test", __dir__)
+
+require "bundler/setup"
+
+Dir.chdir(File.expand_path("..", __dir__))
+
+if ARGV.empty?
+  Dir.glob("test/**/*_test.rb").sort.each { |f| require_relative "../#{f}" }
+else
+  ARGV.each { |f| require_relative "../#{f}" }
+end

data/examples/README.md

@@ -0,0 +1,56 @@
+# Examples
+
+Each example is a complete server. From the repo root:
+
+```bash
+bundle install
+bundle exec ruby examples/puma.rb      # built-in router on puma
+bundle exec ruby examples/falcon.rb    # built-in router on falcon
+bundle exec ruby examples/sinatra.rb   # sinatra DSL on falcon
+```
+
+One example brings its own dependencies (via an inline gemfile) instead of
+the repo bundle — run it with plain `ruby`:
+
+```bash
+ruby examples/brute.rb                 # a brute coding agent served over HTTP
+```
+
+It expects a [brute](https://github.com/general-intelligence-systems/brute) checkout at
+`~/brute/brute` (override with `BRUTE_PATH`) and an LLM — a local Ollama by
+default (`BRUTE_PROVIDER` / `BRUTE_MODEL` to change). Ask it things:
+
+```bash
+curl -d 'What files are in the current directory?' http://localhost:9292/ask
+```
+
+All of them listen on `http://127.0.0.1:9292` (override with `HOST`/`PORT`
+env vars, or `Server.run(host:, port:)`).
+
+## How it works
+
+`require "ratalada/puma"` or `require "ratalada/falcon"` picks the server
+backend and defines the top-level `Server` constant.
+
+With the built-in router, the `Server.run` block receives each request and
+returns a handler for it. A request pattern-matches as `[verb, path]`, and a
+handler can be:
+
+- a `String` — sent as a `200 text/plain` response
+- a callable — called with the request, its result handled the same way
+- a `[status, headers, body]` triplet — used as-is
+- nothing (`nil` or a fall-through `case ... in`) — a `404`
+
+```ruby
+require "ratalada/puma"
+
+Server.run do |request|
+  case request
+  in ["GET", "/"] then "ok"
+  end
+end
+```
+
+`require "ratalada/sinatra"` swaps the block DSL for Sinatra: the block is
+class-evaluated into an anonymous Sinatra app, running on whichever backend
+you required.

data/examples/brute.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Serve a brute agent over HTTP.
+#
+#   curl -d 'Say hi' http://localhost:9292/ask
+
+require "ratalada/falcon"
+require "ratalada/sinatra"
+require "brute"
+require "ruby_llm"
+
+RubyLLM.configure do |config|
+  config.ollama_api_base = "http://localhost:11434/v1"
+end
+
+Server.run do
+  get "/ask" do
+    Brute.agent.run do |env|
+      RubyLLM.chat(model: "llama3.2", provider: :ollama).then do |chat|
+        chat.ask(env[:messages].last.content).content.then do |response|
+          env[:messages].assistant(response)
+        end
+      end
+    end.then do |agent|
+      agent.start(request.body.read)[:messages].last.content
+    end
+  end
+end

data/examples/falcon.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Run:  bundle exec ruby examples/falcon.rb
+# Try:  curl http://localhost:9292/
+#       curl http://localhost:9292/up
+#       curl "http://localhost:9292/greet?name=world"
+
+require "ratalada/falcon"
+
+Server.run do |request|
+  case request
+  in ["GET", "/"]     then "hello from falcon\n"
+  in ["GET", "/up"]   then "ok\n"
+  in ["GET", "/greet"] then ->(req) { "hello #{req.query.delete_prefix("name=")}\n" }
+  end
+end

data/examples/puma.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Run:  bundle exec ruby examples/puma.rb
+# Try:  curl http://localhost:9292/
+#       curl http://localhost:9292/up
+#       curl -d "hello" http://localhost:9292/echo
+
+require "ratalada/puma"
+
+Server.run do |request|
+  case request
+  in ["GET", "/"]      then "hello from puma\n"
+  in ["GET", "/up"]    then "ok\n"
+  in ["POST", "/echo"] then ->(req) { [200, { "content-type" => "text/plain" }, req.body] }
+  end
+end

data/examples/sinatra.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Run:  bundle exec ruby examples/sinatra.rb
+# Try:  curl http://localhost:9292/
+#       curl http://localhost:9292/up
+#       curl http://localhost:9292/greet/world
+
+require "ratalada/falcon"
+require "ratalada/sinatra"
+
+Server.run do
+  get "/" do
+    "hello from sinatra on falcon\n"
+  end
+
+  get "/up" do
+    "ok\n"
+  end
+
+  get "/greet/:name" do
+    "hello #{params[:name]}\n"
+  end
+end

data/exe/ratalada

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ratalada"
+
+puts "hello from ratalada"

data/flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1781577229,
+        "narHash": "sha256-lrp67w8AulE9Ks53n27I45ADSzbOCn4H+CNW1Ck8B+8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "567a49d1913ce81ac6e9582e3553dd90a955875f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "utils": "utils"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/flake.nix

@@ -0,0 +1,38 @@
+{
+  description = "Ruby gem flake";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    utils.url = "github:numtide/flake-utils";
+  };
+  outputs = { self, nixpkgs, utils }:
+    utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+        ruby = pkgs.ruby_3_4; # Specify version
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          nativeBuildInputs = [
+            pkgs.pkg-config # native extension discovery
+          ];
+
+          buildInputs = [
+            ruby
+            pkgs.libyaml # psych gem
+            pkgs.openssl # openssl gem
+          ];
+
+          shellHook = ''
+            export GEM_HOME="$HOME/.gem-${ruby.version}"
+            export GEM_PATH="$GEM_HOME"
+            export PATH="$GEM_HOME/bin:$PATH"
+            export BUNDLE_GEMFILE="$PWD/Gemfile"
+            export BUNDLE_PATH="$GEM_HOME"
+            export BUNDLE_BIN="$GEM_HOME/bin"
+          '';
+        };
+      }
+    );
+}
+

data/lib/ratalada/falcon.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "falcon"
+require "falcon/environment/server"
+require "async/service/configuration"
+require "async/service/controller"
+require "async/container"
+require_relative "../ratalada"
+
+module Ratalada
+  module Backends
+    module Falcon
+      module_function
+
+      # Runs the app the way `falcon host` does: declare a server environment,
+      # hand it to Async::Service::Controller. The controller binds the socket
+      # once in the parent, runs `count` supervised workers accepting from it
+      # (restarts, health checks, INT/TERM/HUP handling all come with it).
+      def run(app, host:, port:, count: 1)
+        middleware = ::Falcon::Server.middleware(app)
+
+        environment = Async::Service::Environment.new(::Falcon::Environment::Server).with(
+          name: "ratalada",
+          url: "http://#{host}:#{port}",
+          middleware: -> { middleware },
+          container_options: { count: count, restart: true },
+        )
+
+        configuration = Async::Service::Configuration.new
+        configuration.add(environment)
+
+        warn "ratalada: falcon listening on http://#{host}:#{port}#{" (#{count} workers)" if count > 1}"
+        Async::Service::Controller.run(configuration, container_class: Async::Container.best_container_class)
+      rescue Interrupt
+        # clean shutdown
+      end
+    end
+  end
+
+  self.backend = Backends::Falcon
+end

data/lib/ratalada/puma.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "puma"
+require_relative "../ratalada"
+
+module Ratalada
+  module Backends
+    module Puma
+      module_function
+
+      def run(app, host:, port:, count: 1)
+        warn "ratalada: puma backend ignores count: (not yet implemented)" if count > 1
+        server = ::Puma::Server.new(app)
+        server.add_tcp_listener(host, port)
+        warn "ratalada: puma listening on http://#{host}:#{port}"
+        server.run.join
+      rescue Interrupt
+        server.stop(true)
+      end
+    end
+  end
+
+  self.backend = Backends::Puma
+end

data/lib/ratalada/sinatra.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require_relative "../ratalada"
+
+module Ratalada
+  module Frontends
+    # Sinatra-flavoured DSL: the Server.run block is class-evaluated into an
+    # anonymous Sinatra application, so `get "/" do ... end` etc. all work.
+    module Sinatra
+      def self.build(block)
+        app = Class.new(::Sinatra::Base)
+        app.class_eval(&block)
+        app.new
+      end
+    end
+  end
+
+  self.frontend = Frontends::Sinatra
+end

data/lib/ratalada/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ratalada
+  VERSION = "0.2.0"
+end

data/lib/ratalada/version.rb.erb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ratalada
+  VERSION = "<%= version %>"
+end

data/lib/ratalada.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "ratalada/version"
+
+module Ratalada
+  DEFAULT_HOST = ENV.fetch("HOST", "127.0.0.1")
+  DEFAULT_PORT = Integer(ENV.fetch("PORT", "9292"))
+  DEFAULT_COUNT = Integer(ENV.fetch("COUNT", "1"))
+
+  class Error < StandardError; end
+
+  class NoBackendError < Error
+    def initialize(msg = nil)
+      super(msg || <<~MSG)
+        No server backend selected. Require one before calling Server.run:
+
+          require "ratalada/puma"    # or
+          require "ratalada/falcon"
+      MSG
+    end
+  end
+
+  class << self
+    # The backend runs a rack app (set by requiring ratalada/puma or
+    # ratalada/falcon); the frontend turns the Server.run block into a rack
+    # app (the built-in router by default, ratalada/sinatra to swap it).
+    attr_writer :backend, :frontend
+
+    def backend
+      @backend or raise NoBackendError
+    end
+
+    def frontend
+      @frontend ||= Frontends::Routes
+    end
+  end
+
+  # Wraps the Rack env with just enough sugar to pattern match on.
+  class Request
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    def verb  = env["REQUEST_METHOD"]
+    def path  = env["PATH_INFO"]
+    def query = env["QUERY_STRING"]
+    def body  = @body ||= env["rack.input"]&.read
+
+    # Enables `in ["GET", "/"]`
+    def deconstruct = [verb, path]
+
+    # Enables `in {verb: "GET", path: "/users"}`
+    def deconstruct_keys(_keys) = { verb:, path:, query:, env: }
+  end
+
+  module Frontends
+    # The default DSL: the Server.run block is a router. It is called with
+    # each Request and returns a handler for it — a callable (called with the
+    # request), a response body String, or a full [status, headers, body]
+    # triplet. No match (nil, or a fall-through `case ... in`) means 404.
+    module Routes
+      def self.build(block)
+        App.new(block)
+      end
+
+      class App
+        def initialize(router)
+          @router = router
+        end
+
+        def call(env)
+          request = Request.new(env)
+          handler = begin
+            @router.call(request)
+          rescue NoMatchingPatternError
+            nil
+          end
+          respond(handler, request)
+        end
+
+        private
+
+        def respond(handler, request)
+          case handler
+          when nil
+            [404, { "content-type" => "text/plain" }, ["not found"]]
+          when Proc, Method
+            respond(handler.call(request), request)
+          when String
+            [200, { "content-type" => "text/plain" }, [handler]]
+          when Array
+            status, headers, body = handler
+            [status, headers, body.is_a?(String) ? [body] : body]
+          else
+            handler
+          end
+        end
+      end
+    end
+  end
+
+  module Server
+    module_function
+
+    # count runs that many worker processes accepting from a shared socket,
+    # like node's cluster module. Each worker has its own state — anything
+    # shared (sessions, caches) needs an external store or count: 1.
+    def run(host: DEFAULT_HOST, port: DEFAULT_PORT, count: DEFAULT_COUNT, &block)
+      raise ArgumentError, "Server.run requires a block" unless block
+      raise ArgumentError, "count must be a positive Integer" unless count.is_a?(Integer) && count.positive?
+
+      app = Ratalada.frontend.build(block)
+      Ratalada.backend.run(app, host: host, port: port, count: count)
+    end
+  end
+end
+
+# The whole point is a zero-ceremony top-level DSL.
+Server = Ratalada::Server unless defined?(Server)

data/ratalada.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/ratalada/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ratalada"
+  spec.version = Ratalada::VERSION
+  spec.authors = ["Nathan K"]
+  spec.email = ["nathankidd@hey.com"]
+
+  spec.summary = "DSL for running rack servers as easily as you can in javascript."
+
+  spec.description = <<~DESC
+    DSL for running rack servers as easily as you can in javasript.
+  DESC
+
+  spec.homepage = "https://github.com/n-at-han-k/ratalada"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|data|docs|\.github)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+
+  # Servers and frameworks the adapters wrap; users install whichever they require.
+  spec.add_development_dependency "falcon"
+  spec.add_development_dependency "puma"
+  spec.add_development_dependency "sinatra"
+end

data/ratalada.gemspec.erb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/ratalada/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "<%= gem_name %>"
+  spec.version = Ratalada::VERSION
+  spec.authors = [<%= authors.map { |a| %("#{a}") }.join(", ") %>]
+  spec.email = [<%= emails.map { |e| %("#{e}") }.join(", ") %>]
+
+  spec.summary = "<%= summary %>"
+
+  spec.description = <<~DESC
+    <%= description %>
+  DESC
+
+  spec.homepage = "<%= homepage %>"
+  spec.license = "<%= license %>"
+  spec.required_ruby_version = ">= <%= ruby_version %>"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|data)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: ratalada
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nathan K
+bindir: exe
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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: falcon
+  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: puma
+  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: sinatra
+  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'
+description: 'DSL for running rack servers as easily as you can in javasript.
+
+  '
+email:
+- nathankidd@hey.com
+executables:
+- ratalada
+extensions: []
+extra_rdoc_files: []
+files:
+- ".envrc"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/increment-version
+- bin/release-gem
+- bin/setup
+- bin/tag-version
+- bin/test
+- examples/README.md
+- examples/brute.rb
+- examples/falcon.rb
+- examples/puma.rb
+- examples/sinatra.rb
+- exe/ratalada
+- flake.lock
+- flake.nix
+- lib/ratalada.rb
+- lib/ratalada/falcon.rb
+- lib/ratalada/puma.rb
+- lib/ratalada/sinatra.rb
+- lib/ratalada/version.rb
+- lib/ratalada/version.rb.erb
+- ratalada.gemspec
+- ratalada.gemspec.erb
+homepage: https://github.com/n-at-han-k/ratalada
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/n-at-han-k/ratalada
+  source_code_uri: https://github.com/n-at-han-k/ratalada
+  documentation_uri: https://github.com/n-at-han-k/ratalada
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: DSL for running rack servers as easily as you can in javascript.
+test_files: []