@tutorialkit-rb/cli 0.1.5 → 0.1.7

package/template/src/templates/default/scripts/smoke-test.js

@@ -0,0 +1,349 @@
+/**
+ * Smoke test for the Rails WASM boot sequence.
+ *
+ * Exercises the same code paths as WebContainer (WASM load → VM init →
+ * Rails bootstrap) directly on the host via Node.js.
+ *
+ * Usage:
+ *   npm run smoke                    # run all offline tests
+ *   npm run smoke -- --rails-new     # only rails new (chmod compat)
+ *   npm run smoke -- --generate      # only generator infrastructure
+ *   npm run smoke -- --boot-app      # only app boot (native ext compat)
+ *   npm run smoke -- --server        # only full server init (Rails.application.initialize!)
+ *   npm run smoke -- --http          # only Express/Rack bridge
+ *   npm run smoke -- --fetch         # only outbound HTTP fetch (needs network)
+ *   npm run smoke -- --skip-rails    # VM init only (no Rails bootstrap)
+ *   npm run smoke -- --rails-new --boot-app  # combine specific tests
+ *
+ * Dependencies are resolved automatically:
+ *   --generate and --boot-app require rails new, which runs first.
+ *
+ * Limitations (node:wasi vs WebContainer):
+ *   - Dir.chdir doesn't work (no WASI chdir syscall) — use full paths
+ *   - Console REPL is interactive, can't be smoke-tested — but --boot-app
+ *     exercises the same app boot path (Bundler.require) that console uses
+ *   - Server is tested via --http (createRackServer), not bin/rails server
+ *
+ * WASM binary resolution (first match wins):
+ *   1. RAILS_WASM_PATH env var
+ *   2. ../../public/ruby.wasm  (dynamic packing output)
+ *   3. node_modules/@ruby/wasm-wasi/dist/ruby.wasm  (WebContainer placement)
+ *   4. node_modules/@rails-tutorial/wasm/dist/rails.wasm  (npm package)
+ *
+ * Requires --no-turbo-fast-api-calls to work around a V8 GC bug in node:wasi's
+ * PathFilestatGet fast API callback. The npm script includes this flag.
+ */
+
+import { existsSync } from 'node:fs';
+import { performance } from 'node:perf_hooks';
+
+// ---------------------------------------------------------------------------
+// CLI flags
+// ---------------------------------------------------------------------------
+const args = new Set(process.argv.slice(2));
+const skipRails = args.has('--skip-rails');
+
+// Known test flags (everything except --skip-rails)
+const testFlags = ['--rails-new', '--generate', '--boot-app', '--server', '--http', '--fetch'];
+const hasExplicitFlags = testFlags.some(f => args.has(f));
+
+// No flags = run all tests. With flags = run only those (+ auto-resolved dependencies).
+const runRailsNew  = !hasExplicitFlags || args.has('--rails-new') || args.has('--generate') || args.has('--boot-app') || args.has('--server');
+const runGenerate  = !hasExplicitFlags || args.has('--generate');
+const runBootApp   = !hasExplicitFlags || args.has('--boot-app') || args.has('--server');
+const runServer    = !hasExplicitFlags || args.has('--server');
+const runHttp      = !hasExplicitFlags || args.has('--http');
+const runFetch     = !hasExplicitFlags || args.has('--fetch');
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function timer() {
+  const start = performance.now();
+  return () => {
+    const ms = performance.now() - start;
+    return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+  };
+}
+
+function log(msg) {
+  console.log(`[smoke] ${msg}`);
+}
+
+// ---------------------------------------------------------------------------
+// Resolve WASM binary
+// ---------------------------------------------------------------------------
+const nodeModules = new URL('../node_modules', import.meta.url).pathname;
+
+if (!existsSync(nodeModules)) {
+  log('node_modules/ not found — running npm install --ignore-scripts...');
+  const { execSync } = await import('node:child_process');
+  const templateDir = new URL('..', import.meta.url).pathname;
+  execSync('npm install --ignore-scripts', { cwd: templateDir, stdio: 'inherit' });
+}
+
+const wasmCandidates = [
+  { path: process.env.RAILS_WASM_PATH, label: 'RAILS_WASM_PATH env var' },
+  { path: new URL('../../../../public/ruby.wasm', import.meta.url).pathname, label: 'public/ruby.wasm (dynamic packing)' },
+  { path: new URL('../node_modules/@ruby/wasm-wasi/dist/ruby.wasm', import.meta.url).pathname, label: '@ruby/wasm-wasi' },
+  { path: new URL('../node_modules/@rails-tutorial/wasm/dist/rails.wasm', import.meta.url).pathname, label: '@rails-tutorial/wasm' },
+].filter(c => c.path);
+
+const resolved = wasmCandidates.find(c => existsSync(c.path));
+
+if (!resolved) {
+  console.error(
+    '\n  Could not find a Ruby WASM binary. Searched:\n' +
+    wasmCandidates.map(c => `    - ${c.label}: ${c.path}`).join('\n') + '\n\n' +
+    '  Set RAILS_WASM_PATH to the path of your monolithic ruby.wasm binary,\n' +
+    '  or ensure @rails-tutorial/wasm is installed.\n',
+  );
+  process.exit(1);
+}
+
+log(`Using WASM binary from ${resolved.label}: ${resolved.path}`);
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+console.log('\n=== Rails WASM Smoke Test ===\n');
+const totalTimer = timer();
+
+// --- Step 0: Ensure workspace directory exists (WASI preopen requires it) ---
+{
+  const { mkdirSync } = await import('node:fs');
+  const workspaceDir = new URL('../workspace', import.meta.url).pathname;
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+// --- Step 1: Load WASM + init VM (+ optional Rails bootstrap) ---
+let vm;
+{
+  log(skipRails ? 'Initializing VM (skip-rails)...' : 'Initializing VM + Rails...');
+  const initVM = (await import('../lib/rails.js')).default;
+  vm = await initVM({ skipRails, wasmPath: resolved.path });
+}
+
+if (skipRails) {
+  log('VM ready — Rails bootstrap skipped');
+  console.log(`\n=== PASSED — skip-rails (total ${totalTimer()}) ===\n`);
+  process.exit(0);
+}
+
+// --- Step 2: Verify Rails is loadable ---
+{
+  vm.eval('require "rails"');
+  const version = vm.eval('Rails.version').toString();
+  log(`Rails.version = ${version}`);
+}
+
+// --- Step 3: Fetch bridge test ---
+if (runFetch) {
+  log('Testing HTTP fetch bridge...');
+  const fetchResult = await vm.evalAsync(`
+    require "net/http"
+    require "uri"
+    require "json"
+    response = Net::HTTP.get(URI("https://httpbin.org/get?source=smoke_test"))
+    parsed = JSON.parse(response)
+    parsed["args"]["source"]
+  `);
+  if (fetchResult.toString() !== "smoke_test") {
+    throw new Error("HTTP fetch bridge test failed");
+  }
+  log('HTTP fetch bridge: PASS');
+}
+
+// --- Step 4: rails new + generate + boot-app + server ---
+// These share a generated app, so they run as a group with cleanup.
+if (runRailsNew || runGenerate || runBootApp || runServer) {
+  const { existsSync: existsSyncFs, rmSync, mkdirSync } = await import('node:fs');
+  const { join } = await import('node:path');
+
+  const workspaceHost = new URL('../workspace', import.meta.url).pathname;
+  const appName = '_smoke_test_app';
+  const appDirHost = join(workspaceHost, appName);
+
+  // Clean up any leftover from a previous failed run
+  if (existsSyncFs(appDirHost)) rmSync(appDirHost, { recursive: true, force: true });
+  mkdirSync(workspaceHost, { recursive: true });
+
+  try {
+    // --- rails new (always runs as prerequisite) ---
+    const railsNewTimer = timer();
+    log('Testing rails new (app generator + chmod compat)...');
+    await vm.evalAsync(`
+      ENV["HOME"] = "/workspace" unless ENV["HOME"]
+      require "rails/command"
+      require "rails/commands/application/application_command"
+      ARGV.replace(["new", "/workspace/${appName}", "--skip-bundle", "--skip-git",
+                     "--skip-bootsnap", "--skip-brakeman", "--skip-dev-gems",
+                     "--skip-kamal", "--skip-thruster", "--skip-docker",
+                     "--skip-system-test", "--skip-rubocop",
+                     "--skip-decrypted-diffs"])
+      Rails::Command.invoke(:application, ARGV)
+    `);
+
+    // Verify key files were created
+    const checks = ['Gemfile', 'Rakefile', 'config.ru', 'bin/rails', 'app/controllers/application_controller.rb'];
+    const missing = checks.filter(f => !existsSyncFs(join(appDirHost, f)));
+    if (missing.length > 0) {
+      throw new Error(`rails new: missing files: ${missing.join(', ')}`);
+    }
+    log(`rails new: PASS (${railsNewTimer()}) — ${checks.length} key files verified`);
+
+    // --- generator infrastructure ---
+    if (runGenerate) {
+      const genTimer = timer();
+      log('Testing generator infrastructure...');
+      await vm.evalAsync(`
+        require "rails/generators"
+        require "rails/generators/rails/model/model_generator"
+        require "rails/generators/rails/scaffold_controller/scaffold_controller_generator"
+
+        # Verify generator classes are loaded and functional
+        gen = Rails::Generators::ModelGenerator.new(["Post", "title:string"])
+        raise "destination_root mismatch" unless gen.destination_root == "/workspace/${appName}"
+        raise "behavior should be :invoke" unless gen.behavior == :invoke
+
+        # Verify template engine can write files through WASI
+        gen.create_file("app/models/post.rb", <<~RUBY)
+          class Post < ApplicationRecord
+          end
+        RUBY
+
+        # Verify scaffold controller generator loads
+        sgen = Rails::Generators::ScaffoldControllerGenerator.new(["Post"])
+        raise "scaffold dest mismatch" unless sgen.destination_root == "/workspace/${appName}"
+      `);
+
+      const genChecks = ['app/models/post.rb'];
+      const genMissing = genChecks.filter(f => !existsSyncFs(join(appDirHost, f)));
+      if (genMissing.length > 0) {
+        throw new Error(`generator infra: missing: ${genMissing.join(', ')}`);
+      }
+      log(`generator infrastructure: PASS (${genTimer()}) — classes loaded, WASI file creation works`);
+    }
+
+    // --- boot generated app ---
+    if (runBootApp) {
+      const bootTimer = timer();
+      log('Testing app boot (config/application.rb → Bundler.require)...');
+      await vm.evalAsync(`
+        require "/workspace/${appName}/config/application.rb"
+      `);
+      log(`app boot: PASS (${bootTimer()}) — config/application.rb loaded, Bundler.require succeeded`);
+    }
+
+    // --- full server boot + first request ---
+    // Exercises the same path as `rails server` + first HTTP request.
+    // Rails eager-loads code on the first request in development mode,
+    // loading 1600+ files. This catches WASM memory issues (e.g. "index out
+    // of bounds") that only manifest under this heavy load.
+    if (runServer) {
+      const serverTimer = timer();
+      log('Testing full server boot + first request...');
+
+      // Boot Rails app via config.ru (same as real server).
+      // config.ru loads config/environment.rb which calls initialize!
+      await vm.evalAsync(`
+        require "rack/builder"
+        require "rack/wasi/incoming_handler"
+        app = Rack::Builder.load_file("/workspace/${appName}/config.ru")
+        $incoming_handler = Rack::WASI::IncomingHandler.new(app)
+      `);
+
+      // Serve actual HTTP request through the full Rails stack
+      const { createRackServer } = await import('../lib/server.js');
+      const rackApp = await createRackServer(vm, { skipRackup: true });
+
+      await new Promise((resolve, reject) => {
+        const server = rackApp.listen(0, async () => {
+          const port = server.address().port;
+          log(`Rails app listening on port ${port}`);
+          try {
+            const res = await fetch(`http://localhost:${port}/up`);
+            log(`GET /up → ${res.status}`);
+            if (res.status >= 500) {
+              throw new Error(`server test: GET /up returned ${res.status}`);
+            }
+          } catch (err) {
+            server.close();
+            reject(err);
+            return;
+          }
+          server.close(() => resolve());
+        });
+      });
+
+      log(`server: PASS (${serverTimer()}) — Rails.application.initialize! + first request succeeded`);
+    }
+  } finally {
+    if (existsSyncFs(appDirHost)) rmSync(appDirHost, { recursive: true, force: true });
+  }
+}
+
+// --- Step 5: HTTP bridge test ---
+if (runHttp) {
+  log('Starting HTTP bridge test...');
+
+  // Set up a minimal Rack app inline (no config.ru needed).
+  // This tests the Express→Rack bridge without requiring a full Rails app.
+  await vm.evalAsync(`
+    require "rack/builder"
+    require "rack/wasi/incoming_handler"
+
+    app = Rack::Builder.new do
+      run ->(env) { [200, {"content-type" => "text/plain"}, ["ok"]] }
+    end
+
+    $incoming_handler = Rack::WASI::IncomingHandler.new(app)
+  `);
+
+  const { createRackServer } = await import('../lib/server.js');
+  const app = await createRackServer(vm, { skipRackup: true });
+
+  await new Promise((resolve, reject) => {
+    const server = app.listen(0, async () => {
+      const port = server.address().port;
+      log(`Express listening on port ${port}`);
+
+      try {
+        const res = await fetch(`http://localhost:${port}/smoke-test`);
+        log(`GET /smoke-test → ${res.status}`);
+        if (res.status !== 200) {
+          throw new Error(`HTTP test failed with status ${res.status}`);
+        }
+        const body = await res.text();
+        if (body !== 'ok') {
+          throw new Error(`HTTP test: expected "ok", got "${body}"`);
+        }
+        log('HTTP bridge: PASS');
+      } catch (err) {
+        server.close();
+        reject(err);
+        return;
+      }
+
+      server.close(() => resolve());
+    });
+  });
+}
+
+// --- Cleanup: remove PGLite data created during smoke test ---
+{
+  const { existsSync: existsSyncFs, rmSync, readdirSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  const pgDataDir = new URL('../pgdata', import.meta.url).pathname;
+
+  if (existsSyncFs(pgDataDir)) {
+    for (const entry of readdirSync(pgDataDir)) {
+      if (entry === '.keep') continue;
+      rmSync(join(pgDataDir, entry), { recursive: true, force: true });
+    }
+    log('Cleaned up pgdata/');
+  }
+}
+
+console.log(`\n=== PASSED (total ${totalTimer()}) ===\n`);
+process.exit(0);

package/template/src/templates/default/scripts/wasi-loader.mjs

@@ -0,0 +1,10 @@
+// Node.js module resolution hook: remaps bare 'wasi' → 'node:wasi'
+// WebContainer provides 'wasi' as a bare specifier; Node.js needs 'node:wasi'.
+// Usage: node --loader ./scripts/wasi-loader.mjs
+
+export function resolve(specifier, context, next) {
+  if (specifier === 'wasi') {
+    return { url: 'node:wasi', shortCircuit: true };
+  }
+  return next(specifier, context);
+}

package/template/src/templates/default/workspace/_debug_app/.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

package/template/src/templates/default/workspace/_debug_app/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+
+jobs:
+  scan_js:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Scan for security vulnerabilities in JavaScript dependencies
+        run: bin/importmap audit
+
+  test:
+    runs-on: ubuntu-latest
+
+    # services:
+    #  redis:
+    #    image: redis
+    #    ports:
+    #      - 6379:6379
+    #    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    steps:
+      - name: Install packages
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends -y build-essential git libyaml-dev pkg-config
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Run tests
+        env:
+          RAILS_ENV: test
+          # REDIS_URL: redis://localhost:6379/0
+        run: bin/rails db:test:prepare test

package/template/src/templates/default/workspace/_debug_app/.ruby-version

@@ -0,0 +1 @@
+ruby-3.3.8

package/template/src/templates/default/workspace/_debug_app/Gemfile

@@ -0,0 +1,37 @@
+source "https://rubygems.org"
+
+# Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
+gem "rails", "~> 8.0.2"
+# The modern asset pipeline for Rails [https://github.com/rails/propshaft]
+gem "propshaft"
+# Use sqlite3 as the database for Active Record
+gem "sqlite3", ">= 2.1"
+# Use the Puma web server [https://github.com/puma/puma]
+gem "puma", ">= 5.0"
+# Use JavaScript with ESM import maps [https://github.com/rails/importmap-rails]
+gem "importmap-rails"
+# Hotwire's SPA-like page accelerator [https://turbo.hotwired.dev]
+gem "turbo-rails"
+# Hotwire's modest JavaScript framework [https://stimulus.hotwired.dev]
+gem "stimulus-rails"
+# Build JSON APIs with ease [https://github.com/rails/jbuilder]
+gem "jbuilder"
+
+# Use Active Model has_secure_password [https://guides.rubyonrails.org/active_model_basics.html#securepassword]
+# gem "bcrypt", "~> 3.1.7"
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem "tzinfo-data", platforms: %i[ windows jruby ]
+
+# Use the database-backed adapters for Rails.cache, Active Job, and Action Cable
+gem "solid_cache"
+gem "solid_queue"
+gem "solid_cable"
+
+# Use Active Storage variants [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
+# gem "image_processing", "~> 1.2"
+
+group :development, :test do
+  # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
+  gem "debug", platforms: %i[ mri windows ], require: "debug/prelude"
+end

package/template/src/templates/{rails-app/workspace/store → default/workspace/_debug_app}/app/views/layouts/application.html.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title><%= content_for(:title) || "Store" %></title>
+    <title><%= content_for(:title) || "Debug App" %></title>
     <meta name="viewport" content="width=device-width,initial-scale=1">
     <meta name="apple-mobile-web-app-capable" content="yes">
     <meta name="mobile-web-app-capable" content="yes">
@@ -19,7 +19,6 @@
 
     <%# Includes all stylesheet files in app/assets/stylesheets %>
     <%= stylesheet_link_tag :app, "data-turbo-track": "reload" %>
-    <%= javascript_importmap_tags %>
   </head>
 
   <body>

package/template/src/templates/{rails-app/workspace/store → default/workspace/_debug_app}/app/views/pwa/manifest.json.erb

@@ -1,5 +1,5 @@
 {
-  "name": "Store",
+  "name": "DebugApp",
   "icons": [
     {
       "src": "/icon.png",
@@ -16,7 +16,7 @@
   "start_url": "/",
   "display": "standalone",
   "scope": "/",
-  "description": "Store.",
+  "description": "DebugApp.",
   "theme_color": "red",
   "background_color": "red"
 }

package/template/src/templates/default/workspace/_debug_app/bin/dev

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "./bin/rails", "server", *ARGV

package/template/src/templates/default/workspace/_debug_app/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

package/template/src/templates/default/workspace/_debug_app/bin/setup

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  unless ARGV.include?("--skip-server")
+    puts "\n== Starting development server =="
+    STDOUT.flush # flush the output before exec(2) so that it displays
+    exec "bin/dev"
+  end
+end

package/template/src/templates/default/workspace/_debug_app/config/application.rb

@@ -0,0 +1,30 @@
+require_relative "boot"
+
+require "rails/all"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module DebugApp
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 8.0
+
+    # Please, add to the `ignore` list any other `lib` subdirectories that do
+    # not contain `.rb` files, or that should not be reloaded or eager loaded.
+    # Common ones are `templates`, `generators`, or `middleware`, for example.
+    config.autoload_lib(ignore: %w[assets tasks])
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+
+    # Don't generate system test files.
+    config.generators.system_tests = nil
+  end
+end

package/template/src/templates/default/workspace/_debug_app/config/cable.yml

@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: _debug_app_production

package/template/src/templates/default/workspace/_debug_app/config/credentials.yml.enc

@@ -0,0 +1 @@
+fmFP/4SmyTa9OK493+lQuvTxwNKPGEfIrIl+CUPcABSGhhVnzNZRKlWJN8dGx4vsSuFEY4cirFTPi6SszAwL6IWYpi+RrnSYU945a5rmXNO5G0QwQ93AtlL5vcOe0Tj4UYumbHWsn0/lthdqFRY4TOmDtxL+LWcsJRIS26fqdm/oEKaLZ8T2S3IikkthzwuUHzmSpXfW6dZlEvwIze0NZqqQJhnsQSMxHDAM/ROEqzWFdABW8mksHI8C89eY8lAX+cBcp+QHb30MMTYYayjWkn5A+iMOT+L95At3ICETkrQMrXt6Yz3SX/1sYti2lfI8z7XAQPJ54RlHiXc40V4wjfzPc/YkFvR1ubQXm1NE6yh/hGoC2OzWuKAcp+kSjO7wPJ9O2SCM8CgUhYVLyGAavIT3PUjKpxYKRY/YuE2ij3bSePp6PowXCnHUhxVUmUvSOmlSmS+ayP0yrXdV+kj1hTCZXgqzaGUhKpIRzvkVUzJfDR3j6PfhvPdj--PXMuLZ2/BnSPJCaI--9xCqfbZIAFLPcKcdRo7H5A==

package/template/src/templates/default/workspace/_debug_app/config/master.key

@@ -0,0 +1 @@
+0f07fe4aaff8cfc33878e6f96768fbef

package/template/src/templates/default/workspace/_debug_app/config/routes.rb

@@ -0,0 +1,14 @@
+Rails.application.routes.draw do
+  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
+
+  # Reveal health status on /up that returns 200 if the app boots with no exceptions, otherwise 500.
+  # Can be used by load balancers and uptime monitors to verify that the app is live.
+  get "up" => "rails/health#show", as: :rails_health_check
+
+  # Render dynamic PWA files from app/views/pwa/* (remember to link manifest in application.html.erb)
+  # get "manifest" => "rails/pwa#manifest", as: :pwa_manifest
+  # get "service-worker" => "rails/pwa#service_worker", as: :pwa_service_worker
+
+  # Defines the root path route ("/")
+  # root "posts#index"
+end

package/template/src/templates/default/workspace/_debug_app/test/test_helper.rb

@@ -0,0 +1,15 @@
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rails/test_help"
+
+module ActiveSupport
+  class TestCase
+    # Run tests in parallel with specified workers
+    parallelize(workers: :number_of_processors, with: :threads)
+
+    # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+    fixtures :all
+
+    # Add more helper methods to be used by all tests here...
+  end
+end

package/template/src/templates/rails-app/workspace/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

package/template/src/templates/rails-app/workspace/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks