cybertrain 0.1.0

data/cybertrain/cli/scaffold.rb

@@ -0,0 +1,227 @@
+# `cybertrain generate scaffold post title:string body:text`: writes the
+# migration, model, controller and views of a resource and adds
+# `resources :posts` to config/routes.rb, the way Rails' scaffold does.
+require "cybertrain/generator/inflector"
+require "cybertrain/cli/templates"
+
+module Cybertrain
+  module CLI
+    class InvalidArgument < StandardError
+    end
+
+    # One "name:type" argument. A references field ("post:references")
+    # becomes the post_id column.
+    class Field
+      TYPES = %w[string text integer float boolean date datetime references]
+
+      # Columns every table already has (the primary key and t.timestamps).
+      RESERVED_COLUMNS = %w[id created_at updated_at]
+
+      # Ruby keywords: a column (or resource) named after one would generate
+      # `def class` / `|end|` and break the generated code.
+      RUBY_KEYWORDS = %w[
+        __ENCODING__ __LINE__ __FILE__ BEGIN END alias and begin break case
+        class def defined do else elsif end ensure false for if in module
+        next nil not or redo rescue retry return self super then true undef
+        unless until when while yield
+      ]
+
+      attr_reader :field_name, :field_type
+
+      def self.parse(arg)
+        colons = 0
+        arg.each_char { |ch| colons += 1 if ch == ":" }
+        raise InvalidArgument, "bad field '#{arg}': use name:type (modifiers such as :index are not supported)" if colons > 1
+
+        parts = arg.split(":")
+        name = parts[0].to_s
+        type = parts.size > 1 ? parts[1].to_s : "string"
+        type = "references" if type == "belongs_to"
+        raise InvalidArgument, "bad field name '#{name}'" unless Templates.identifier?(name)
+        raise InvalidArgument, "'#{name}' is a Ruby keyword and cannot name a field" if RUBY_KEYWORDS.include?(name)
+        raise InvalidArgument, "unknown type '#{type}' for #{name} (use #{TYPES.join(", ")})" unless TYPES.include?(type)
+
+        field = Field.new(name, type)
+        raise InvalidArgument, "'#{field.column_name}' is a column every table already has" if RESERVED_COLUMNS.include?(field.column_name)
+
+        field
+      end
+
+      def initialize(field_name, field_type)
+        @field_name = field_name
+        @field_type = field_type
+      end
+
+      def reference?
+        @field_type == "references"
+      end
+
+      def column_name
+        reference? ? "#{@field_name}_id" : @field_name
+      end
+
+      def label
+        Templates.humanize(@field_name)
+      end
+
+      def migration_line
+        reference? ? "t.references :#{@field_name}" : "t.#{@field_type} \"#{@field_name}\""
+      end
+
+      # The FormBuilder method that edits this column.
+      def form_input
+        case @field_type
+        when "text" then "text_area"
+        when "integer", "float" then "number_field"
+        when "boolean" then "check_box"
+        else "text_field"
+        end
+      end
+    end
+
+    # The names a scaffold derives from its NAME argument ("post", "Post"
+    # or "posts" all give post / posts / Post / Posts).
+    class Resource
+      attr_reader :singular, :plural, :class_name, :plural_class, :fields
+
+      def initialize(name, fields)
+        @singular = Inflector.singularize(Inflector.underscore(name))
+        @plural = Inflector.pluralize(@singular)
+        @class_name = Inflector.camelize(@singular)
+        @plural_class = Inflector.camelize(@plural)
+        @fields = fields
+      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" }
+        ""
+      end
+    end
+
+    module Scaffold
+      DRAW_LINE = "Cybertrain::Routes.draw do"
+
+      # Returns the paths it created (files that already exist are reported
+      # as "identical" or "exist" and left alone). Raises InvalidArgument on a
+      # bad name, a bad or duplicate field, or a routes file without a
+      # `Cybertrain::Routes.draw do` line, before anything is written.
+      def self.generate(root, name, fields)
+        routes_path = File.join(root, "config/routes.rb")
+        raise InvalidArgument, "#{routes_path} not found: run this inside a cybertrain app" unless File.exist?(routes_path)
+        raise InvalidArgument, "#{routes_path} has no `#{DRAW_LINE}` line" if File.read(routes_path).index(DRAW_LINE).nil?
+
+        underscored = Inflector.underscore(name)
+        raise InvalidArgument, "bad resource name '#{name}'" unless Templates.identifier?(underscored)
+        raise InvalidArgument, "'#{name}' is a Ruby keyword and cannot name a resource" if Field::RUBY_KEYWORDS.include?(Inflector.singularize(underscored))
+
+        parsed = Array.new(0) { Field.new("", "") }
+        columns = Array.new(0) { "" }
+        fields.each do |arg|
+          field = Field.parse(arg)
+          raise InvalidArgument, "duplicate column '#{field.column_name}'" if columns.include?(field.column_name)
+
+          columns << field.column_name
+          parsed << field
+        end
+        res = Resource.new(name, parsed)
+
+        created = Array.new(0) { "" }
+        migration = migration_path(root, res)
+        record(created, root, migration, Templates.migration(res))
+        record(created, root, "app/models/#{res.singular}.rb", Templates.model(res))
+        record(created, root, "app/controllers/#{res.plural}_controller.rb", Templates.controller(res))
+        views = "app/views/#{res.plural}"
+        record(created, root, "#{views}/index.html.erb", Templates.index_view(res))
+        record(created, root, "#{views}/show.html.erb", Templates.show_view(res))
+        record(created, root, "#{views}/new.html.erb", Templates.new_view(res))
+        record(created, root, "#{views}/edit.html.erb", Templates.edit_view(res))
+        record(created, root, "#{views}/_form.html.erb", Templates.form_partial(res))
+        add_route(routes_path, res.plural)
+        created
+      end
+
+      def self.record(created, root, path, content)
+        created << path if Templates.write(root, path, content) == "create"
+        nil
+      end
+
+      # db/migrate/<timestamp>_create_posts.rb, or the existing
+      # *_create_posts.rb when the scaffold already ran.
+      def self.migration_path(root, res)
+        suffix = "_create_#{res.plural}.rb"
+        existing = Dir.glob(File.join(root, "db/migrate/*#{suffix}")).sort
+        return "db/migrate/#{File.basename(existing[0])}" unless existing.empty?
+
+        "db/migrate/#{next_version(root, timestamp)}#{suffix}"
+      end
+
+      # The version a new migration gets: stamp, unless db/migrate already
+      # holds a version >= stamp (two scaffolds in the same second, or a
+      # fixed CYBERTRAIN_TIMESTAMP), in which case the largest one + 1, the
+      # way Rails does it. Versions must stay unique (schema_migrations keys
+      # on them) and increasing (they order the migrations).
+      def self.next_version(root, stamp)
+        largest = 0
+        Dir.glob(File.join(root, "db/migrate/*.rb")).each do |path|
+          digits = leading_digits(File.basename(path))
+          next if digits == ""
+
+          v = digits.to_i
+          largest = v if v > largest
+        end
+        return stamp if stamp.to_i > largest
+
+        (largest + 1).to_s
+      end
+
+      def self.leading_digits(name)
+        out = +""
+        name.each_char do |ch|
+          break unless ch >= "0" && ch <= "9"
+
+          out << ch
+        end
+        out
+      end
+
+      def self.timestamp
+        fixed = ENV["CYBERTRAIN_TIMESTAMP"]
+        return fixed.to_s unless fixed.nil? || fixed == ""
+
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      # Inserts `  resources :posts` right after `Cybertrain::Routes.draw do`
+      # unless a `resources :posts` line is already there.
+      def self.add_route(routes_path, plural)
+        route = "resources :#{plural}"
+        source = File.read(routes_path)
+        lines = source.split("\n")
+        present = false
+        lines.each do |line|
+          l = line.strip
+          present = true if l == route || l.start_with?("#{route} ") || l.start_with?("#{route},")
+        end
+        if present
+          puts "identical route #{route}"
+          return false
+        end
+
+        at = source.index(DRAW_LINE)
+        raise InvalidArgument, "#{routes_path} has no `#{DRAW_LINE}` line" if at.nil?
+
+        eol = source.index("\n", at)
+        eol = source.size if eol.nil?
+        updated = +""
+        updated << source[0, eol]
+        updated << "\n  #{route}"
+        updated << source[eol, source.size - eol]
+        updated << "\n" unless updated.end_with?("\n")
+        File.write(routes_path, updated)
+        puts "route #{route}"
+        true
+      end
+    end
+  end
+end

data/cybertrain/cli/templates.rb

@@ -0,0 +1,421 @@
+# Cybertrain::CLI::Templates -- the file contents `cybertrain new` and
+# `cybertrain generate scaffold` write, embedded in the binary, plus the one
+# helper that puts them on disk.
+#
+# The scaffold templates take a Cybertrain::CLI::Resource (cli/scaffold.rb).
+# Generated views stay inside the template language of docs/design.md
+# section 7: literals, @ivars, locals, helper calls, `if` and `each do`.
+module Cybertrain
+  module CLI
+    module Templates
+      # Writes root/path unless it already exists, creating directories on
+      # the way. Returns "create", "identical" (same content already there)
+      # or "exist" (different content: left alone, never overwritten), and
+      # prints that status with the path.
+      def self.write(root, path, content)
+        full = File.join(root, path)
+        status = "create"
+        if File.exist?(full)
+          status = File.read(full) == content ? "identical" : "exist"
+        else
+          mkdir_p(File.dirname(full))
+          File.write(full, content)
+        end
+        puts "#{status} #{path}"
+        status
+      end
+
+      def self.mkdir_p(dir)
+        return if dir == "" || File.directory?(dir)
+
+        path = dir.start_with?("/") ? +"/" : +""
+        dir.split("/").each do |part|
+          next if part == ""
+
+          path << part
+          Dir.mkdir(path) unless File.directory?(path)
+          path << "/"
+        end
+        nil
+      end
+
+      # A lowercase Ruby-ish name: "post", "blog_post", "released_on".
+      def self.identifier?(word)
+        return false if word == ""
+
+        ok = true
+        first = true
+        word.each_char do |ch|
+          lower = ch >= "a" && ch <= "z"
+          digit = ch >= "0" && ch <= "9"
+          ok = false unless lower || (!first && (digit || ch == "_"))
+          first = false
+        end
+        ok
+      end
+
+      # "blog_posts" -> "Blog posts"
+      def self.humanize(word)
+        word.tr("_", " ").capitalize
+      end
+
+      # ---- cybertrain new ----------------------------------------------
+
+      # framework_dep is the TOML value: `{ path = "..." }` or `"~> 0.1"`.
+      def self.spin_toml(package, framework_dep)
+        <<~TOML
+          [package]
+          name = "#{package}"
+          version = "0.1.0"
+
+          [dependencies]
+          cybertrain = #{framework_dep}
+        TOML
+      end
+
+      def self.gitignore
+        <<~TEXT
+          /build/
+          /storage/*.sqlite3*
+          /tmp/*
+          !/tmp/.keep
+          /log/
+        TEXT
+      end
+
+      def self.readme(title)
+        <<~MARKDOWN
+          # #{title}
+
+          A cybertrain application, compiled to one binary by Spinel.
+
+          ```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
+          ```
+
+          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.
+        MARKDOWN
+      end
+
+      def self.config_app
+        <<~RUBY
+          # Application settings; see Cybertrain::Config for every option.
+          # Environment variables (PORT, CYBERTRAIN_ENV, CYBERTRAIN_DATABASE,
+          # CYBERTRAIN_SECRET_KEY_BASE) are read before this block runs.
+          Cybertrain.configure do |c|
+            # c.port = 3000
+            # c.workers = 1
+
+            # Production marks the session cookie Secure (HTTPS only). Turn it
+            # off only if production is really served over plain http://.
+            # c.session_secure = false
+          end
+        RUBY
+      end
+
+      def self.routes
+        "Cybertrain::Routes.draw do\nend\n"
+      end
+
+      def self.schema
+        "Cybertrain::Schema.define(version: \"0\") do |s|\nend\n"
+      end
+
+      def self.application_controller
+        <<~RUBY
+          class ApplicationController < Cybertrain::Controller
+            rescue_from Cybertrain::RecordNotFound, with: :record_not_found
+
+            private
+
+            def record_not_found
+              render plain: "Not Found", status: :not_found
+            end
+          end
+        RUBY
+      end
+
+      def self.layout(title)
+        <<~ERB
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>#{title}</title>
+              <meta name="viewport" content="width=device-width,initial-scale=1">
+              <%= csrf_meta_tags %>
+              <link rel="stylesheet" href="/style.css">
+            </head>
+            <body>
+              <main>
+                <% if flash[:notice] %>
+                  <p class="notice"><%= flash[:notice] %></p>
+                <% end %>
+                <% if flash[:alert] %>
+                  <p class="alert"><%= flash[:alert] %></p>
+                <% end %>
+                <%= yield %>
+              </main>
+            </body>
+          </html>
+        ERB
+      end
+
+      def self.error_page(status, message)
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>#{message} (#{status})</title>
+              <meta name="viewport" content="width=device-width,initial-scale=1">
+              <link rel="stylesheet" href="/style.css">
+            </head>
+            <body>
+              <main>
+                <h1>#{message}</h1>
+                <p>#{status == "404" ? "The page you were looking for doesn't exist." : "Something went wrong on our side."}</p>
+              </main>
+            </body>
+          </html>
+        HTML
+      end
+
+      def self.style_css
+        <<~CSS
+          body { font-family: system-ui, sans-serif; line-height: 1.5; margin: 0; color: #222; }
+          main { max-width: 48rem; margin: 0 auto; padding: 1rem; }
+          a { color: #0b5cad; }
+          table { border-collapse: collapse; width: 100%; }
+          th, td { text-align: left; padding: 0.25rem 0.5rem; border-bottom: 1px solid #ddd; }
+          .notice { color: #166534; background: #dcfce7; padding: 0.5rem; }
+          .alert { color: #991b1b; background: #fee2e2; padding: 0.5rem; }
+          .field { margin-bottom: 0.75rem; }
+          .field label { display: block; font-weight: 600; }
+          .field input[type=text], .field input[type=number], .field textarea { width: 100%; padding: 0.25rem; }
+          .field_with_errors input, .field_with_errors textarea { border: 1px solid #b91c1c; }
+          #error_explanation { color: #991b1b; border: 1px solid #fca5a5; padding: 0.5rem 1rem; margin-bottom: 1rem; }
+          form.button_to { display: inline; }
+        CSS
+      end
+
+      def self.bin_server
+        <<~RUBY
+          require "cybertrain"
+          require_relative "../config/app"
+          require_relative "../gen/app"
+
+          app = Cybertrain::Application.new(
+            router: Gen::Routes.build(Cybertrain::Router.new),
+            url_resolver: Gen::Routes.url_resolver
+          )
+          app.run
+        RUBY
+      end
+
+      def self.bin_gen
+        <<~RUBY
+          require "cybertrain/generator"
+          require_relative "../config/routes"
+          require_relative "../db/schema"
+
+          exit(Cybertrain::Gen::Runner.run(".", ARGV))
+        RUBY
+      end
+
+      def self.bin_db
+        <<~RUBY
+          require "cybertrain"
+          require_relative "../config/app"
+          require_relative "../gen/migrations"
+
+          exit(Cybertrain::DB::CLI.run(ARGV))
+        RUBY
+      end
+
+      # ---- cybertrain generate scaffold --------------------------------
+
+      def self.migration(res)
+        buf = +""
+        buf << "class Create#{res.plural_class} < Cybertrain::Migration::Base\n"
+        buf << "  def change\n"
+        buf << "    create_table \"#{res.plural}\" do |t|\n"
+        res.fields.each { |f| buf << "      #{f.migration_line}\n" }
+        buf << "      t.timestamps\n"
+        buf << "    end\n"
+        buf << "  end\n"
+        buf << "end\n"
+        buf
+      end
+
+      def self.model(res)
+        buf = +""
+        buf << "# Columns, associations and the Cybertrain::Model superclass come from\n"
+        buf << "# gen/models/#{res.singular}.rb, generated from db/schema.rb by `spin run gen`.\n"
+        buf << "class #{res.class_name}\n"
+        first = res.first_string_field
+        buf << "  validates :#{first}, presence: true\n" unless first == ""
+        buf << "end\n"
+        buf
+      end
+
+      def self.controller(res)
+        s = res.singular
+        p = res.plural
+        human = humanize(s)
+        permitted = res.fields.map { |f| ":#{f.column_name}" }.join(", ")
+        <<~RUBY
+          class #{res.plural_class}Controller < ApplicationController
+            before_action :set_#{s}, only: [:show, :edit, :update, :destroy]
+
+            # GET /#{p}
+            def index
+              @#{p} = #{res.class_name}.all.to_a
+            end
+
+            # GET /#{p}/1
+            def show
+            end
+
+            # GET /#{p}/new
+            # (named new_action: a `new` method would shadow #{res.plural_class}Controller.new)
+            def new_action
+              @#{s} = #{res.class_name}.new
+            end
+
+            # GET /#{p}/1/edit
+            def edit
+            end
+
+            # POST /#{p}
+            def create
+              @#{s} = #{res.class_name}.new(#{s}_params)
+              if @#{s}.save
+                flash[:notice] = "#{human} was successfully created."
+                redirect_to #{s}_path(@#{s}), status: :see_other
+              else
+                render :new, status: :unprocessable_entity
+              end
+            end
+
+            # PATCH/PUT /#{p}/1
+            def update
+              if @#{s}.update(#{s}_params)
+                flash[:notice] = "#{human} was successfully updated."
+                redirect_to #{s}_path(@#{s}), status: :see_other
+              else
+                render :edit, status: :unprocessable_entity
+              end
+            end
+
+            # DELETE /#{p}/1
+            def destroy
+              @#{s}.destroy
+              flash[:notice] = "#{human} was successfully destroyed."
+              redirect_to #{p}_path, status: :see_other
+            end
+
+            private
+
+            def set_#{s}
+              @#{s} = #{res.class_name}.find(params[:id])
+            end
+
+            def #{s}_params
+              params.require(:#{s}).permit(#{permitted})
+            end
+          end
+        RUBY
+      end
+
+      def self.index_view(res)
+        s = res.singular
+        words = s.tr("_", " ")
+        buf = +""
+        buf << "<h1>#{humanize(res.plural)}</h1>\n\n"
+        buf << "<table>\n  <thead>\n    <tr>\n"
+        res.fields.each { |f| buf << "      <th>#{f.label}</th>\n" }
+        buf << "      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n"
+        buf << "    <% @#{res.plural}.each do |#{s}| %>\n"
+        buf << "      <tr>\n"
+        res.fields.each { |f| buf << "        <td><%= #{s}.#{f.column_name} %></td>\n" }
+        buf << "        <td><%= link_to \"Show\", #{s}_path(#{s}) %></td>\n"
+        buf << "      </tr>\n"
+        buf << "    <% end %>\n"
+        buf << "  </tbody>\n</table>\n\n"
+        buf << "<p><%= link_to \"New #{words}\", new_#{s}_path %></p>\n"
+        buf
+      end
+
+      def self.show_view(res)
+        s = res.singular
+        words = s.tr("_", " ")
+        buf = +""
+        buf << "<h1>#{humanize(s)}</h1>\n\n"
+        res.fields.each do |f|
+          buf << "<p>\n  <strong>#{f.label}:</strong>\n  <%= @#{s}.#{f.column_name} %>\n</p>\n\n"
+        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 << "</p>\n\n"
+        buf << "<%= button_to \"Destroy this #{words}\", #{s}_path(@#{s}), method: :delete %>\n"
+        buf
+      end
+
+      def self.new_view(res)
+        s = res.singular
+        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
+      end
+
+      def self.edit_view(res)
+        s = res.singular
+        buf = +""
+        buf << "<h1>Editing #{s.tr("_", " ")}</h1>\n\n"
+        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 << "</p>\n"
+        buf
+      end
+
+      def self.form_partial(res)
+        s = res.singular
+        buf = +""
+        buf << "<%# locals: (#{s}:) %>\n"
+        buf << "<%= form_with(model: #{s}) do |f| %>\n"
+        buf << "  <% if #{s}.errors.any? %>\n"
+        buf << "    <div id=\"error_explanation\">\n"
+        buf << "      <h2><%= pluralize(#{s}.errors.count, \"error\") %> prohibited this #{s.tr("_", " ")} from being saved:</h2>\n"
+        buf << "      <ul>\n"
+        buf << "        <% #{s}.errors.full_messages.each do |message| %>\n"
+        buf << "          <li><%= message %></li>\n"
+        buf << "        <% end %>\n"
+        buf << "      </ul>\n"
+        buf << "    </div>\n"
+        buf << "  <% end %>\n\n"
+        res.fields.each do |f|
+          buf << "  <div class=\"field\">\n"
+          buf << "    <%= f.label :#{f.column_name} %>\n"
+          buf << "    <%= f.#{f.form_input} :#{f.column_name} %>\n"
+          buf << "  </div>\n\n"
+        end
+        buf << "  <div class=\"actions\">\n"
+        buf << "    <%= f.submit %>\n"
+        buf << "  </div>\n"
+        buf << "<% end %>\n"
+        buf
+      end
+    end
+  end
+end