cybertrain 0.1.0 → 0.2.0

data/cybertrain/cli/build.rb

@@ -0,0 +1,192 @@
+# `cybertrain build`: dist/ = the app binary with app/views embedded, plus
+# public/. Also the command lists `cybertrain db` 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
+
+      # `cybertrain db ARGS`, through bin/db.rb (the app binary cannot compile
+      # before the first migration has produced gen/models). bin/db.rb only
+      # knows the migrations gen/migrations.rb lists, so gen runs first;
+      # migrate and rollback rewrite db/schema.rb, which gen/models is
+      # derived from, so gen runs again after them.
+      def self.db_commands(args)
+        words = args.map { |arg| quote_arg(arg) }.join(" ")
+        commands = ["spin run gen", "spin run db -- #{words}"]
+        commands << "spin run gen" if args[0] == "migrate" || args[0] == "rollback"
+        commands
+      end
+
+      # `cybertrain migration`: the same as `cybertrain db migrate`.
+      def self.migration_commands
+        db_commands(["migrate"])
+      end
+
+      # A word sh reads as itself stays bare; anything else is single-quoted.
+      def self.quote_arg(text)
+        return text if !text.empty? && text.match(/\A[A-Za-z0-9_:.\/-]+\z/)
+
+        shell_quote(text)
+      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

@@ -1,12 +1,12 @@
 # `cybertrain new blog`: writes the skeleton of an application package.
 require "cybertrain/generator/inflector"
 require "cybertrain/cli/templates"
+require "cybertrain/cli/build"
+require "cybertrain/cli/toolchain"
 
 module Cybertrain
   module CLI
     module NewApp
-      KEEP_DIRS = ["db/migrate", "app/models", "app/helpers", "gen", "storage", "tmp", "test"]
-
       # dir is the directory to create ("blog" or "path/to/blog"; its last
       # component names the package). framework_dep is the TOML value that
       # spin.toml's `cybertrain =` line gets: `{ path = "/abs/cybertrain" }` or
@@ -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", ""],
@@ -47,28 +47,33 @@ module Cybertrain
 
       # What `rails new` does with `bundle install`: resolve and lock the
       # framework (fetching it into spin's cache, ~/.cache/spin), then write
-      # gen/ so `spin build` works straight away. Without spin on PATH it
-      # only says what to run later. Returns false when a step failed.
+      # gen/ so `spin build` works straight away. Installs Spinel first when
+      # this machine has none of the pinned release (Toolchain.ensure!).
+      # Returns false when a step failed.
       def self.bootstrap(dir)
-        unless system("command -v spin > /dev/null 2>&1")
-          puts "skip spin lock / spin run gen: `spin` is not on PATH"
-          puts "  install Spinel (https://github.com/matz/spinel), then: #{bootstrap_command(dir)}"
-          return true
+        unless Toolchain.ensure!
+          puts "skip spin lock / spin run gen: Spinel #{Cybertrain::SPINEL_TAG} is not available"
+          puts "  fix the problem above (`cybertrain doctor` lists the checks), then: cybertrain setup && #{recovery_command(dir)}"
+          return false
         end
 
         puts "run    spin lock && spin run gen"
         return true if system(bootstrap_command(dir))
 
-        puts "error: bootstrapping #{dir} failed; fix the cause, then run: #{bootstrap_command(dir)}"
+        puts "error: bootstrapping #{dir} failed; fix the cause, then run: #{recovery_command(dir)}"
         false
       end
 
+      # Run by bootstrap once Toolchain.ensure! has put spin on this
+      # process's PATH.
       def self.bootstrap_command(dir)
-        "cd #{shell_quote(dir)} && spin lock && spin run gen"
+        "cd #{Build.shell_quote(dir)} && spin lock && spin run gen"
       end
 
-      def self.shell_quote(text)
-        "'#{text.gsub("'", "'\\\\''")}'"
+      # The same steps for the user to run by hand: through `cybertrain
+      # spin`, since the Spinel cybertrain installed is not on their PATH.
+      def self.recovery_command(dir)
+        "cd #{Build.shell_quote(dir)} && cybertrain spin lock && cybertrain spin run gen"
       end
     end
   end

data/cybertrain/cli/scaffold.rb

@@ -92,6 +92,13 @@ module Cybertrain
         @fields = fields
       end
 
+      # The index route helper's name without _path, as Rails' scaffold
+      # names it: the plural, or "<plural>_index" for a word that is its own
+      # plural (sheep_index_path), matching the routes DSL.
+      def index_helper
+        @plural == @singular ? "#{@plural}_index" : @plural
+      end
+
       # The column the model validates for presence ("" when there is none).
       def first_string_field
         @fields.each { |f| return f.field_name if f.field_type == "string" }

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 db migrate  # 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 `db`, `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 db migrate` 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"
@@ -317,7 +326,7 @@ module Cybertrain
             def destroy
               @#{s}.destroy
               flash[:notice] = "#{human} was successfully destroyed."
-              redirect_to #{p}_path, status: :see_other
+              redirect_to #{res.index_helper}_path, status: :see_other
             end
 
             private
@@ -362,7 +371,7 @@ module Cybertrain
         end
         buf << "<p>\n"
         buf << "  <%= link_to \"Edit this #{words}\", edit_#{s}_path(@#{s}) %> |\n"
-        buf << "  <%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.plural}_path %>\n"
+        buf << "  <%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.index_helper}_path %>\n"
         buf << "</p>\n\n"
         buf << "<%= button_to \"Destroy this #{words}\", #{s}_path(@#{s}), method: :delete %>\n"
         buf
@@ -373,7 +382,7 @@ module Cybertrain
         buf = +""
         buf << "<h1>New #{s.tr("_", " ")}</h1>\n\n"
         buf << "<%= render \"form\", #{s}: @#{s} %>\n\n"
-        buf << "<p><%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.plural}_path %></p>\n"
+        buf << "<p><%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.index_helper}_path %></p>\n"
         buf
       end
 
@@ -384,7 +393,7 @@ module Cybertrain
         buf << "<%= render \"form\", #{s}: @#{s} %>\n\n"
         buf << "<p>\n"
         buf << "  <%= link_to \"Show this #{s.tr("_", " ")}\", #{s}_path(@#{s}) %> |\n"
-        buf << "  <%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.plural}_path %>\n"
+        buf << "  <%= link_to \"Back to #{res.plural.tr("_", " ")}\", #{res.index_helper}_path %>\n"
         buf << "</p>\n"
         buf
       end