ratalada 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f80ed576156e0bc9751e4c89c18c8901b5ba75b72801b526f7ade9b9affa7a26
-  data.tar.gz: 0b2e102f641cd58328435fc665296b00122806ef7e5d931df171ce820777f725
+  metadata.gz: a9932c4c02d4733e5a9b9ea33cc28f284b24bf9556eaae84fb70c6e8c2175ff9
+  data.tar.gz: b40aa17c1c6f96247fb8fdb965d97830cba834cb65dba986f562476d8fd65569
 SHA512:
-  metadata.gz: 19a103db2359a8993ca9953312614a3b861a9a46472f1b37340f27b4f523a238d523970e9617f8bcf6cbf84cbbca6a7a621d65417818dd33ecd3475ce3fbb424
-  data.tar.gz: bf6ee3f9bfbdfc8aebac210fc14ce72745607487c1019018393cd2e1ba44e4956a05b29ab49e722ab0470b4cd68c66da3fb11738b2b1e94688510644d9c429bf
+  metadata.gz: 42c4fe9a65c44ee9801bbfc61e1366fa87d5545a56b634565998f307a5bd591bd460d9e0fde0b26213f4c5684a5d4fad93365e3cd0b96807cf039a5e978dac06
+  data.tar.gz: c5bb3fb1395ba10ba2e7aa58ce514631fe97c10bcc25d24a0048949a8c8ded24bbc410397c2ec8845fae5e2d4d0cf52723387a6e5db35852e58793b667f4a4d2

data/README.md

@@ -26,17 +26,20 @@ The core `ratalada` gem is the router, the backends, and the DSL. It has no
 runtime dependencies of its own — install whichever server you run on (`puma`
 or `falcon`).
 
-The Sinatra and Grape DSLs are optional add-ons, each its own gem:
+The Sinatra, Grape, Hanami::API and Roda DSLs are optional add-ons, each its
+own gem:
 
 ```bash
 gem install ratalada-sinatra   # enables require "ratalada/sinatra"
 gem install ratalada-grape     # enables require "ratalada/grape"
+gem install ratalada-hanami    # enables require "ratalada/hanami"
+gem install ratalada-roda      # enables require "ratalada/roda"
 ```
 
 They ship separately because their dependencies conflict (Grape needs
-`mustermann` 4, Sinatra needs `mustermann` 3), so bundling both into `ratalada`
-would force you to pick one. **The require path is the same either way**:
-install `ratalada-grape`, then `require "ratalada/grape"`. The adapter file
+`mustermann` 4; Sinatra and Hanami::API need `mustermann` 3), so bundling them
+into `ratalada` would force you to pick one. **The require path is the same
+either way**: install `ratalada-grape`, then `require "ratalada/grape"`. The adapter file
 lives under the shared `ratalada/` namespace on the load path, so the `require`
 never names the gem — only the file you want.
 
@@ -100,6 +103,102 @@ Server.run do
 end
 ```
 
+### Middleware
+
+`Server.use` chains, and `run` ends the chain:
+
+```ruby
+Server.use(Rack::CommonLogger).use(Rack::Deflater).run do |request|
+  case request
+  in ["GET", "/"] then "hello\n"
+  end
+end
+```
+
+These are plain rack middleware — they wrap the finished app and are handed
+the `env`, so every middleware gem works unchanged — and they are built once at
+boot, not per request. The first `use` in the chain is the outermost, as in
+`Rack::Builder`. It works with any frontend, including Sinatra and Grape.
+
+If you want rack's own builder DSL instead, `ratalada/builder` makes the
+`Server.run` block a `Rack::Builder` block — `use`, `map` and `run`, built once:
+
+```ruby
+require "ratalada/puma"
+require "ratalada/builder"
+
+Server.run do
+  use ExampleMiddleware
+  map("/admin") { run AdminApp }
+
+  run ->(env) { [200, { "content-type" => "text/plain" }, ["hello\n"]] }
+end
+```
+
+That frontend is rack all the way down, so there is no `Request` sugar: `run`
+hands you the raw env, and you return a full triplet yourself. It ships in the
+core gem (rack is already there via whichever backend you run).
+
+Or Hanami::API, from `ratalada-hanami`:
+
+```ruby
+require "ratalada/falcon"
+require "ratalada/hanami"
+
+Server.run do
+  get "/" do
+    "hello\n"
+  end
+
+  get "/users/:id" do
+    json(id: params[:id])
+  end
+
+  # Hanami::API scopes middleware by path — this wraps /admin only.
+  scope "admin" do
+    use RequestId
+
+    get "/" do
+      "admin\n"
+    end
+  end
+end
+```
+
+Or Roda's routing tree, from `ratalada-roda`:
+
+```ruby
+require "ratalada/falcon"
+require "ratalada/roda"
+
+Server.run do
+  plugin :json
+
+  route do |r|
+    r.root do
+      "hello\n"
+    end
+
+    # Branch once, act on the way down, match the verb last.
+    r.on "users", Integer do |id|
+      user = User[id]
+
+      r.get "posts" do
+        user.posts
+      end
+
+      r.is do
+        user
+      end
+    end
+  end
+end
+```
+
+The block is Roda's class body, so `plugin` and `use` are available next to
+`route`. The app is built with `.freeze.app`, Roda's recommended production
+setup.
+
 Requiring a frontend only changes how the block builds the app, not which
 server runs it. Each of these adapters is a separate gem (`ratalada-sinatra`,
 `ratalada-grape`), but the `require "ratalada/<name>"` line is all your code
@@ -140,6 +239,20 @@ bin/test      # run the tests
 bin/console   # interactive prompt
 ```
 
+One Gemfile covers the whole repository. None of its own gems are in the
+bundle — the devshell puts `lib/` on `RUBYLIB` — so no lockfile records a
+version and a bump has nothing to keep in step.
+
+Each gem carries its own version, changelog (`CHANGELOG-<gem>.md`) and tag
+(`<gem>-v1.2.3`), and is released on its own schedule with
+[gem_kit-release](https://github.com/n-at-han-k/gem_kit):
+
+```bash
+gem kit bump patch --gem ratalada-roda   # move the version
+gem kit changelog --write --gem ratalada-roda
+gem kit release --gem ratalada-roda      # gate, build, push, tag
+```
+
 ## License
 
 [MIT](LICENSE)

data/lib/ratalada/builder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rack"
+require_relative "../ratalada"
+
+module Ratalada
+  module Frontends
+    # Rack::Builder as the DSL: the Server.run block is a rack builder block,
+    # so `use`, `map` and `run` are rack's own, built once at boot. No Request
+    # sugar here — `run` hands the app a raw env, like any rack app.
+    module Builder
+      def self.build(block)
+        ::Rack::Builder.new(&block).to_app
+      end
+    end
+  end
+
+  self.frontend = Frontends::Builder
+end

data/lib/ratalada/version.rb

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

data/lib/ratalada.rb

@@ -82,21 +82,21 @@ module Ratalada
 
         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
+          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
   end
@@ -104,15 +104,44 @@ module Ratalada
   module Server
     module_function
 
+    # Server.use(Middleware).use(Other).run { ... } — plain rack middleware
+    # (it wraps the built app, so it is handed the env), instantiated once at
+    # boot and applied outside whichever frontend built the app.
+    def use(middleware, *args, &block)
+      Stack.new.use(middleware, *args, &block)
+    end
+
     # 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?
+      Stack.new.run(host: host, port: port, count: count, &block)
+    end
 
-      app = Ratalada.frontend.build(block)
-      Ratalada.backend.run(app, host: host, port: port, count: count)
+    # The chain Server.use returns. Collects middleware until run ends it.
+    class Stack
+      def initialize
+        @middleware = []
+      end
+
+      def use(middleware, *args, &block)
+        @middleware << [middleware, args, block]
+        self
+      end
+
+      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?
+
+        Ratalada.backend.run(to_app(block), host: host, port: port, count: count)
+      end
+
+      # First `use` in the chain is the outermost, as in Rack::Builder.
+      def to_app(block)
+        @middleware.reverse.inject(Ratalada.frontend.build(block)) do |inner, (klass, args, blk)|
+          klass.new(inner, *args, &blk)
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratalada
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Nathan K
@@ -107,6 +107,7 @@ files:
 - README.md
 - exe/ratalada
 - lib/ratalada.rb
+- lib/ratalada/builder.rb
 - lib/ratalada/falcon.rb
 - lib/ratalada/puma.rb
 - lib/ratalada/version.rb