hecks 2.8.0 → 3.0.0

data/lib/hecks/cli/document.rb

@@ -2,26 +2,10 @@ require_relative "../../hecks"
 
 module Hecks
   module CLI
-    # The command behind `bin/docs`, `bin/narrate`, `hecks docs` and `hecks narrate`:
+    # The command behind `hecks docs` and `hecks narrate`:
     # one domain's document, projected from its own bluebook, to stdout.
     #
-    # `:docs` answers the usage document a console's `<Domain>.docs` prints; `:narrate`
-    # answers the same chapter read back in English, for the subject-matter expert
-    # (`Projector::NarrateProjector`). Nothing is written for the caller: redirect it,
-    # so the caller decides where a generated file lands and git decides whether it
-    # drifted.
-    #
-    # ## Every failure is a sentence
-    #
-    # A misspelled aggregate refuses by name rather than printing nothing and exiting
-    # 0. A caller cannot tell an empty document from an empty domain, so this refuses
-    # instead and names what is actually there.
-    #
-    # ## Standing in a domain is enough
-    #
-    # `Adapters::Folder#domain_root` walks up for the nearest `.hecksagon`, which makes
-    # the first argument ambiguous. The rule: a directory is a domain, anything else
-    # is an aggregate name, and the two-argument form says which is which.
+    # Nothing is written for the caller: redirect it, so git decides whether it drifted.
     module Document
       # Build output and other trees under a root that hold no domain a caller means.
       # Matched against the path relative to the root, because a substring test
@@ -47,7 +31,7 @@ module Hecks
         refuse_without_domain(program, root) unless path
 
         begin
-          runtime = Hecks.boot(path, install_facade: false)
+          runtime = Hecks.boot(path, install_doors: false)
         rescue StandardError => e
           abort "cannot read #{path}: #{e.message.lines.first.strip}"
         end
@@ -66,10 +50,8 @@ module Hecks
 
       # Lists every directory under `root` that `Hecks.boot` would accept.
       #
-      # Found by their wiring, not their chapters: a `.hecksagon` is what says "this
-      # is a domain, and here is how its aggregates are stored", while most
-      # `.bluebook` files (era translations, the language's own grammar,
-      # `spec/fixtures`) are not domains anybody boots.
+      # Found by their wiring, not their chapters: a `.hecksagon` says this is a
+      # domain, while most `.bluebook` files (era translations, grammar, fixtures) are not.
       #
       # @param root [String] the directory to search under
       # @return [Array<String>] domain directory paths relative to `root`,

data/lib/hecks/cli/expression_projection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../projection_files"
+
+module Hecks
+  module CLI
+    # The command behind `hecks project_expression_tables`: projects the expression machinery's
+    # operator and normalisation tables from the grammar chapter into
+    # `lib/hecks/bluebook/expression/projection.json`.
+    #
+    # It never redirects with `>`: the shell would truncate the file the framework requires at
+    # boot. The default mode replaces the file atomically, and it refuses a projection that drops
+    # a self-bearing operator (one the chapter's own `status != "retired"` givens evaluate
+    # through), since that would wedge every later boot. Recover a broken file with
+    # `git checkout -- lib/hecks/bluebook/expression/projection.json`.
+    module ExpressionProjection
+      module_function
+
+      # Rewrites the projection file, or with `--stdout` prints it instead.
+      #
+      # @param argv [Array<String>] `--stdout` for the diff mode
+      # @param out [IO] where the result goes
+      # @return [Integer] the exit status, 0 once written or printed
+      # @raise [SystemExit] with the refusal when the projection drops a self-bearing operator
+      def call(argv, out: $stdout)
+        result = begin
+          Hecks::ProjectionFiles.build(:expression_tables)
+        rescue Hecks::ProjectionFiles::Refused => e
+          abort e.message
+        end
+
+        if argv.include?("--stdout")
+          out.print result.content.values.first
+        else
+          out.puts Hecks::ProjectionFiles.write(:expression_tables)
+        end
+        0
+      end
+    end
+  end
+end

data/lib/hecks/cli/follow.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "../../hecks"
+
+module Hecks
+  module CLI
+    # The command behind `hecks follow`: live-tails a domain's persisted event log as JSON lines.
+    #
+    # Events are one table per domain, so this polls the first repository that answers `:events`
+    # and diffs its size each tick, filtering client-side when `--aggregate` is given.
+    module Follow
+      module_function
+
+      # Tails until interrupted.
+      #
+      # @param argv [Array<String>] `<domain> [--aggregate name] [--interval seconds] [--from-now]`
+      # @param program [String] the name the usage message calls this command by
+      # @return [void]
+      # @raise [SystemExit] when no domain is named or no adapter persists an event log
+      def call(argv, program: "hecks follow")
+        argv = argv.dup
+        domain_name = argv.shift or abort "usage: #{program} <domain> [options]"
+        options = parse(argv, program)
+        repository = event_repository(Hecks.boot(domain_name), domain_name, program)
+        tail(repository, options)
+      end
+
+      # @param argv [Array<String>] the options after the domain; consumed in place
+      # @param program [String] the name the usage banner calls this command by
+      # @return [Hash] `:interval`, `:from_now` and, when given, `:aggregate`
+      def parse(argv, program)
+        options = { interval: 0.5, from_now: false }
+        OptionParser.new do |parser|
+          parser.banner = "usage: #{program} <domain> [options]"
+          parser.on("-a", "--aggregate=NAME", "Only follow events for this aggregate (e.g. Order)") do |name|
+            options[:aggregate] = name
+          end
+          parser.on("-i", "--interval=SECONDS", Float, "Poll interval in seconds (default: 0.5)") { |v| options[:interval] = v }
+          parser.on("--from-now", "Skip existing events; only print ones emitted from now on") { options[:from_now] = true }
+        end.parse!(argv)
+        options
+      end
+
+      # @param runtime [Runtime] a booted domain
+      # @param domain_name [String] its name, for the refusal
+      # @param program [String] the name the refusal calls this command by
+      # @return [Object] the first repository that answers `:events`
+      # @raise [SystemExit] when none does
+      def event_repository(runtime, domain_name, program)
+        repositories = runtime.registry.bluebooks.flat_map do |bluebook_domain, bluebook|
+          bluebook.aggregates.map { |aggregate| runtime.registry.repository(bluebook_domain, aggregate) }
+        end
+        repositories.find { |repo| repo.respond_to?(:events) } or
+          abort "#{program}: no adapter in #{domain_name} persists an event log"
+      end
+
+      # Says whether `event` passes the `--aggregate` filter: a bare name matched
+      # case-insensitively, or the exact name.
+      #
+      # @param event [Object] a logged event
+      # @param filter [String, nil] the aggregate name asked for
+      # @return [Boolean]
+      def matches?(event, filter)
+        filter.nil? || event.aggregate.to_s.split("::").last.casecmp?(filter) || event.aggregate == filter
+      end
+
+      # @param repository [Object] answers `events`
+      # @param options [Hash] the parsed options
+      # @return [void]
+      def tail(repository, options)
+        seen = options[:from_now] ? repository.events.size : 0
+        $stdout.sync = true
+        trap("INT") { exit }
+
+        loop do
+          events = repository.events
+          if events.size > seen
+            events[seen..].each { |event| puts JSON.generate(event.to_h) if matches?(event, options[:aggregate]) }
+            seen = events.size
+          end
+          sleep options[:interval]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/cli/history.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../hecks"
+
+module Hecks
+  module CLI
+    # The command behind `hecks history` and `hecks history`: every journal entry a domain's
+    # append-only adapters hold, as JSON, the full write history rather than the current head.
+    module History
+      module_function
+
+      # Boots the domain `argv` names and prints its history as one JSON document.
+      #
+      # @param argv [Array<String>] the domain directory, first
+      # @param program [String] the name the usage message calls this command by
+      # @return [void]
+      # @raise [SystemExit] when `argv` is empty
+      def call(argv, program: "hecks history")
+        domain = argv.first or abort "usage: #{program} <domain>"
+        puts JSON.generate(document(Hecks.boot(domain).registry))
+      end
+
+      # @param registry [Runtime::Registry] a booted domain's registry
+      # @return [Hash{String => Array<Hash>}] each aggregate's storage name mapped to its entries
+      def document(registry)
+        registry.bluebooks.each_with_object({}) do |(name, bluebook), all|
+          bluebook.aggregates.each do |aggregate|
+            all[aggregate.storage_name] = entries(registry.repository(name, aggregate))
+          end
+        end
+      end
+
+      # @param repository [Object] an aggregate's repository
+      # @return [Array<Hash{String => Object}>] its journal entries; empty
+      #   when it is not append-only
+      def entries(repository)
+        return [] unless repository.is_a?(Ports::Persistence::AppendOnly)
+
+        repository.entries.map { |entry| { "operation" => entry.operation, "id" => entry.id, "state" => entry.state } }
+      end
+    end
+  end
+end

data/lib/hecks/cli/ir.rb

@@ -5,18 +5,16 @@ require_relative "../ports/persistence/plugins/era"
 
 module Hecks
   module CLI
-    # The command behind `bin/ir` and `hecks ir`: a booted domain's IR as JSON, the
-    # same `to_h` the golden specs pin and `StorageShape` hashes into an era, for
-    # reading rather than asserting on.
+    # The command behind `hecks ir`: a booted domain's IR as JSON, the
+    # same `to_h` the golden specs pin and `StorageShape` hashes into an era.
     module Ir
       module_function
 
       # Prints the IR `argv` asks for.
       #
-      # `--meta` prints the language's own IR, the chapters under
-      # `lib/hecks/language/bluebook/` merged into one. It is reached through
+      # `--meta` prints the language's own IR, reached through
       # `Bluebook::MetaValidator.grammar_registry`, the real boot sequence, so it
-      # cannot drift from what `MetaValidator` itself loads.
+      # can't drift from what `MetaValidator` loads.
       #
       # @param argv [Array<String>] a domain path and `--translations`, or `--meta`
       # @param program [String] the name the usage message calls this command by

data/lib/hecks/cli/mcp.rb

@@ -2,12 +2,11 @@ require_relative "../mcp_stdio_guard"
 
 module Hecks
   module CLI
-    # The command behind `bin/hecks_mcp_door` and `hecks mcp`: the MCP door onto the
+    # The command behind `hecks mcp`: the MCP door onto the
     # storehouse bus, over stdio only.
     #
-    # This file loads nothing but `McpStdioGuard`, so the transport check runs before
-    # the framework does. The door itself is `McpDoor`, required only once the check
-    # passes.
+    # This file loads nothing but `McpStdioGuard`, so the transport check runs
+    # before the framework does.
     module Mcp
       # The server name the guard's refusals and warnings carry.
       SERVER = "hecks-mcp-door".freeze
@@ -24,8 +23,8 @@ module Hecks
       #   set up for stdio
       def call(argv)
         McpStdioGuard.enforce_stdio!(server: SERVER, argv: argv)
-        require_relative "mcp_door"
-        McpDoor.serve
+        require_relative "../doors/mcp_door"
+        Doors::McpDoor.serve
       end
     end
   end

data/lib/hecks/cli/model_check.rb

@@ -3,28 +3,15 @@ require_relative "../bluebook/model_check"
 
 module Hecks
   module CLI
-    # The command behind `bin/model_check` and `hecks model_check`: static analysis
+    # The command behind `hecks model_check`: static analysis
     # over the IR, printed per domain, exiting non-zero when any error-severity
-    # finding is left.
+    # finding is left — unreachable lifecycle states, dead transitions, unreached
+    # saga states, dispatches to a nonexistent command, handlers for an event
+    # nothing emits. The runtime checks none of these; a dead transition never
+    # fires, in silence.
     #
-    # It finds unreachable lifecycle states, transitions nothing can fire, saga
-    # states no handler chain reaches, a compensation whose `from_state` is
-    # unreachable, dispatches to a command that does not exist, and handlers
-    # listening for an event nothing emits. The runtime checks none of these: a dead
-    # transition never fires, in silence.
-    #
-    # ## Named domains, or the whole corpus
-    #
-    # Given domain paths, it boots each and runs one cross-domain check across all
-    # of them. Given none, it sweeps the repository's corpus (`Corpus.model_check_members`)
-    # and the language's own chapters; that needs `root:`, the repository, so an
-    # installed gem without one asks for a domain path instead.
-    #
-    # ## Options
-    #
-    # `--strict` makes a `rust_reserved_name` finding an error for every target, not
-    # only for those with a Cargo feature under `root`'s `rust/Cargo.toml`.
-    # `--profile client` adds `Bluebook::ModelCheck::ClientProfile`'s error findings.
+    # Given domain paths it checks just those, cross-domain; given none it sweeps
+    # the repository's corpus and the language's own chapters, which needs `root:`.
     module ModelCheck
       # The directory the framework's own `.port` and `.adapter` files live under.
       HECKS_DIR = File.expand_path("..", __dir__)
@@ -37,7 +24,8 @@ module Hecks
 
       # Runs the model check `argv` describes and exits with its verdict.
       #
-      # @param argv [Array<String>] `--strict`, `--profile NAME` and domain paths
+      # @param argv [Array<String>] `--strict`, `--profile NAME`, `--wait` and domain paths;
+      #   `--wait` is accepted for the launcher's sake, as the verdict is always the exit status
       # @param program [String] the name the usage message calls this command by
       # @param root [String, nil] the repository root, for the corpus sweep and the
       #   Rust-target check; nil when there is no checkout
@@ -47,6 +35,7 @@ module Hecks
       def call(argv, program:, root: nil)
         argv = argv.dup
         strict = !argv.delete("--strict").nil?
+        argv.delete("--wait")
         profile = take_profile(argv)
         unless profile.nil? || Bluebook::ModelCheck::PROFILES.include?(profile)
           warn "unknown profile #{profile.inspect} (known: #{Bluebook::ModelCheck::PROFILES.join(', ')})"
@@ -64,10 +53,6 @@ module Hecks
         exit(ok ? 0 : 1)
       end
 
-      # Reads `--profile client` or `--profile=client` and removes it from `argv`.
-      #
-      # @param argv [Array<String>] the arguments, changed in place
-      # @return [Symbol, nil] the requested profile, or nil when none was asked for
       def take_profile(argv)
         inline = argv.find { |arg| arg.start_with?("--profile=") }
         index = argv.index("--profile")
@@ -79,13 +64,8 @@ module Hecks
         name.to_sym
       end
 
-      # Boots each named domain and examines them against one shared set of known
-      # domains and emitted events, so a cross-domain reaction between two of them
-      # is checked.
-      #
-      # @param domain_args [Array<String>] domain directory paths
-      # @param options [Options] the run's configuration
-      # @return [Boolean] true when every domain passes
+      # Examines every named domain against one shared set of known domains and
+      # emitted events, so a cross-domain reaction between two of them is checked.
       def check_domains(domain_args, options)
         booted = domain_args.map do |domain_arg|
           [File.basename(domain_arg.chomp("/")), boot(bluebook_dir(domain_arg.chomp("/")) || domain_arg)]
@@ -93,15 +73,8 @@ module Hecks
         examine_all(booted, options)
       end
 
-      # Boots every corpus member once, then examines each against the set of names
-      # every member declares, then examines the language itself.
-      #
       # Two passes over the same boots, because a single boot's own registry cannot
       # answer whether a target domain exists anywhere in the corpus.
-      #
-      # @param root [String] the repository root
-      # @param options [Options] the run's configuration
-      # @return [Boolean] true when every member and the language pass
       def check_corpus(root, options)
         require_relative "../corpus"
         targets = Corpus.model_check_members(root: root).map { |member| [member.stem, Corpus.source_of(member)] }
@@ -110,17 +83,8 @@ module Hecks
         examine_language(options) && ok
       end
 
-      # Boots one source into a fresh registry, with its sibling hecksagons so a
-      # policy bound from there is visible too.
-      #
-      # `root:` is the source's parent: a directory source is already the domain's
-      # own `bluebook/` folder, and without a root a member declaring
-      # `uses_embryonaut_bluebook` refuses with "needs a registry with a root to
-      # vendor from".
-      #
-      # @param source [String] a directory to boot (every bluebook within), or a
-      #   single `.bluebook` file path
-      # @return [Runtime::Registry] the registry populated with the booted bluebooks
+      # `root:` is the source's parent, so a member declaring
+      # `uses_embryonaut_bluebook` can vendor from it.
       def boot(source)
         root = File.directory?(source) ? File.dirname(source) : nil
         registry = Runtime::Registry.new(root: root)
@@ -142,14 +106,13 @@ module Hecks
         end
 
         # A port attaches to its aggregate from the hecksagon, not the bluebook, so a
-        # deaf-policy check that never loads it would see a policy reacting to an
-        # event nothing appears to emit. A directory loads every `*.hecksagon` in it,
-        # as a real boot does. Recording a bind builds IR only, so no adapter needs to
-        # resolve here.
+        # deaf-policy check that skipped it would miss a policy reacting to an event
+        # nothing emits. Recording a bind builds IR only; no adapter resolves here. A chapter
+        # that ships its ports beside its bluebook (`<name>.ports.hecksagon`) is read with them.
         hecksagons = if File.directory?(source)
                        Dir.glob(File.join(source, "*.hecksagon"))
                      else
-                       [source.sub(/\.bluebook\z/, ".hecksagon")]
+                       [".hecksagon", ".ports.hecksagon"].map { |suffix| source.sub(/\.bluebook\z/, suffix) }
                      end
         hecksagons.each { |hecksagon| Kernel.load(hecksagon) if File.exist?(hecksagon) }
       end
@@ -167,17 +130,6 @@ module Hecks
         end
       end
 
-      # Runs `Bluebook::ModelCheck` over one booted domain's chapters, prints its
-      # findings against the allowlist, and reports whether it passes.
-      #
-      # @param name [String] the domain's display name, for the header and the
-      #   `ALLOWED_FINDINGS` lookup
-      # @param registry [Runtime::Registry] a booted registry holding the domain's chapters
-      # @param options [Options] the run's configuration
-      # @param known_domains [Set<String>] every bluebook and hecksagon name booted this run
-      # @param global_emitted_events [Set<String>] every event any booted chapter emits
-      # @return [Boolean] false if an allowlist entry is stale; otherwise true when no
-      #   error-severity finding is left
       def domain_passes?(name, registry, options, known_domains:, global_emitted_events:)
         puts "── #{name}"
 
@@ -203,12 +155,9 @@ module Hecks
         passes?(findings, "   clean — #{chapters.size} chapter(s), no dead states, no unreachable protocol steps")
       end
 
-      # Examines the language's own `Bluebook` and `World` chapters through
-      # `MetaValidator.grammar_registry`, the judged graph its conformance specs use,
-      # because any one grammar file booted alone is a fraction of the language.
-      #
-      # @param options [Options] the run's configuration
-      # @return [Boolean] true when neither chapter has an error-severity finding
+      # Checked through `MetaValidator.grammar_registry`, the judged graph its
+      # conformance specs use, because any one grammar file booted alone is a
+      # fraction of the language.
       def examine_language(options)
         ok = true
         ["Bluebook", "World"].each do |name|
@@ -235,16 +184,8 @@ module Hecks
         errors.empty?
       end
 
-      # Says whether the domain has a Cargo feature, which makes a
-      # `rust_reserved_name` finding an error for it.
-      #
-      # The check reads `rust/Cargo.toml` through the repository-only fuzzing
-      # tooling, so it is loaded only when there is a `rust/` to read.
-      #
-      # @param name [String] the domain's display name
-      # @param rust_dir [String, nil] the repository's `rust/` directory; nil without a
-      #   checkout
-      # @return [Boolean] true when `rust_dir` declares a feature named after the domain
+      # The repository-only fuzzing tooling is loaded lazily, only when there is a
+      # `rust/` to read.
       def rust_target?(name, rust_dir)
         return false unless rust_dir
 
@@ -252,12 +193,7 @@ module Hecks
         Fuzzing::TargetCapabilities.rust_feature?(name, rust_dir)
       end
 
-      # The directory holding a domain's bluebooks: `<domain>/bluebook/` or the
-      # domain directory itself, the same rule `Corpus.bluebook_dir` applies.
-      #
-      # @param domain_path [String] a domain directory path
-      # @return [String, nil] the directory of the first `.bluebook` found, or nil when
-      #   neither place holds one
+      # The same rule `Corpus.bluebook_dir` applies.
       def bluebook_dir(domain_path)
         [File.join(domain_path, "bluebook"), domain_path].each do |dir|
           files = Dir[File.join(dir, "*.bluebook")]

data/lib/hecks/cli/pattern_cases.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hecks
+  module CLI
+    # The command behind `hecks record_pattern_cases`: records the expected match results for
+    # `pattern:` cases, which `spec/pattern_subset_spec.rb` reads from
+    # `spec/corpus/fixtures/patterns.json`.
+    #
+    # The inputs cover embedded and trailing newlines and non-ASCII digits and word characters.
+    module PatternCases
+      # Each pattern with the inputs it is matched against.
+      CASES = [
+        ["^[A-Z]{3}-[0-9]{4}$", ["ABC-1234", "abc-1234", "xx\nABC-1234\nyy", "ABC-1234\n", "ABC-١٢٣٤"]],
+        ["^[0-9]{5}(-[0-9]{4})?$", ["12345", "12345-6789", "1234", "12345\nx", "١٢٣٤٥"]],
+        ['^[^@ ]+@[^@ ]+\.[^@ ]+$', ["a@b.co", "a b@c.co", "no-at-sign", "a@b.co\nevil", "\na@b.co", "café@x.co"]],
+        ["^(red|green|blue)$", ["red", "purple", "red\ngreen", "RED", "x\nred"]],
+        ["^[A-Za-z0-9_]+$", ["abc_1", "a b", "café", "abc\ndef"]],
+        ['^[ \t]*$', ["", "   ", " ", "a", "\n", "\t"]],
+        ["^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$", ["12345678-1234-1234-1234-123456789abc", "nope"]],
+        ['^\+?[0-9 ()-]{7,20}$', ["+44 20 1234", "abc", "+44 20 1234\nx"]],
+        ['\Aonly\z', ["only", "only\n", "x\nonly"]],
+        ["^a.c$", ["abc", "a\nc", "a\tc", "aéc"]]
+      ].freeze
+
+      module_function
+
+      # @return [Array<Hash{String => Object}>] one row per pattern and input, with its match result
+      def rows
+        CASES.flat_map do |pattern, inputs|
+          regexp = Regexp.new(pattern)
+          inputs.map { |input| { "pattern" => pattern, "input" => input, "matches" => regexp.match?(input) } }
+        end
+      end
+
+      # Prints the rows as pretty JSON.
+      #
+      # @param out [IO] where the JSON goes
+      # @return [Integer] the exit status, always 0
+      def call(out: $stdout)
+        out.puts JSON.pretty_generate(rows)
+        0
+      end
+    end
+  end
+end

data/lib/hecks/cli/present.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../forms"
+require_relative "../forms/banking_presentation"
+
+module Hecks
+  module CLI
+    # The command behind `hecks present` and `hecks present`: serves the banking example's rendered
+    # forms and views, backed by the in-memory adapter
+    # (docs/command-form-and-query-form-bluebook.md).
+    #
+    # Then, for example, `http://localhost:4567/` lists every exposed chapter,
+    # `/Banking/Customer.html` every Customer plus Register, `/Banking/Account/Overdrawn.html` a
+    # query view, and `/Banking/Account/Debit` answers the command's shape as JSON.
+    module Present
+      ROOT = File.expand_path("../../..", __dir__)
+
+      module_function
+
+      # Starts a development server and blocks until it stops.
+      #
+      # @param argv [Array<String>] `[-p port]`
+      # @param program [String] the name the refusal calls this command by
+      # @param root [String] the checkout whose examples are served
+      # @return [void]
+      # @raise [SystemExit] when the port argument is refused
+      def call(argv, program: "hecks present", root: ROOT)
+        require "rackup"
+        port, error = Hecks::Forms::PortArgument.parse(argv)
+        abort "#{program}: #{error}" if error
+
+        app = Hecks::Forms::BankingPresentation.app(root: root)
+        puts "command_form.bluebook/query_form.bluebook — Banking, in memory — http://localhost:#{port}/"
+        puts "development server: no authentication, no CSRF protection, no caller identity — do not expose beyond localhost"
+        Rackup::Server.start(app: app, Port: port, server: "webrick")
+      end
+    end
+  end
+end