edgeway 0.1.0 → 0.2.0

data/lib/edgeway/cli/build/view_compiler.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../../inflector"
+
+module Edgeway
+  module CLI
+    class Build
+      # app/views/**/*.html.erb -> Ruby that reopens the controllers.
+      #
+      # Spinel has no eval and no binding, so a template can't be read at
+      # runtime: each one becomes an instance method of its controller (it sees
+      # the action's @variables, params and helpers as any method of it does),
+      # and `edgeway build` / `edgeway test` require the result after the
+      # controllers.
+      #
+      #   app/views/todos/index.html.erb   TodosController#_view_todos_index
+      #   app/views/layouts/application.html.erb
+      #                                    ApplicationController#_render_layout
+      #
+      # A controller gets `_render_view(action)` too: a case over its templates,
+      # not a send, since with a computed name Spinel's send misses the methods
+      # of a subclass (matz/spinel#8592).
+      #
+      # The ERB it reads is a small subset (stdlib ERB is not used):
+      #   <%= expr %>    expr, HTML-escaped
+      #   <%== expr %>   expr, as it is
+      #   <% code %>     code
+      #   <%# text %>    nothing
+      #   <%%            a literal <%
+      #   <%-            starts a tag and drops the indentation before it
+      #   -%>            ends a tag and drops the newline after it
+      # and `<%= yield %>` (or `<%== yield %>`) in the layout is the page, as
+      # it is.
+      class ViewCompiler
+        EXT = ".html.erb"
+        LAYOUT = "layouts/application#{EXT}"
+        NAME = /\A[a-z_][a-z0-9_]*\z/
+
+        def initialize(root)
+          @root = root
+        end
+
+        # The Ruby for app/views, nil when the app has none.
+        def compile
+          views = File.join(@root, "app/views")
+          return nil unless Dir.exist?(views)
+
+          files = Dir.glob("**/*#{EXT}", base: views).sort
+          layout = files.delete(LAYOUT)
+          files.reject! { |f| f.start_with?("layouts/") }
+          by_dir = {}
+          files.each do |f|
+            dir = File.dirname(f)
+            raise Error, "app/views/#{f}: a template goes in a controller's directory (app/views/todos/index#{EXT})" if dir == "."
+
+            (by_dir[dir] ||= []) << f
+          end
+
+          out = ["# Generated by `edgeway build` from app/views; do not edit."]
+          out.concat(layout_source(layout)) if layout
+          by_dir.each { |dir, fs| out.concat(controller_source(dir, fs)) }
+          out.join("\n") + "\n"
+        end
+
+        def template_lines(text, path, layout: false)
+          lines = []
+          pos = 0
+          literal = +""
+          # the line of text[counted], advanced as the scan goes
+          counted = 0
+          line = 1
+          while (open = text.index("<%", pos))
+            if text[open + 2] == "%"
+              literal << text[pos...open] << "<%"
+              pos = open + 3
+              next
+            end
+            line += text[counted...open].count("\n")
+            counted = open
+            close = text.index("%>", open + 2) or raise Error, "#{path}:#{line}: unclosed <%"
+            literal << text[pos...open]
+            body = text[(open + 2)...close]
+            if body.start_with?("-")
+              body = body[1..]
+              # <%- also drops the indentation before it on its line
+              line_start = open > 0 ? (text.rindex("\n", open - 1) || -1) + 1 : 0
+              indent = open - line_start
+              literal = literal[0...(literal.length - indent)] if indent > 0 && text[line_start...open].strip.empty?
+            end
+            trim = body.end_with?("-")
+            body = body.chomp("-") if trim
+            after = close + 2
+            if trim && text[after] == "\n"
+              after += 1
+            elsif trim && text[after, 2] == "\r\n"
+              after += 2
+            end
+            flush(lines, literal)
+            code = body.strip
+            if body.start_with?("#")
+            elsif body.start_with?("==")
+              expr = code[2..].strip
+              lines << "# #{path}:#{line}" << output(expr, "(", ").to_s", layout, path, line)
+            elsif body.start_with?("=")
+              expr = code[1..].strip
+              lines << "# #{path}:#{line}" << output(expr, "Edgeway::View.escape(", ")", layout, path, line)
+            else
+              lines << "# #{path}:#{line}" << code
+            end
+            pos = after
+          end
+          literal << text[pos..]
+          flush(lines, literal)
+          lines
+        end
+
+        private
+
+        # An output tag; the closing paren goes on its own line so that a
+        # trailing `# comment` in the tag doesn't swallow it. `yield` is the
+        # page in the layout.
+        def output(expr, head, tail, layout, path, line)
+          if expr == "yield"
+            raise Error, "#{path}:#{line}: yield is only for the layout" unless layout
+
+            return "out << content"
+          end
+          "out << #{head}#{expr}\n#{tail}"
+        end
+
+        def flush(lines, literal)
+          return if literal.empty?
+
+          lines << "out << #{literal.dump}"
+          literal.clear
+        end
+
+        def layout_source(file)
+          path = "app/views/#{file}"
+          controller_file!("application", path)
+          body = template_lines(File.read(File.join(@root, path)), path, layout: true)
+          wrap("ApplicationController", method_source("_render_layout(content)", body, path))
+        end
+
+        def controller_source(dir, files)
+          controller_file!(dir, "app/views/#{dir}/")
+          methods = []
+          actions = []
+          files.each do |f|
+            path = "app/views/#{f}"
+            action = File.basename(f).delete_suffix(EXT)
+            raise Error, "#{path}: #{action.inspect} is not a valid action name" unless NAME.match?(action)
+            dir.split("/").each { |part| raise Error, "#{path}: #{part.inspect} is not a valid controller path" unless NAME.match?(part) }
+
+            name = "_view_#{dir.tr("/", "_")}_#{action}"
+            methods.concat(method_source(name, template_lines(File.read(File.join(@root, path)), path), path))
+            methods << ""
+            actions << [action, name]
+          end
+          dispatch = ["def _render_view(action)", "  case action"]
+          actions.each { |action, name| dispatch << "  when #{action.dump} then #{name}" }
+          dispatch << "  else super" << "  end" << "end"
+          wrap(Inflector.controller_class_name(dir), methods + dispatch)
+        end
+
+        def method_source(signature, body, path)
+          ["def #{signature}", "  # #{path}", "  out = +\"\""] +
+            body.map { |l| "  #{l}" } + ["  out", "end"]
+        end
+
+        def wrap(klass, body)
+          *modules, name = klass.split("::")
+          depth = modules.size
+          lines = [""]
+          modules.each_with_index { |m, i| lines << "#{"  " * i}module #{m}" }
+          lines << "#{"  " * depth}class #{name}"
+          body.each { |l| lines << (l.empty? ? "" : "#{"  " * (depth + 1)}#{l}") }
+          lines << "#{"  " * depth}end"
+          modules.size.times { |i| lines << "#{"  " * (modules.size - 1 - i)}end" }
+          lines
+        end
+
+        def controller_file!(dir, what)
+          return if File.exist?(File.join(@root, "app/controllers/#{dir}_controller.rb"))
+
+          raise Error, "#{what} has no controller: app/controllers/#{dir}_controller.rb does not exist"
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/build.rb

@@ -2,11 +2,16 @@
 
 require "optparse"
 require "json"
+require_relative "build/app_config"
+require_relative "build/app_files"
+require_relative "build/view_compiler"
 
 module Edgeway
   module CLI
     # edgeway build: app/, config/ -> build/main.rb -> build/app.wasm, and the
-    # gem's js/ -> build/edgeway/.
+    # gem's js/ -> build/edgeway/. Spinel compiles with --incremental (cached C
+    # units, fast rebuilds, no inlining across units) unless --release, which
+    # builds as one unit for deploying.
     #
     # Spinel resolves require at compile time and has no autoloading, so
     # build/main.rb requires every file, in an order where a class body finds
@@ -16,22 +21,26 @@ module Edgeway
     #   2. app/*/ other than models/ and controllers/ (services, ...)
     #   3. app/models/
     #   4. app/controllers/
-    #   5. config/routes.rb
+    #   5. build/views.rb, the Ruby compiled from app/views (when there is one)
+    #   6. config/routes.rb
     # Within each, application_*.rb come first (the base classes), then the
     # rest by path (byte order).
     class Build
       def self.run(args)
         env = "development"
+        release = false
         OptionParser.new do |o|
-          o.banner = "Usage: edgeway build [--env ENV]"
+          o.banner = "Usage: edgeway build [--env ENV] [--release]"
           o.on("--env ENV", "environment (default: development)") { |v| env = v }
+          o.on("--release", "build as one unit, without --incremental (for deploying)") { release = true }
         end.parse!(args)
-        new(Dir.pwd, env).run
+        new(Dir.pwd, env, release:).run
       end
 
-      def initialize(root, env)
+      def initialize(root, env, release: false)
         @root = root
         @env = env
+        @release = release
       end
 
       def run
@@ -55,18 +64,29 @@ module Edgeway
         lines << 'require "edgeway/service/cloudflare/jwt"'
         lines << ""
         lines << connection_line(config)
+        config.databases.each { |name, binding_name| lines << connect_line(config, name, binding_name) }
         lines << "Edgeway::Auth.verifier = Edgeway::Cloudflare::JWTVerifier.new"
         lines << ""
-        lines.concat(AppFiles.new(@root).require_lines)
+        views = ViewCompiler.new(@root).compile
+        File.write(File.join(@root, "build/views.rb"), views) if views
+        lines.concat(AppFiles.new(@root).require_lines(views: views && "views"))
         lines << ""
         lines << "Edgeway::Server.run"
         File.write(File.join(@root, "build/main.rb"), lines.join("\n") + "\n")
       end
 
       def connection_line(config)
+        "Edgeway::Model.connection = #{adapter_expression(config, config.binding_name)}"
+      end
+
+      def connect_line(config, name, binding_name)
+        "Edgeway::Model.connect(#{name.inspect}, #{adapter_expression(config, binding_name)})"
+      end
+
+      def adapter_expression(config, binding_name)
         case config.adapter
-        when "d1" then %(Edgeway::Model.connection = Edgeway::Cloudflare::D1Adapter.new(binding: #{config.binding_name.inspect}))
-        else "Edgeway::Model.connection = Edgeway::DB::MemoryAdapter.new"
+        when "d1" then "Edgeway::Cloudflare::D1Adapter.new(binding: #{binding_name.inspect})"
+        else "Edgeway::DB::MemoryAdapter.new"
         end
       end
 
@@ -74,14 +94,19 @@ module Edgeway
         dest = File.join(@root, "build/edgeway")
         FileUtils.mkdir_p(dest)
         Dir.glob(File.join(CLI.gem_dir, "js/*.js")).each { |f| FileUtils.cp(f, dest) }
-        js = "// Generated by `edgeway build` from config/database.yml; do not edit.\n" \
-             "export default #{JSON.generate({ "env" => config.env, "d1Binding" => config.binding_name })};\n"
-        File.write(File.join(dest, "config.js"), js)
+        File.write(File.join(dest, "config.js"), config_js(config))
+      end
+
+      def config_js(config)
+        values = { "env" => config.env, "d1Binding" => config.binding_name, "sessions" => config.sessions }
+        "// Generated by `edgeway build` from config/database.yml; do not edit.\n" \
+          "export default #{JSON.generate(values)};\n"
       end
 
       def compile
         spinel = Toolchain.spinel || raise(Error, "no Spinel compiler found (install it with mise, or set SPINEL=/path/to/spinel)")
         cmd = [spinel, "-I", File.join(CLI.gem_dir, "lib"), "--target=wasm32-wasi", "build/main.rb", "-o", "build/app.wasm"]
+        cmd << "--incremental" unless @release
         puts cmd.join(" ")
         system(*cmd, chdir: @root) || raise(Error, "spinel failed")
       end

data/lib/edgeway/cli/generate.rb

@@ -9,32 +9,37 @@ module Edgeway
       USAGE = <<~TEXT
         Usage: edgeway generate model NAME [field:type ...]
                edgeway generate controller NAME [action ...]
+               edgeway generate scaffold NAME [field:type ...]
 
         Types: #{%w[string text integer float boolean datetime].join(", ")} (default string)
       TEXT
 
-      # field type => [the column's SQL type, its attribute type]
+      # field type => its column's SQL type, its attribute type, and the values
+      # (as Ruby source) the scaffold's test creates and updates with.
       # D1 is SQLite, which has no datetime/boolean type (only NULL, INTEGER,
       # REAL, TEXT and BLOB): a datetime is TEXT (ISO 8601, as Model.now
       # writes it) and a boolean is an INTEGER 0/1. It is SQLite's, not a
       # Cloudflare, limit.
+      Type = Struct.new(:sql, :attr, :created, :updated)
       TYPES = {
-        "string" => ["TEXT", ":string"],
-        "text" => ["TEXT", ":string"],
-        "integer" => ["INTEGER", ":integer"],
-        "float" => ["REAL", ":float"],
-        "boolean" => ["INTEGER NOT NULL DEFAULT 0", ":boolean"],
-        "datetime" => ["TEXT", ":datetime"]
+        "string" => Type.new("TEXT", ":string", '"MyString"', '"Updated"'),
+        "text" => Type.new("TEXT", ":string", '"MyText"', '"Updated"'),
+        "integer" => Type.new("INTEGER", ":integer", "1", "2"),
+        "float" => Type.new("REAL", ":float", "1.5", "2.5"),
+        "boolean" => Type.new("INTEGER NOT NULL DEFAULT 0", ":boolean", "true", "false"),
+        "datetime" => Type.new("TEXT", ":datetime", '"2026-01-01T00:00:00Z"', '"2026-02-01T00:00:00Z"')
       }.freeze
 
+      Field = Struct.new(:name, :sql, :attr, :created, :updated)
+
       RESOURCE_ACTIONS = %w[index show create update destroy].freeze
 
       def self.run(args)
         kind, name, *rest = args
-        raise Error, USAGE unless %w[model controller].include?(kind) && name && !name.start_with?("-")
+        raise Error, USAGE unless %w[model controller scaffold].include?(kind) && name && !name.start_with?("-")
 
         generator = new(Dir.pwd)
-        kind == "model" ? generator.model(name, rest) : generator.controller(name, rest)
+        generator.public_send(kind, name, rest)
       end
 
       def initialize(root)
@@ -46,21 +51,32 @@ module Edgeway
 
       def model(name, fields)
         base = underscore(name)
-        table = Inflector.pluralize(base)
         columns = fields.map { |f| parse_field(f) }
-        write("app/models/#{base}.rb", model_source(camelize(base), columns))
-        write("db/migrations/#{next_migration_number}_create_#{table}.sql", migration_source(table, columns))
-        write("test/models/#{base}_test.rb", model_test_source(camelize(base)))
-        puts "\nApply the migration locally: #{PackageManager.exec} wrangler d1 migrations apply DB_NAME --local"
+        write_all(model_files(base, columns))
+        puts_migration_hint
       end
 
       def controller(name, actions)
         base = underscore(name).delete_suffix("_controller")
         actions.each { |a| raise Error, "invalid action name: #{a}" unless a.match?(/\A[a-z_][a-z0-9_]*\z/) }
-        write("app/controllers/#{base}_controller.rb", controller_source(camelize(base), actions))
-        write("test/controllers/#{base}_test.rb", controller_test_source(camelize(base)))
-        puts "\nAdd to config/routes.rb:"
-        route_hints(base, actions).each { |l| puts "  #{l}" }
+        write_all([
+          ["app/controllers/#{base}_controller.rb", controller_source(camelize(base), actions)],
+          ["test/controllers/#{base}_test.rb", controller_test_source(camelize(base))]
+        ])
+        puts_route_hints(route_hints(base, actions))
+      end
+
+      def scaffold(name, fields)
+        base = underscore(Inflector.singularize(name))
+        plural = Inflector.pluralize(base)
+        columns = fields.map { |f| parse_field(f) }
+        # Every path is checked before the first is written: no half a scaffold.
+        write_all(model_files(base, columns) + [
+          ["app/controllers/#{plural}_controller.rb", scaffold_controller_source(camelize(base), plural, columns)],
+          ["test/controllers/#{plural}_test.rb", scaffold_test_source(camelize(base), plural, columns)]
+        ])
+        add_route(plural)
+        puts_migration_hint
       end
 
       private
@@ -71,21 +87,60 @@ module Edgeway
         name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
       end
 
-      def camelize(name) = name.split("_").map(&:capitalize).join
+      def camelize(name) = Inflector.camelize(name)
 
-      # "title:string" => ["title", "TEXT", ":string"]
+      # "title:string" => Field.new("title", "TEXT", ":string", '"MyString"', '"Updated"')
       def parse_field(spec)
         name, type = spec.split(":", 2)
         type ||= "string"
         raise Error, "invalid field name: #{spec}" unless name.match?(/\A[a-z_][a-z0-9_]*\z/)
         raise Error, "unknown field type #{type} (#{TYPES.keys.join(", ")})" unless TYPES.key?(type)
 
-        [name, *TYPES[type]]
+        Field.new(name, *TYPES[type].to_a)
+      end
+
+      def model_files(base, columns)
+        table = Inflector.pluralize(base)
+        existing = Dir.glob("db/migrations/*_create_#{table}.sql", base: @root).first
+        raise Error, "#{existing} already exists" if existing
+
+        [
+          ["app/models/#{base}.rb", model_source(camelize(base), columns)],
+          ["db/migrations/#{next_migration_number}_create_#{table}.sql", migration_source(table, columns)],
+          ["test/models/#{base}_test.rb", model_test_source(camelize(base))]
+        ]
+      end
+
+      def puts_migration_hint
+        puts "\nApply the migration locally: #{PackageManager.exec} wrangler d1 migrations apply DB_NAME --local"
+      end
+
+      def add_route(plural)
+        path = File.join(@root, "config/routes.rb")
+        text = File.read(path)
+        match = text.match(/^([ \t]*)[\w.]*routes\.draw[ \t]+do[ \t]*\|[ \t]*(\w+)[ \t]*\|[ \t]*(\r?\n)/)
+        return puts_route_hints(["r.resources :#{plural}"], "no `routes.draw do |r|` block found") unless match
+
+        indent, var, eol = match.captures
+        line = "#{var}.resources :#{plural}"
+        return puts "  identical  #{line}" if text.match?(/^[ \t]*#{Regexp.escape(var)}\.resources[ \t]*\(?[ \t]*:#{plural}(?!\w)/)
+
+        close = text.index(/^#{Regexp.escape(indent)}end\b/, match.end(0))
+        return puts_route_hints([line], "no closing `end` found") unless close
+
+        File.write(path, text[0...close] + "#{indent}  #{line}#{eol}" + text[close..])
+        puts "  route  #{line}"
+      end
+
+      def puts_route_hints(hints, reason = nil)
+        puts "\nconfig/routes.rb not changed: #{reason}" if reason
+        puts "\nAdd to config/routes.rb:"
+        hints.each { |l| puts "  #{l}" }
       end
 
       def model_source(klass, columns)
-        lines = columns.map do |name, _sql, attr|
-          attr == ":boolean" ? "  attribute :#{name}, :boolean, default: false" : "  attribute :#{name}, #{attr}"
+        lines = columns.map do |c|
+          c.attr == ":boolean" ? "  attribute :#{c.name}, :boolean, default: false" : "  attribute :#{c.name}, #{c.attr}"
         end
         lines << "  timestamps"
         "class #{klass} < ApplicationModel\n#{lines.join("\n")}\nend\n"
@@ -93,7 +148,7 @@ module Edgeway
 
       def migration_source(table, columns)
         lines = ["  id INTEGER PRIMARY KEY AUTOINCREMENT"]
-        columns.each { |name, sql, _attr| lines << "  #{name} #{sql}" }
+        columns.each { |c| lines << "  #{c.name} #{c.sql}" }
         lines << "  created_at TEXT" << "  updated_at TEXT"
         "CREATE TABLE #{table} (\n#{lines.join(",\n")}\n);\n"
       end
@@ -130,6 +185,96 @@ module Edgeway
         RUBY
       end
 
+      def scaffold_controller_source(klass, plural, columns)
+        var = underscore(klass)
+        lines = [
+          "class #{camelize(plural)}Controller < ApplicationController",
+          "  def index = render json: #{klass}.order(:id).limit(50)",
+          "",
+          "  def show = render json: #{klass}.find(params[:id])",
+          "",
+          "  def create",
+          "    #{var} = #{columns.empty? ? "#{klass}.create!" : "#{klass}.create!(#{var}_params)"}",
+          "    render json: #{var}, status: :created",
+          "  end",
+          "",
+          "  def update",
+          "    #{var} = #{klass}.find(params[:id])"
+        ]
+        lines << "    #{var}.update!(#{var}_params)" unless columns.empty?
+        lines += [
+          "    render json: #{var}",
+          "  end",
+          "",
+          "  def destroy",
+          "    #{klass}.find(params[:id]).destroy",
+          "    head :no_content",
+          "  end"
+        ]
+        unless columns.empty?
+          permitted = columns.map { |c| ":#{c.name}" }.join(", ")
+          lines += ["", "  private", "", "  def #{var}_params = params.require(:#{var}).permit(#{permitted})"]
+        end
+        lines << "end"
+        lines.join("\n") + "\n"
+      end
+
+      def scaffold_test_source(klass, plural, columns)
+        var = underscore(klass)
+        create_args = columns.empty? ? "" : "(#{columns.map { |c| "#{c.name}: #{c.created}" }.join(", ")})"
+        hash = lambda do |value|
+          columns.empty? ? "{}" : "{ #{columns.map { |c| "\"#{c.name}\" => #{c.public_send(value)}" }.join(", ")} }"
+        end
+        checks = ->(value) { columns.map { |c| "    assert_equal #{c.public_send(value)}, json[\"#{c.name}\"]" }.join("\n") }
+        <<~RUBY
+          require "edgeway/test"
+          require "test_helper"
+
+          class #{camelize(plural)}Test < Edgeway::IntegrationTest
+            def test_index
+              #{var} = #{klass}.create!#{create_args}
+              get "/#{plural}"
+              assert_response 200
+              assert_equal 1, json.size
+              assert_equal #{var}.id, json[0]["id"]
+            end
+
+            def test_show
+              #{var} = #{klass}.create!#{create_args}
+              get "/#{plural}/\#{#{var}.id}"
+              assert_response 200
+              assert_equal #{var}.id, json["id"]
+            end
+
+            def test_show_not_found
+              get "/#{plural}/0"
+              assert_response 404
+            end
+
+            def test_create
+              post "/#{plural}", json: { "#{var}" => #{hash.call(:created)} }
+              assert_response 201
+              assert_equal 1, #{klass}.count
+          #{checks.call(:created)}
+            end
+
+            def test_update
+              #{var} = #{klass}.create!#{create_args}
+              patch "/#{plural}/\#{#{var}.id}", json: { "#{var}" => #{hash.call(:updated)} }
+              assert_response 200
+          #{checks.call(:updated)}
+            end
+
+            def test_destroy
+              #{var} = #{klass}.create!#{create_args}
+              delete "/#{plural}/\#{#{var}.id}"
+              assert_response 204
+              assert_equal 0, #{klass}.count
+            end
+          end
+        RUBY
+      end
+
       def route_hints(base, actions)
         return ["r.resources :#{base}"] if actions.empty?
 
@@ -147,10 +292,13 @@ module Edgeway
         format("%04d", last + 1)
       end
 
+      def write_all(files)
+        files.each { |rel, _text| raise Error, "#{rel} already exists" if File.exist?(File.join(@root, rel)) }
+        files.each { |rel, text| write(rel, text) }
+      end
+
       def write(rel, text)
         dest = File.join(@root, rel)
-        raise Error, "#{rel} already exists" if File.exist?(dest)
-
         FileUtils.mkdir_p(File.dirname(dest))
         File.write(dest, text)
         puts "  create  #{rel}"

data/lib/edgeway/cli/new.rb

@@ -36,7 +36,7 @@ module Edgeway
           FileUtils.chmod(0o755, dest) if File.executable?(src)
           puts "  create  #{dest}"
         end
-        puts "\nNext: cd #{@dir} && bin/setup && bundle exec edgeway test && bin/build"
+        puts "\nNext: cd #{@dir} && bin/setup && bin/test && bin/build"
       end
     end
   end

data/lib/edgeway/cli/test.rb

@@ -24,8 +24,11 @@ module Edgeway
         # Where the migrations are read from at test time (the binary may run
         # from another directory); Edgeway::UnitTest#setup applies them.
         lines << "module Edgeway; TEST_APP_ROOT = #{@root.dump}; end"
+        lines << "module Edgeway; TEST_DATABASES = #{Build::DatabaseConfig.new(@root).names.inspect}; end"
         lines << ""
-        lines.concat(AppFiles.new(@root).require_lines)
+        views = Build::ViewCompiler.new(@root).compile
+        File.write(File.join(@root, "tmp/views.rb"), views) if views
+        lines.concat(Build::AppFiles.new(@root).require_lines(views: views && "views"))
         File.write(File.join(@root, "tmp/test_app.rb"), lines.join("\n") + "\n")
       end
     end

data/lib/edgeway/cli.rb

@@ -5,9 +5,7 @@
 require "fileutils"
 require "yaml"
 require_relative "version"
-require_relative "cli/app_config"
 require_relative "cli/toolchain"
-require_relative "cli/app_files"
 require_relative "cli/build"
 require_relative "cli/precheck"
 require_relative "cli/test"
@@ -22,9 +20,12 @@ module Edgeway
       Usage: edgeway COMMAND [options]
 
         new APP                  create a new app in APP/
-        build [--env ENV]        compile the app to build/app.wasm (ENV: development)
+        build [--env ENV] [--release]
+                                 compile the app to build/app.wasm (ENV: development);
+                                   --release builds for deploying (no --incremental)
         test [ARGS]              regenerate tmp/test_app.rb, run test/ with spinel_test-unit
-        generate, g KIND NAME    generate a model (NAME field:type ...) or a controller (NAME action ...)
+        generate, g KIND NAME    generate a model (NAME field:type ...), a controller (NAME action ...)
+                                   or a scaffold (NAME field:type ...)
         routes                   print the routes
         version                  print the version
     TEXT

data/lib/edgeway/controller/base.rb

@@ -8,7 +8,8 @@ module Edgeway
 
       NON_ACTIONS = ["render", "head", "headers", "params", "request", "performed?", "to_response",
                      "action?", "run_before_actions", "rescue_with_handler",
-                     "authenticate!", "current_claims", "authenticated?"]
+                     "authenticate!", "current_claims", "authenticated?",
+                     "action_name", "action_name=", "raw"]
 
       def self.before_action(name, only: [], except: [])
         @own_before_actions ||= []
@@ -48,9 +49,11 @@ module Edgeway
       end
 
       attr_reader :request
+      attr_accessor :action_name
 
       def initialize(request)
         @request = request
+        @action_name = ""
         @status = 200
         @headers = {}
         @response_body = ""
@@ -63,9 +66,16 @@ module Edgeway
       def headers = @headers
 
       def action?(name)
-        self.respond_to?(name.to_sym) && !NON_ACTIONS.include?(name)
+        return false if name.start_with?("_view_") || name.start_with?("_render_")
+        respond_to?(name.to_sym) && !NON_ACTIONS.include?(name)
       end
 
+      def raw(text) = View::SafeHTML.new(text)
+
+      def _render_view(action) = nil
+
+      def _render_layout(content) = content
+
       def params
         @params ||= wrapped_params
       end