cybertrain 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 213798cb904eb6eb4ba8f45d0ef3c4d89db13533689a40ca0faf8419514bdc25
-  data.tar.gz: 4a975e911f2e3bbd3de9c3e5d126a5095a52a36bbe21365e97620c0b13b921d1
+  metadata.gz: 7660171ff57ac0e3f625dbffdef0a5a81de709bb80d2bcaf4e2b55be40034c24
+  data.tar.gz: 467b4243e1b26cfa42b64e276f6f859d01c1c7f9bd96df015e1222b66b31dd5d
 SHA512:
-  metadata.gz: 44538d5ef1697095ca313333baaf0c7a47ece4ae98ed480b39da2553cb99f3da265862d24e921a7e60f8226bbb02a52b804cbc7f95b553152730b19f626772e9
-  data.tar.gz: 7edfda7ced1ce88bea85fca1a45ced852ebdee842861fb3ebd6ee0cfe9bfdb317bdecce8e1f330a1095ba1712f5e6f122eb2e48e6b0f447849ea1a29db7b95fb
+  metadata.gz: f56d35ff51a73b15c54376c145197847760d0238cf6599c68559d1c82c84f27998d65b0e53fd594ed7951f7d1b9d75ed3da7895571b4746e3ccb3b58e11bb7d1
+  data.tar.gz: 49a0e1927cd913289307e6684065bf157a1c04c22a585bad2e38cd2826f523cf480aa8a2cea19cd2437fb21dd249dd21a4a3ad97e6c43e231a580f166c202aa6

data/README.md

@@ -3,8 +3,8 @@
 cybertrain is a Rails-shaped web application framework written natively for
 [Spinel](https://github.com/matz/spinel), matz's ahead-of-time Ruby compiler.
 There is no Rack, no gems at runtime, and no Ruby interpreter in the deployed
-artifact: `spin build` compiles an application — controllers, models, views
-and the framework itself — into a single native binary. Where Rails leans on
+artifact: `cybertrain build` compiles an application — controllers, models,
+views and the framework itself — into a single native binary. Where Rails leans on
 runtime metaprogramming (`method_missing`, `define_method`, `eval`) for
 `before_action :set_post` or `Post.where(title: "x")`, cybertrain gets the
 same vocabulary by generating plain, committed Ruby from `db/schema.rb` and
@@ -48,7 +48,8 @@ Spinel, since they find test methods by reflection and an ahead-of-time
 compiler has nothing to reflect on at run time. `spin test --regen
 test/<name>.rb` rewrites a snapshot from CRuby's output; a few tests that
 touch SQLite through FFI take theirs from the compiled binary instead
-([spikes/NOTES.md](spikes/NOTES.md), rule 23).
+([spikes/NOTES.md](spikes/NOTES.md), rule 23); `script/regen-snapshot
+test/<name>.rb` does that build-then-capture step for you and prints the diff stat.
 
 ## Installing the CLI
 
@@ -57,13 +58,29 @@ gem install cybertrain
 ```
 
 The `cybertrain` command is plain Ruby and the gem runs it under CRuby
-(3.2 or newer); the framework itself is not in the gem. Two commands:
-`cybertrain new NAME` scaffolds an application, `cybertrain generate
-scaffold NAME field:type ...` (alias `g scaffold`) adds a resource to one.
+(3.2 or newer); the framework itself is not in the gem. Its commands
+(`cybertrain help` prints them):
+
+- `cybertrain new NAME` creates an application in NAME, then runs `spin
+  lock` and `spin run gen` in it.
+- `cybertrain generate scaffold NAME field:type ...` (alias `g scaffold`)
+  adds a resource to the application in the current directory.
+- `cybertrain migration` generates, applies pending migrations, and
+  generates again (`spin run gen; spin run db -- migrate; spin run gen`).
+- `cybertrain db COMMAND...` runs any database command: `status`,
+  `rollback [N]`, `schema:dump`, `create`.
+- `cybertrain server [PORT]` generates, then starts the development server
+  (`spin run gen; spin run NAME`, or `spin run NAME -- PORT`; default port
+  3000).
+- `cybertrain build` builds NAME with `app/views/` embedded and assembles
+  `dist/` (the binary, `public/`, `storage/`, `tmp/`).
+
+`migration`, `db`, `server` and `build` run inside an application; NAME is
+the `[package] name` in its `spin.toml`.
 
 `cybertrain new` points the app's `spin.toml` at the release matching the
 CLI — `cybertrain = { git = "https://github.com/saeki-mototsune/cybertrain",
-ref = "v0.1.0" }` — then runs `spin lock` (spin fetches the framework into
+ref = "v0.1.1" }` — then runs `spin lock` (spin fetches the framework into
 its cache, `~/.cache/spin/packages/`, and pins the commit in `spin.lock`)
 and `spin run gen`, much as `rails new` runs `bundle install`. Nothing of
 the framework is copied into the app; commit `spin.toml` and `spin.lock`.
@@ -87,7 +104,7 @@ articles and comments.
 ```sh
 cybertrain new blog
 cd blog
-spin build            # works right away: `new` already locked the framework and ran `spin run gen`
+cybertrain server            # works right away: `new` already locked the framework and ran `spin run gen`
 ```
 
 ```
@@ -95,10 +112,22 @@ blog/
   spin.toml  config/app.rb  config/routes.rb
   db/schema.rb  db/migrate/
   app/controllers/application_controller.rb  app/models/  app/views/  app/helpers/
-  public/  bin/server.rb  bin/gen.rb  bin/db.rb
+  public/  bin/blog.rb  bin/gen.rb  bin/db.rb
   gen/  storage/  tmp/  test/
 ```
 
+`bin/blog.rb` is the application's one entry point, the program `spin build
+blog` compiles: `./blog` serves, `./blog migrate` and `./blog db status`
+manage the database. `bin/gen.rb` runs the generator (`spin run gen`), and
+`bin/db.rb` runs the migrator during development (`cybertrain migration`
+uses it, since `bin/blog.rb` cannot compile until the first migration has
+generated `gen/models/`). `gen/` already holds `views.rb`, the committed,
+empty table of embedded views (see "How it works").
+
+Apps created before `cybertrain build` existed have `bin/server.rb` and
+no `bin/<name>.rb`: copy `bin/<name>.rb` from a fresh `cybertrain new` (with
+the same NAME), delete `bin/server.rb` and run `spin run gen`.
+
 `ApplicationController` starts with the one thing every controller inherits:
 
 ```ruby
@@ -181,11 +210,14 @@ end
 ### Generate, migrate, run
 
 ```sh
-spin run gen          # reads db/schema.rb + config/routes.rb, scans app/, writes gen/
-spin run db -- migrate   # applies db/migrate/*.rb, rewrites db/schema.rb (arguments go after --)
-spin run server       # http://127.0.0.1:3000
+cybertrain migration     # spin run gen; spin run db -- migrate; spin run gen
+cybertrain server        # http://127.0.0.1:3000; rebuilds on Ruby edits, views reload without a rebuild
 ```
 
+`spin run gen` reads `db/schema.rb` and `config/routes.rb`, scans `app/` and
+writes `gen/`; `spin run db -- migrate` applies `db/migrate/*.rb` and
+rewrites `db/schema.rb`.
+
 Re-run `spin run gen` (and commit `gen/`) after touching the schema, routes,
 or a controller/model's callbacks and ivars — the dev server does this for
 you automatically (see "How it works").
@@ -277,6 +309,27 @@ child routes to the nested collection (`article_comments_path`), a persisted
 one to the nested member (`article_comment_path`) — generated into
 `gen/routes.rb` from the nested `resources` block above.
 
+### Build for deployment
+
+```sh
+cybertrain build
+```
+
+writes `dist/`: `dist/blog`, the app compiled with every `app/views/`
+template embedded (rendered from memory, error messages still say
+`articles/show.html.erb:12`), `dist/public/`, and empty `dist/storage/` and
+`dist/tmp/`. Copy `dist/` to a machine with the same OS and CPU (the binary
+links the system SQLite) and run `./blog migrate && ./blog`; a built binary
+is production by default (`CYBERTRAIN_ENV` overrides). Set
+`CYBERTRAIN_SECRET_KEY_BASE`. Static files can also be served by the reverse
+proxy from `dist/public/` — see [docs/deploy.md](docs/deploy.md).
+
+A running `cybertrain server` skips its rebuilds while `cybertrain build` is
+in progress (the build holds `tmp/cybertrain-build.lock`, since both write
+`build/bin/blog`), logs the skip, and rebuilds as usual on the next save
+once the build has finished. The lock records the build's PID; one left
+behind by a killed build is ignored and removed.
+
 ## How it works
 
 **Build-time code generation.** `spin run gen` (`bin/gen.rb`) executes
@@ -289,17 +342,24 @@ zero-argument `def`s. From that it writes plain, readable Ruby under `gen/`:
 `gen/models/<name>.rb` (accessors, casts, finders, FK-derived associations),
 `gen/routes.rb` (route table, dispatcher, `*_path`/`*_url` helpers),
 `gen/controllers.rb` (`view_assigns` and `run_callback` per controller),
-`gen/migrations.rb` and `gen/app.rb` (the `require_relative` manifest).
+`gen/migrations.rb`, `gen/views.rb` (the embedded views table, empty unless
+building for deployment) and `gen/app.rb` (the `require_relative` manifest).
 `gen/` is committed, not gitignored — `spin build`/`spin test` have no hook
 to generate first, so the checked-in output has to already be what compiles.
 CI re-runs `spin run gen` and fails on a diff, so stale generated code can't
 merge.
 
 **Views are interpreted, not compiled.** `app/views/**/*.html.erb` files look
-like Rails ERB but are read from disk, parsed into an AST at request time
-(cached after first parse in production; re-parsed on change in
-development), then walked by a tree-walking interpreter — Spinel has no
-`eval`, so this is a closed grammar (literals, `@ivar`/local lookups, calls
+like Rails ERB but are parsed into an AST at request time, then walked by a
+tree-walking interpreter. Where the source comes from depends on the mode:
+in development (and test) the engine reads `app/views/` from disk and
+re-parses a template when it changes, so view edits need no rebuild.
+`cybertrain build` runs `spin run gen -- --embed-views`, which writes every
+template's source into `gen/views.rb` as a string table for that one `spin
+build`, then runs `spin run gen` again to restore the empty table that is
+committed; the production binary renders only that table (parsing each
+template once) and refuses to boot when it is empty (`error: views are not
+embedded in this binary`). Spinel has no `eval`, so this is a closed grammar (literals, `@ivar`/local lookups, calls
 through fixed per-type dispatch tables, `if`/`unless`,
 `each`/`each_with_index`/one helper block), not real Ruby. Full grammar,
 helpers and gaps: [docs/template-language.md](docs/template-language.md).
@@ -316,10 +376,11 @@ faster and stall-free for this I/O-bound shape at 100 concurrent connections.
 and foreign keys on; every query is bound, never interpolated. It's the only
 adapter today (PostgreSQL via `libpq` FFI is noted as possible future work).
 
-**The development loop.** `spin run server` in `development` (the default
-`CYBERTRAIN_ENV`) also polls `app/**/*.rb`, `config/**/*.rb`, `db/schema.rb`
+**The development loop.** `cybertrain server` (`spin run gen`, then `spin run NAME`) in
+`development` (the default `CYBERTRAIN_ENV`, except in a binary from
+`cybertrain build`) also polls `app/**/*.rb`, `config/**/*.rb`, `db/schema.rb`
 and `gen/**/*.rb` every half second (views are excluded — the engine reloads
-those itself). A change runs `spin run gen && spin build server` in the
+those itself — and so is `gen/views.rb`, empty in development). A change runs `spin run gen && spin build NAME` in the
 background; success sends the server `SIGHUP`, whose handler stops listening
 and `execv`s the new binary on the same port and PID, invisible to a client
 mid-session. A failed build keeps serving the old binary and banners the
@@ -330,7 +391,7 @@ compiler output on every HTML response. None of this loads in production.
 | Rails | cybertrain |
 | --- | --- |
 | `rails console` | No console — Spinel has no `eval` |
-| Edit code, the running app picks it up | Ruby needs a rebuild; `spin run server` in development does this for you (rebuild, `SIGHUP`, `execv`) |
+| Edit code, the running app picks it up | Ruby needs a rebuild; `cybertrain server` in development does this for you (rebuild, `SIGHUP`, `execv`) |
 | Edit a view, no reload needed | Same — views are parsed from disk per request in development |
 | `def new` | `def new_action` (`new` would shadow `Klass.new(ctx)`) |
 | `before_action { do_thing }` (implicit `self`) | `before_action { \|c\| c.do_thing }` — no `instance_exec` on a stored block, so callbacks take the controller/record explicitly |
@@ -361,7 +422,7 @@ end
 
 | Variable | Attribute | Default |
 | --- | --- | --- |
-| `CYBERTRAIN_ENV` | `env` | `"development"` (also `"test"`, `"production"`) |
+| `CYBERTRAIN_ENV` | `env` | `"development"`; `"production"` in a binary from `cybertrain build` (also `"test"`) |
 | `PORT` | `port` | `3000` |
 | `CYBERTRAIN_DATABASE` | `database_path` | `storage/#{env}.sqlite3` |
 | `CYBERTRAIN_SECRET_KEY_BASE` | `secret_key_base` | required in production; dev/test auto-generate one into `tmp/secret_key` |
@@ -374,10 +435,12 @@ Other attributes with fixed, overridable defaults: `host` (`"127.0.0.1"`),
 marks the session cookie `Secure`; `false` elsewhere), `pool_size` (4),
 `static_files`/`csrf` (`true`).
 
-**Deployment:** `spin build server` produces `build/bin/server`. Ship it with
-`app/views/` (read at request time, never compiled in), `public/` (static
-assets, or let a reverse proxy serve it) and `storage/` (the SQLite file),
-`CYBERTRAIN_ENV=production` and `CYBERTRAIN_SECRET_KEY_BASE` set. The binary
+**Deployment:** `cybertrain build` produces `dist/`: the binary `dist/NAME`
+with the views embedded, `dist/public/` (static assets, or let a reverse
+proxy serve it), and `dist/storage/` (the SQLite file by default) and
+`dist/tmp/`. Run it from `dist/` with `CYBERTRAIN_SECRET_KEY_BASE` set;
+it is production unless `CYBERTRAIN_ENV` says otherwise, and `./NAME
+migrate` applies the migrations compiled into it. The binary
 speaks plain HTTP/1.1 only; put nginx/Caddy in front for TLS and HTTP/2 (the
 session cookie is `Secure` in production, so serve it over HTTPS). In
 production an exception answers 500 and a bare error response (the router's
@@ -453,8 +516,8 @@ before the gem is pushed:
 1. Bump `Cybertrain::VERSION` (`cybertrain/version.rb`) and `version` in
    `spin.toml` together (CI checks they match); spin caches a git
    dependency by that version.
-2. Merge to `main`, then tag and push: `git tag v0.1.0 && git push origin v0.1.0`.
-3. `gem build cybertrain.gemspec && gem push cybertrain-0.1.0.gem`.
+2. Merge to `main`, then tag and push: `git tag v0.1.1 && git push origin v0.1.1`.
+3. `gem build cybertrain.gemspec && gem push cybertrain-0.1.1.gem`.
 
 ## License
 

data/cybertrain/cli/build.rb

@@ -0,0 +1,174 @@
+# `cybertrain build`: dist/ = the app binary with app/views embedded, plus
+# public/. Also the command lists `cybertrain migration` and `server` run. Plain Ruby:
+# runs under CRuby (the gem) and compiles under Spinel (spin install).
+module Cybertrain
+  module CLI
+    module Build
+      # The [package] name in root/spin.toml, or "" when there is none.
+      def self.app_name(root)
+        path = "#{root}/spin.toml"
+        return "" unless File.exist?(path)
+
+        name = ""
+        in_package = false
+        File.read(path).each_line do |line|
+          text = line.strip
+          in_package = text == "[package]" if text.start_with?("[")
+          next unless in_package && text.start_with?("name")
+
+          match = text.match(/\Aname\s*=\s*"([^"]*)"/)
+          unless match.nil?
+            name = match[1]
+            break
+          end
+        end
+        name
+      end
+
+      def self.commands(name)
+        ["spin run gen -- --embed-views", "spin build #{name}", "spin run gen"]
+      end
+
+      # Through bin/db.rb: the app binary cannot compile before the first
+      # migration has produced gen/models.
+      def self.migration_commands
+        ["spin run gen", "spin run db -- migrate", "spin run gen"]
+      end
+
+      # port is "" (the app's default, 3000) or a port? string.
+      def self.server_commands(name, port)
+        run = port == "" ? "spin run #{name}" : "spin run #{name} -- #{port}"
+        ["spin run gen", run]
+      end
+
+      # All digits, 1 to 65535 (the app reads 0 as "no port").
+      def self.port?(text)
+        return false if text.empty? || text.size > 5
+        return false unless text.bytes.all? { |b| b >= 48 && b <= 57 }
+
+        text.to_i >= 1 && text.to_i <= 65535
+      end
+
+      # Runs one build step (a spin command) in root; true when it succeeds.
+      # Build.run takes a Runner so tests can stand in for spin.
+      class Runner
+        def run_step(root, command)
+          Build.run_in(root, command)
+        end
+      end
+
+      # Holds this process's PID while the steps run and dist/ is assembled:
+      # the development server (Dev::Rebuilder) skips its rebuilds
+      # meanwhile, since both write build/bin/<name>, and treats a lock
+      # whose PID is gone (a killed build) as stale.
+      def self.lock_path(root)
+        "#{root}/tmp/cybertrain-build.lock"
+      end
+
+      # Runs the build in root and assembles dist/. Returns the exit code.
+      def self.run(root, name, runner = Runner.new)
+        steps = commands(name)
+        ok = false
+        restored = false
+        code = 1
+        Templates.mkdir_p("#{root}/tmp")
+        File.write(lock_path(root), Process.pid.to_s)
+        begin
+          begin
+            ok = runner.run_step(root, steps[0]) && runner.run_step(root, steps[1])
+          ensure
+            # Always put gen/views.rb back to the empty table, even after a
+            # failure or Ctrl-C.
+            restored = runner.run_step(root, steps[2])
+            puts "warning: gen/views.rb still holds the embedded views; run spin run gen" unless restored
+          end
+          if ok && restored
+            assemble(root, name)
+            code = 0
+          end
+        ensure
+          # Released only once dist/ holds the new binary: assemble reads
+          # build/bin/<name>, which a dev rebuild would be writing.
+          File.delete(lock_path(root)) if File.exist?(lock_path(root))
+        end
+        return 1 unless code == 0
+
+        puts ""
+        puts "dist/#{name}       (production by default)"
+        puts "dist/public/"
+        puts "run:  cd dist && ./#{name} migrate && ./#{name}"
+        0
+      end
+
+      def self.run_in(root, command)
+        puts "run    #{command}"
+        system("cd #{shell_quote(root)} && #{command}")
+      end
+
+      # Copies build/bin/<name> and public/ into dist/; storage/ and tmp/ are
+      # created when missing and never emptied (a database and the secret
+      # key can live there). Each copy lands in a dist/.*.tmp entry first and
+      # is renamed into place: a running dist/<name> keeps its old file
+      # (writing over a running binary fails with ETXTBSY on Linux), and the
+      # old dist/public/ steps aside to dist/.public.old between two renames
+      # (rename cannot replace a non-empty directory), so dist/public/ is
+      # missing only for that instant rather than for the whole copy.
+      def self.assemble(root, name)
+        binary = "#{root}/build/bin/#{name}"
+        raise InvalidArgument, "build/bin/#{name} is missing: `spin build #{name}` did not produce it" unless File.exist?(binary)
+
+        dist = "#{root}/dist"
+        Templates.mkdir_p(dist)
+        binary_tmp = "#{dist}/.#{name}.tmp"
+        public_tmp = "#{dist}/.public.tmp"
+        public_old = "#{dist}/.public.old"
+        # Leftovers of an interrupted earlier run.
+        rm_tree(binary_tmp)
+        rm_tree(public_tmp)
+        rm_tree(public_old)
+
+        copy_command = "cp #{shell_quote(binary)} #{shell_quote(binary_tmp)}"
+        raise InvalidArgument, "could not copy #{binary} to dist/" unless system(copy_command)
+
+        File.rename(binary_tmp, "#{dist}/#{name}")
+
+        if File.directory?("#{root}/public")
+          public_command = "cp -R #{shell_quote("#{root}/public")} #{shell_quote(public_tmp)}"
+          raise InvalidArgument, "could not copy public/ to dist/" unless system(public_command)
+        else
+          Dir.mkdir(public_tmp)
+        end
+        public_dir = "#{dist}/public"
+        File.rename(public_dir, public_old) if File.exist?(public_dir) || File.symlink?(public_dir)
+        File.rename(public_tmp, public_dir)
+        rm_tree(public_old)
+
+        Templates.mkdir_p("#{dist}/storage")
+        Templates.mkdir_p("#{dist}/tmp")
+        ["dist/#{name}", "dist/public/", "dist/storage/", "dist/tmp/"]
+      end
+
+      # A symlink is removed itself, never followed: its target may be
+      # dist/storage/ or outside dist/.
+      def self.rm_tree(path)
+        if File.symlink?(path)
+          File.delete(path)
+          return nil
+        end
+        return nil unless File.exist?(path)
+
+        if File.directory?(path)
+          Dir.children(path).each { |child| rm_tree("#{path}/#{child}") }
+          Dir.rmdir(path)
+        else
+          File.delete(path)
+        end
+        nil
+      end
+
+      def self.shell_quote(text)
+        "'#{text.gsub("'", "'\\\\''")}'"
+      end
+    end
+  end
+end

data/cybertrain/cli/new_app.rb

@@ -18,7 +18,7 @@ module Cybertrain
         files = [
           ["spin.toml", Templates.spin_toml(package, framework_dep)],
           [".gitignore", Templates.gitignore],
-          ["README.md", Templates.readme(title)],
+          ["README.md", Templates.readme(title, package)],
           ["config/app.rb", Templates.config_app],
           ["config/routes.rb", Templates.routes],
           ["db/schema.rb", Templates.schema],
@@ -30,7 +30,7 @@ module Cybertrain
           ["public/404.html", Templates.error_page("404", "Not Found")],
           ["public/500.html", Templates.error_page("500", "Internal Server Error")],
           ["public/style.css", Templates.style_css],
-          ["bin/server.rb", Templates.bin_server],
+          ["bin/#{package}.rb", Templates.bin_app(package)],
           ["bin/gen.rb", Templates.bin_gen],
           ["bin/db.rb", Templates.bin_db],
           ["gen/.keep", ""],

data/cybertrain/cli/templates.rb

@@ -76,6 +76,7 @@ module Cybertrain
       def self.gitignore
         <<~TEXT
           /build/
+          /dist/
           /storage/*.sqlite3*
           /tmp/*
           !/tmp/.keep
@@ -83,7 +84,7 @@ module Cybertrain
         TEXT
       end
 
-      def self.readme(title)
+      def self.readme(title, package)
         <<~MARKDOWN
           # #{title}
 
@@ -91,16 +92,22 @@ module Cybertrain
 
           ```sh
           cybertrain generate scaffold post title:string body:text
-          spin run gen           # pick up the new migration (gen/migrations.rb)
-          spin run db -- migrate # apply db/migrate, rewrite db/schema.rb
-          spin run gen           # regenerate gen/ from db/schema.rb, config/routes.rb and app/
-          spin run server        # http://127.0.0.1:3000
+          cybertrain migration   # gen, apply db/migrate, gen again
+          cybertrain server      # http://127.0.0.1:3000 (`cybertrain server 4000` for another port)
+          cybertrain build       # dist/: the binary (views embedded) + public/
           ```
 
-          Run `spin run gen` after changing the schema, the routes or a
-          controller's instance variables and callbacks, and commit `gen/`.
-          Views under `app/views/` are read at run time: edit them without
-          rebuilding.
+          `spin run gen` (which `migration`, `server` and `build` run for you)
+          regenerates `gen/` from db/schema.rb, config/routes.rb and app/;
+          commit `gen/`. In development views under `app/views/` are read at
+          run time: edit them without rebuilding. `cybertrain db status` and
+          `cybertrain db rollback 1` reach the other database commands.
+          `cybertrain migration` runs migrations through `bin/db.rb`; a
+          deployed `dist/#{package}` runs them with `./#{package} migrate`.
+
+          To deploy, copy `dist/` to a machine with the same OS and CPU, then
+          `cd dist && ./#{package} migrate && ./#{package}` (production by default;
+          set CYBERTRAIN_SECRET_KEY_BASE).
         MARKDOWN
       end
 
@@ -204,17 +211,18 @@ module Cybertrain
         CSS
       end
 
-      def self.bin_server
+      def self.bin_app(package)
         <<~RUBY
           require "cybertrain"
-          require_relative "../config/app"
+          require_relative "../gen/views"      # embedded build: sets CYBERTRAIN_ENV=production by default
+          require_relative "../config/app"     # so it comes before the config
           require_relative "../gen/app"
+          require_relative "../gen/migrations"
 
-          app = Cybertrain::Application.new(
-            router: Gen::Routes.build(Cybertrain::Router.new),
-            url_resolver: Gen::Routes.url_resolver
-          )
-          app.run
+          exit(Cybertrain::Main.run("#{package}", ARGV,
+                                    router: Gen::Routes.build(Cybertrain::Router.new),
+                                    url_resolver: Gen::Routes.url_resolver,
+                                    views: Gen::Views::SOURCES))
         RUBY
       end
 
@@ -228,6 +236,7 @@ module Cybertrain
         RUBY
       end
 
+      # Development only, so migrations run before gen/models exist; production uses `./NAME migrate`.
       def self.bin_db
         <<~RUBY
           require "cybertrain"

data/cybertrain/cli.rb

@@ -3,11 +3,13 @@
 #
 #   cybertrain new NAME [--path DIR | --version V] [--skip-spin]
 #   cybertrain generate scaffold NAME field:type ... [parent:references]
+#   cybertrain migration | db COMMAND... | server [PORT] | build
 #   cybertrain version | help
 require "cybertrain/version"
 require "cybertrain/cli/templates"
 require "cybertrain/cli/new_app"
 require "cybertrain/cli/scaffold"
+require "cybertrain/cli/build"
 
 module Cybertrain
   module CLI
@@ -24,6 +26,17 @@ module Cybertrain
         cybertrain generate scaffold NAME field:type ... [parent:references]
             Add a resource to the application in the current directory.
             Types: #{Field::TYPES.join(", ")} (default string).
+        cybertrain migration
+            Generate, apply pending migrations, generate again
+            (spin run gen; spin run db -- migrate; spin run gen).
+        cybertrain db COMMAND...
+            Any database command: status, rollback [N], schema:dump, create.
+        cybertrain server [PORT]
+            Generate, then start the development server
+            (spin run gen; spin run NAME [-- PORT]; default port 3000).
+        cybertrain build
+            Build NAME with app/views embedded and assemble dist/
+            (the binary, public/, storage/, tmp/).
         cybertrain version
         cybertrain help
     TEXT
@@ -34,6 +47,10 @@ module Cybertrain
       case command
       when "new" then run_new(argv)
       when "generate", "g" then run_generate(argv)
+      when "migration" then run_in_app { |_name| run_all(Build.migration_commands) }
+      when "db" then run_in_app { |_name| run_all(["spin run db -- #{db_args(argv)}"]) }
+      when "server" then run_in_app { |name| run_server(name, argv) }
+      when "build" then run_in_app { |name| Build.run(".", name) }
       when "version", "--version", "-v"
         puts "cybertrain #{Cybertrain::VERSION}"
         0
@@ -88,6 +105,48 @@ module Cybertrain
       argv[i + 1]
     end
 
+    # Commands that need the app: its name comes from ./spin.toml.
+    def self.run_in_app
+      name = Build.app_name(".")
+      if name == ""
+        puts "error: no spin.toml with a [package] name here; run this inside a cybertrain application"
+        return 1
+      end
+      yield name
+    end
+
+    # Runs each command in turn; stops at the first failure.
+    def self.run_all(commands)
+      status = 0
+      commands.each do |command|
+        puts "run    #{command}"
+        unless system(command)
+          status = 1
+          break
+        end
+      end
+      status
+    end
+
+    # `cybertrain server [PORT]`.
+    def self.run_server(name, argv)
+      port = argv.size > 1 ? argv[1] : ""
+      unless port == "" || Build.port?(port)
+        puts "error: PORT must be a number"
+        return 1
+      end
+      if argv.size > 2
+        puts "error: unexpected argument '#{argv[2]}'"
+        return 1
+      end
+      run_all(Build.server_commands(name, port))
+    end
+
+    # The words after `db`, each shell-quoted.
+    def self.db_args(argv)
+      argv[1, argv.size - 1].map { |arg| Build.shell_quote(arg) }.join(" ")
+    end
+
     def self.run_generate(argv)
       kind = argv.size > 1 ? argv[1] : ""
       raise InvalidArgument, "only `generate scaffold` is supported" unless kind == "scaffold"

data/cybertrain/version.rb

@@ -1,5 +1,5 @@
 module Cybertrain
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 
   # Where `cybertrain new` points an app's spin.toml by default: the git tag
   # "v#{VERSION}" of this repository. Kept here because the gem (CRuby) and

data/exe/cybertrain

@@ -4,4 +4,12 @@
 # same entry point, compiled by spin).
 require "cybertrain/cli"
 
-exit(Cybertrain::CLI.run(ARGV))
+# Ctrl-C reaches the whole process group: the child (`spin run NAME`, a
+# build) stops itself, and CRuby raises Interrupt out of `system` here.
+# Build.run's ensure has restored gen/views.rb by the time it arrives.
+begin
+  status = Cybertrain::CLI.run(ARGV)
+rescue Interrupt
+  status = 130
+end
+exit(status)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cybertrain
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Saeki Mototsune
@@ -21,6 +21,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - cybertrain/cli.rb
+- cybertrain/cli/build.rb
 - cybertrain/cli/new_app.rb
 - cybertrain/cli/scaffold.rb
 - cybertrain/cli/templates.rb