edgeway 0.1.0 → 0.2.0

data/lib/edgeway/controller/dispatcher.rb

@@ -15,6 +15,7 @@ module Edgeway
         klass = controller_class(route)
         raise RoutingError, "no controller for #{route.controller_path}" if klass.nil?
         controller = klass.new(request)
+        controller.action_name = route.action
         # A route whose action isn't defined (or is one of Base's own public
         # methods) is a 404, as in Rails.
         raise RoutingError, "no route for #{request.method} #{request.path}" unless controller.action?(route.action)
@@ -26,7 +27,7 @@ module Edgeway
           # a route can't reach a private method.
           action = route.action.to_sym
           controller.public_send(action) if controller.run_before_actions(route.action)
-          controller.head(:no_content) unless controller.performed?
+          implicit_render(controller, route) unless controller.performed?
         rescue => e
           raise e unless controller.rescue_with_handler(e)
           # A handler that rendered nothing answers 204, as an action does.
@@ -34,6 +35,15 @@ module Edgeway
         end
         controller.to_response
       end
+
+      def self.implicit_render(controller, route)
+        content = controller._render_view(route.action)
+        if content.nil?
+          controller.head(:no_content)
+        else
+          controller.render(html: View::SafeHTML.new(content))
+        end
+      end
     end
   end
 end

data/lib/edgeway/controller/rendering.rb

@@ -10,6 +10,8 @@ module Edgeway
         "service_unavailable" => 503
       }
 
+      UNSET = Object.new
+
       def self.json_response(status, json_text)
         HTTP::Response.json(status, json_text)
       end
@@ -39,10 +41,28 @@ module Edgeway
         end
       end
 
-      def render(json:, status: 200)
-        @status = Rendering.status_code(status)
-        @headers["Content-Type"] = "application/json"
-        @response_body = JSON.generate(Rendering.json_value(json)) + "\n"
+      def self.html_content(value)
+        value.is_a?(View::SafeHTML) ? value.to_s : View.escape(value)
+      end
+
+      def render(template = nil, json: UNSET, html: UNSET, status: 200, layout: true)
+        code = Rendering.status_code(status)
+        if !json.equal?(UNSET)
+          body = JSON.generate(Rendering.json_value(json)) + "\n"
+          @headers["Content-Type"] = "application/json"
+        else
+          content = html.equal?(UNSET) ? nil : Rendering.html_content(html)
+          if content.nil?
+            name = template.nil? ? @action_name : template.to_s
+            content = _render_view(name)
+            raise MissingTemplate, "no template #{name.inspect} for #{self.class.name}" if content.nil?
+          end
+          body = layout ? _render_layout(content) : content
+          @headers["Content-Type"] = "text/html; charset=utf-8"
+          @headers["X-Content-Type-Options"] = "nosniff"
+        end
+        @status = code
+        @response_body = body
         @performed = true
       end
 

data/lib/edgeway/db/adapter.rb

@@ -1,6 +1,18 @@
+require_relative "query_stats"
+
 module Edgeway
   module DB
     class Adapter
+      MAX_BINDS = 100
+
+      def query_stats
+        @query_stats ||= QueryStats.new
+      end
+
+      def record_meta(meta)
+        query_stats.add(meta)
+      end
+
       def select_all(sql, binds)
         raise Error, "#{self.class} does not define select_all"
       end
@@ -9,6 +21,10 @@ module Edgeway
         raise Error, "#{self.class} does not define execute"
       end
 
+      def exec(sql)
+        raise Error, "#{self.class} does not define exec"
+      end
+
       def batch(statements)
         raise Error, "#{self.class} does not define batch"
       end
@@ -19,11 +35,33 @@ module Edgeway
         rows[0]
       end
 
+      def last_insert_id_of(value)
+        return 0 if value.nil?
+        number = value.to_i
+        number > Edgeway::Model::INT_MAX || number < Edgeway::Model::INT_MIN ? value.to_s : number
+      rescue RangeError
+        value.to_s
+      end
+
+      def check_binds(binds)
+        return if binds.size <= MAX_BINDS
+        raise ArgumentError, "too many bind parameters: #{binds.size} (at most #{MAX_BINDS})"
+      end
+
       def fail_with(message)
         raise RecordNotUnique, message if message.include?("UNIQUE constraint failed")
+        raise NotNullViolation, message if message.include?("NOT NULL constraint failed")
+        raise InvalidForeignKey, message if message.include?("FOREIGN KEY constraint failed")
+        raise CheckViolation, message if message.include?("CHECK constraint failed")
         raise DatabaseError, message
       end
 
+      def raise_error_result(res, prefix = "")
+        message = "#{prefix}#{res["error"]}"
+        raise DatabaseUnavailable, message if res.key?("unavailable")
+        fail_with(message)
+      end
+
       def supports_returning? = true
       def placeholder(n) = "?"
       def quote_boolean(value) = value ? 1 : 0

data/lib/edgeway/db/memory.rb

@@ -32,8 +32,8 @@ module Edgeway
       end
 
       # Makes the next query or execute whose SQL contains `containing` (any,
-      # by default) fail with this database message, after logging it, as D1
-      # would: "UNIQUE constraint failed: t.c" is a RecordNotUnique.
+      # by default) fail with this database message, after logging it, as the
+      # database would: "UNIQUE constraint failed: t.c" is a RecordNotUnique.
       def fail_next(message, containing = "")
         @failure = message
         @failure_on = containing
@@ -42,18 +42,25 @@ module Edgeway
       def supports_returning? = @returning
 
       def select_all(sql, binds)
+        check_binds(binds)
         record(sql, binds)
         @queue.empty? ? [] : @queue.shift
       end
 
       def execute(sql, binds)
+        check_binds(binds)
         record(sql, binds)
         id = @next_id
         @next_id += 1
         { "changes" => @changes, "last_insert_id" => id }
       end
 
+      def exec(sql)
+        record(sql, [])
+      end
+
       def batch(statements)
+        statements.each { |s| check_binds(s[1]) }
         @log << "BATCH #{statements.size}"
         statements.map { |s| execute(s[0], s[1]) }
       end

data/lib/edgeway/db/query_stats.rb

@@ -0,0 +1,46 @@
+module Edgeway
+  module DB
+    # What the database reported for one request.
+    class QueryStats
+      MAX_COUNT = 2147483647
+
+      attr_reader :queries, :rows_read, :rows_written, :duration_ms, :served_by_region, :served_by_primary
+
+      def initialize
+        @queries = 0
+        @rows_read = 0
+        @rows_written = 0
+        @duration_ms = 0.0
+        @served_by_region = ""
+        @served_by_primary = true
+      end
+
+      def add(meta)
+        rows_read = capped_sum(@rows_read, meta["rows_read"])
+        rows_written = capped_sum(@rows_written, meta["rows_written"])
+        duration_ms = @duration_ms + meta["duration"].to_f
+        @rows_read = rows_read
+        @rows_written = rows_written
+        @duration_ms = duration_ms
+        @served_by_region = meta["served_by_region"].to_s if meta.key?("served_by_region")
+        @served_by_primary = meta["served_by_primary"] != false if meta.key?("served_by_primary")
+        @queries = capped_sum(@queries, 1)
+      end
+
+      def log_text
+        "db=#{@queries} rows_read=#{count_text(@rows_read)} rows_written=#{count_text(@rows_written)} db_ms=#{format("%.2f", @duration_ms)}"
+      end
+
+      private
+
+      def count_text(count)
+        count == MAX_COUNT ? "#{count}+" : count.to_s
+      end
+
+      def capped_sum(total, count)
+        return MAX_COUNT if count.to_i > MAX_COUNT - total
+        total + count.to_i
+      end
+    end
+  end
+end

data/lib/edgeway/db/sqlite.rb

@@ -20,6 +20,7 @@ module Edgeway
       ffi_func :sqlite3_prepare_v2,      [:ptr, :str, :int, :ptr, :ptr],    :int
       ffi_func :sqlite3_bind_text,       [:ptr, :int, :str, :int, :ptr],    :int
       ffi_func :sqlite3_bind_int64,      [:ptr, :int, :long],               :int
+      ffi_func :sqlite3_bind_blob,       [:ptr, :int, :str, :int, :ptr],    :int
       ffi_func :sqlite3_bind_double,     [:ptr, :int, :double],             :int
       ffi_func :sqlite3_bind_null,       [:ptr, :int],                      :int
       ffi_func :sqlite3_step,            [:ptr],                            :int
@@ -35,6 +36,35 @@ module Edgeway
       ffi_func :sqlite3_changes,         [:ptr],                            :int
       ffi_func :sqlite3_libversion_number, [],                              :int
 
+      # A BLOB can hold NUL, which would cut a :str result short, so it is read
+      # as hex text.
+      ffi_source <<~C
+        #include <stdlib.h>
+
+        extern const void *sqlite3_column_blob(void *statement, int column);
+        extern int sqlite3_column_bytes(void *statement, int column);
+
+        static char *hex;
+        static int hex_capacity;
+
+        const char *column_hex(void *statement, int column) {
+          const unsigned char *bytes = sqlite3_column_blob(statement, column);
+          int length = sqlite3_column_bytes(statement, column);
+          if (2 * length + 1 > hex_capacity) {
+            hex = realloc(hex, 2 * length + 1);
+            if (!hex) abort();
+            hex_capacity = 2 * length + 1;
+          }
+          for (int i = 0; i < length; i++) {
+            hex[2 * i] = "0123456789abcdef"[bytes[i] >> 4];
+            hex[2 * i + 1] = "0123456789abcdef"[bytes[i] & 15];
+          }
+          hex[2 * length] = 0;
+          return hex;
+        }
+      C
+      ffi_func :column_hex, [:ptr, :int], :str
+
       ffi_buffer :db_out,   8
       ffi_buffer :stmt_out, 8
       ffi_read_ptr :read_ptr, 0
@@ -43,6 +73,7 @@ module Edgeway
     class SQLiteAdapter < Adapter
       INTEGER = 1
       FLOAT = 2
+      BLOB = 4
       NULL = 5
 
       attr_reader :log
@@ -63,6 +94,7 @@ module Edgeway
       def supports_returning? = @returning
 
       def select_all(sql, binds)
+        check_binds(binds)
         stmt = start(sql, binds)
         rows = []
         rc = SQLiteFFI.sqlite3_step(stmt)
@@ -75,26 +107,25 @@ module Edgeway
       end
 
       def execute(sql, binds)
+        check_binds(binds)
         stmt = start(sql, binds)
         rc = SQLiteFFI.sqlite3_step(stmt)
         while rc == SQLiteFFI::ROW
           rc = SQLiteFFI.sqlite3_step(stmt)
         end
         finish(stmt, rc)
-        { "changes" => SQLiteFFI.sqlite3_changes(@db), "last_insert_id" => SQLiteFFI.sqlite3_last_insert_rowid(@db) }
+        { "changes" => SQLiteFFI.sqlite3_changes(@db), "last_insert_id" => last_insert_id_of(SQLiteFFI.sqlite3_last_insert_rowid(@db)) }
+      end
+
+      def exec(sql)
+        @log << "#{sql} | []"
+        in_transaction { sql.split("\n").each { |line| run_script(line) unless line.strip.empty? } }
       end
 
       def batch(statements)
         @log << "BATCH #{statements.size}"
-        run_script("BEGIN")
         results = []
-        begin
-          statements.each { |s| results << execute(s[0], s[1]) }
-        rescue => e
-          run_script("ROLLBACK")
-          raise e
-        end
-        run_script("COMMIT")
+        in_transaction { statements.each { |s| results << execute(s[0], s[1]) } }
         results
       end
 
@@ -113,6 +144,17 @@ module Edgeway
 
       private
 
+      def in_transaction
+        run_script("BEGIN")
+        begin
+          yield
+        rescue => e
+          run_script("ROLLBACK")
+          raise e
+        end
+        run_script("COMMIT")
+      end
+
       def run_script(sql_text)
         rc = SQLiteFFI.sqlite3_exec(@db, sql_text, nil, nil, nil)
         fail_with(SQLiteFFI.sqlite3_errmsg(@db)) if rc != SQLiteFFI::OK
@@ -122,6 +164,7 @@ module Edgeway
       # finalized before the error is raised.
       def start(sql, binds)
         @log << "#{sql} | #{JSON.generate(binds)}"
+        check_blob_binds(binds)
         rc = SQLiteFFI.sqlite3_prepare_v2(@db, sql, -1, SQLiteFFI.stmt_out, nil)
         if rc != SQLiteFFI::OK
           message = SQLiteFFI.sqlite3_errmsg(@db)
@@ -148,6 +191,8 @@ module Edgeway
           SQLiteFFI.sqlite3_bind_int64(stmt, n, value)
         elsif value.is_a?(Float)
           SQLiteFFI.sqlite3_bind_double(stmt, n, value)
+        elsif value.is_a?(Hash)
+          bind_blob(stmt, n, value)
         elsif value == true
           SQLiteFFI.sqlite3_bind_int64(stmt, n, 1)
         elsif value == false
@@ -158,6 +203,19 @@ module Edgeway
         end
       end
 
+      def check_blob_binds(binds)
+        binds.each do |value|
+          next unless value.is_a?(Hash)
+          bytes = value.key?("$blob") ? Edgeway::Model.cast(:binary, value) : nil
+          raise ArgumentError, "a Hash bind must be {\"$blob\" => base64}: #{value}" if bytes.nil?
+        end
+      end
+
+      def bind_blob(statement, position, value)
+        bytes = Edgeway::Model.cast(:binary, value).to_s
+        SQLiteFFI.sqlite3_bind_blob(statement, position, bytes, bytes.bytesize, -1)
+      end
+
       # Finalizes the statement; raises if its last step failed.
       def finish(stmt, rc)
         message = rc == SQLiteFFI::DONE ? "" : SQLiteFFI.sqlite3_errmsg(@db)
@@ -165,6 +223,10 @@ module Edgeway
         fail_with(message) if rc != SQLiteFFI::DONE
       end
 
+      def read_blob(statement, column)
+        Edgeway::Model.blob([SQLiteFFI.column_hex(statement, column)].pack("H*"))
+      end
+
       def read_row(stmt)
         row = {}
         n = SQLiteFFI.sqlite3_column_count(stmt)
@@ -178,6 +240,8 @@ module Edgeway
             row[name] = SQLiteFFI.sqlite3_column_int64(stmt, i)
           elsif type == FLOAT
             row[name] = SQLiteFFI.sqlite3_column_double(stmt, i)
+          elsif type == BLOB
+            row[name] = read_blob(stmt, i)
           else
             row[name] = SQLiteFFI.sqlite3_column_text(stmt, i)
           end

data/lib/edgeway/errors.rb

@@ -41,6 +41,10 @@ module Edgeway
   # details only in the log.
   class InvalidHeader < Error; end
 
+  # render named a template that was not compiled from app/views: 500, with
+  # the name only in the log, since it is a bug in the app.
+  class MissingTemplate < Error; end
+
   # A failure in the database adapter: 500.
   class DatabaseError < Error; end
 
@@ -49,6 +53,24 @@ module Edgeway
   # the log only.
   class RecordNotUnique < DatabaseError; end
 
+  # A write the database refused for a NOT NULL constraint: 500, since it is a
+  # bug in the app. The message goes to the log only.
+  class NotNullViolation < DatabaseError; end
+
+  # A write the database refused for a FOREIGN KEY constraint: 500, since it is
+  # a bug in the app. The message goes to the log only.
+  class InvalidForeignKey < DatabaseError; end
+
+  # A write the database refused for a CHECK constraint: 500, since it is a bug
+  # in the app. The message goes to the log only.
+  class CheckViolation < DatabaseError; end
+
+  # A transient database failure or overload (a lost connection, a reset object...):
+  # 503 with "Retry-After: 1" and a fixed body. The message goes to the log
+  # only. Edgeway never retries it. A write that fails this way may still have
+  # been applied, so only an idempotent request is safe to retry.
+  class DatabaseUnavailable < DatabaseError; end
+
   # A record that failed its validations: 422 with {"errors": [...]}.
   class RecordInvalid < Error
     attr_reader :errors

data/lib/edgeway/generators/app/templates/.github/workflows/ci.yml.tt

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    # The first run builds Spinel from source; later runs use mise-action's cache.
+    timeout-minutes: 15
+
+    steps:
+      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
+        with:
+          persist-credentials: false
+      # `edgeway test` links libsqlite3.
+      - name: Install libsqlite3-dev
+        run: sudo apt-get update && sudo apt-get install -y libsqlite3-dev
+      # The Ruby in .ruby-version.
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@651ff0d62c5c79bed6d53ec518387aae20e72c1a # v1.329.0
+        with:
+          bundler-cache: true
+      # Everything in mise.toml: the WASI SDK (bin/build needs it), Spinel,
+      # Node.js, and <%= PackageManager.name %>.
+      - name: Install the tools
+        uses: jdx/mise-action@9b200bcecbfd6303e69a4a261b2e09e3757440a7 # v5.2.0
+      - name: Run the tests
+        run: bin/test
+      - name: Build
+        run: bin/build --release

data/lib/edgeway/generators/app/templates/.ruby-version.tt

@@ -0,0 +1 @@
+<%= RUBY_VERSION %>

data/lib/edgeway/generators/app/templates/README.md.tt

@@ -9,14 +9,18 @@ bin/setup                                     # mise, bundle, <%= PackageManager
 mise install                                  # Spinel and the WASI SDK (mise.toml)
 bundle install
 <%= PackageManager.install %>
-bundle exec edgeway build                     # build/app.wasm (or bin/build)
+bundle exec edgeway build                     # build/app.wasm (or bin/build); --incremental, for development
 <%= PackageManager.exec %> wrangler d1 migrations apply <%= @name %>-db --local
 <%= PackageManager.exec %> wrangler dev                              # http://localhost:8787/health
 bundle exec edgeway routes
 ```
 
+`bin/deploy` builds with `--release`: one unit, without Spinel's `--incremental` (cached C units, no inlining across units), for deploying.
+
 Without mise, set `SPINEL` to the Spinel compiler and `WASI_SDK` to the WASI SDK.
 
-Tests (`test/`) run with `bundle exec edgeway test [ARGS]`. Always use it rather than `spinel_test-unit` directly: it rewrites `tmp/test_app.rb` (git-ignored) from `app/` on every run, so new files are picked up. Each test gets a fresh in-memory SQLite database with `db/migrations/*.sql` applied, so running the tests requires SQLite (sqlite3): its development library has to be installed to link (`apt install libsqlite3-dev` on Debian/Ubuntu, `dnf install sqlite-devel` on Fedora; macOS has it).
+Tests (`test/`) run with `bin/test [FILE...]` (all of `test/` when no file is given; it runs `bundle exec edgeway test`). Always use it rather than `spinel_test-unit` directly: it rewrites `tmp/test_app.rb` (git-ignored) from `app/` on every run, so new files are picked up. Each test gets a fresh in-memory SQLite database with `db/migrations/*.sql` applied, so running the tests requires SQLite (sqlite3): its development library has to be installed to link (`apt install libsqlite3-dev` on Debian/Ubuntu, `dnf install sqlite-devel` on Fedora; macOS has it).
+
+`.github/workflows/ci.yml` runs `bin/test` and `bin/build --release` on GitHub Actions for pushes to main and pull requests.
 
 Model tests inherit `Edgeway::UnitTest` (a database, no requests), request tests `Edgeway::IntegrationTest` (a `UnitTest` that also has `get`, `post`, `json`, `assert_response`).

data/lib/edgeway/generators/app/templates/app/views/layouts/application.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>App</title>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/lib/edgeway/generators/app/templates/bin/build.tt

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Compiles the app to build/app.wasm, like `bundle exec edgeway build`.
-# Arguments go to it (--env ENV).
+# Arguments go to it (--env ENV, --release).
 set -euo pipefail
 cd "$(dirname "$0")/.."
 

data/lib/edgeway/generators/app/templates/bin/deploy.tt

@@ -5,6 +5,6 @@
 set -euo pipefail
 cd "$(dirname "$0")/.."
 
-bin/build
+bin/build --release
 <%= PackageManager.exec %> wrangler d1 migrations apply <%= @name %>-db --remote
 <%= PackageManager.exec %> wrangler deploy "$@"

data/lib/edgeway/generators/app/templates/bin/test.tt

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Runs the tests, like `bundle exec edgeway test`.
+# Arguments go to it: test files to run (all of test/ when none are given).
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+exec bundle exec edgeway test "$@"

data/lib/edgeway/generators/app/templates/config/database.yml

@@ -2,6 +2,23 @@
 # the wasm. adapter: d1 uses the D1 binding named by binding:, which must
 # match a binding in wrangler.toml (wrangler.toml says which D1 database it
 # is); memory is for tests.
+#
+# Another database goes under databases:, which a model picks with
+# `self.database = :analytics` (see the README's "Multiple databases").
+# It has its own binding, migrations (db/<name>/migrations) and test database.
+#   production:
+#     adapter: d1
+#     binding: DB
+#     databases:
+#       analytics:
+#         binding: ANALYTICS
+#
+# For a database with read replication, `sessions: true` next to its binding
+# (see the README's "Read replication (Sessions)").
+#   production:
+#     adapter: d1
+#     binding: DB
+#     sessions: true
 development:
   adapter: d1
   binding: DB

data/lib/edgeway/generators/app/templates/mise.toml.tt

@@ -14,7 +14,7 @@ spinel = "https://github.com/y-yagi/mise-spinel"
 # master, so an install (and CI's cache of it) is the Spinel that was tested.
 # depends: the wasi-sdk is installed first, so the build also makes Spinel's
 # wasm32-wasi runtime (mise-spinel does when WASI_SDK, set below, is there).
-spinel = { version = "530ba2b17", depends = ["github:WebAssembly/wasi-sdk"] }
+spinel = { version = "ec0ad13e4", depends = ["github:WebAssembly/wasi-sdk"] }
 
 # wrangler (package.json) runs on Node.js.
 node = "lts"

data/lib/edgeway/generators/app/templates/wrangler.toml.tt

@@ -21,3 +21,10 @@ binding = "DB"
 database_name = "<%= @name %>-db"
 database_id = "00000000-0000-0000-0000-000000000000"
 migrations_dir = "db/migrations"
+
+# A second database (config/database.yml's databases:) is another binding:
+# [[d1_databases]]
+# binding = "ANALYTICS"
+# database_name = "<%= @name %>-analytics"
+# database_id = "00000000-0000-0000-0000-000000000000"
+# migrations_dir = "db/analytics/migrations"

data/lib/edgeway/http/auth/stub.rb

@@ -12,9 +12,7 @@ module Edgeway
       end
 
       def reject(token, message)
-        # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
-        # Spinel refuses this String as it is, or emits C that doesn't compile.
-        @answers[token] = JSON.generate({ "error" => message.dup })
+        @answers[token] = JSON.generate({ "error" => message })
       end
 
       def unavailable(token, message)

data/lib/edgeway/http/request.rb

@@ -63,12 +63,12 @@ module Edgeway
         add_body_params(decode_pairs(@body, "form body"))
       end
 
-      # decode_www_form never raises on bad bytes: it turns those that aren't
+      # URI.decode_www_form never raises on bad bytes: it turns those that aren't
       # UTF-8 (%ff) into U+FFFD. That is only right when the client sent a
       # U+FFFD itself, so otherwise one in the result is a BadRequest.
       def decode_pairs(text, what)
         raise BadRequest, "#{what} is not valid UTF-8" unless text.valid_encoding?
-        pairs = decode_www_form(text)
+        pairs = URI.decode_www_form(text)
         sent = text.include?(REPLACEMENT) || text.downcase.include?("%ef%bf%bd")
         unless sent
           pairs.each do |k, v|
@@ -78,26 +78,6 @@ module Edgeway
         pairs
       end
 
-      # URI.decode_www_form, written out so that Edgeway doesn't require
-      # "uri": a send with a computed name (Dispatcher) reaches uri's
-      # find_proxy(env = ENV), which Spinel refuses since its Strings are
-      # shared by reference (matz/spinel 44119ab30). Same answers as uri's,
-      # ArgumentError for a non-ASCII input included.
-      def decode_www_form(text)
-        raise ArgumentError, "the input of URI.decode_www_form must be ASCII only string" unless text.ascii_only?
-        return [] if text.empty?
-        pieces = text.split("&", -1)
-        pieces.pop if pieces.last.empty?
-        pieces.map do |piece|
-          key, _sep, val = piece.partition("=")
-          [unescape_www(key), unescape_www(val)]
-        end
-      end
-
-      def unescape_www(s)
-        s.b.gsub(/\+|%\h\h/) { |m| m == "+" ? " " : m[1, 2].hex.chr }.force_encoding(Encoding::UTF_8).scrub
-      end
-
       def read_json
         json = JSONBody.new(@body)
         @json_body = json.value

data/lib/edgeway/inflector.rb

@@ -1,8 +1,21 @@
 module Edgeway
   module Inflector
+    # "admin_posts" -> "AdminPosts"
+    def self.camelize(name) = name.split("_").map(&:capitalize).join
+
+    # "admin/posts" -> "Admin::PostsController"
+    def self.controller_class_name(path)
+      path.split("/").map { |part| camelize(part) }.join("::") + "Controller"
+    end
+
     def self.singularize(name)
       n = name.to_s
       return n[0...-3] + "y" if n.end_with?("ies")
+      if n.end_with?("es")
+        stem = n[0...-2]
+        return stem if sibilant?(stem)
+      end
+      return n if n.end_with?("ss") || n.end_with?("us")
       return n[0...-1] if n.end_with?("s")
       n
     end
@@ -10,7 +23,13 @@ module Edgeway
     def self.pluralize(name)
       n = name.to_s
       return n[0...-1] + "ies" if n.end_with?("y") && n.length > 1 && !"aeiou".include?(n[-2])
+      return n + "es" if n.end_with?("s") || n.end_with?("x") || n.end_with?("sh") || n.end_with?("ch")
       n + "s"
     end
+
+    def self.sibilant?(stem)
+      stem.end_with?("ss") || (stem.end_with?("us") && !stem.end_with?("ous")) || stem.end_with?("x") ||
+        stem.end_with?("sh") || stem.end_with?("ch")
+    end
   end
 end