create-react-on-rails-app 16.5.1 → 16.6.0-rc.0

package/lib/create-app.js

@@ -10,6 +10,94 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const utils_js_1 = require("./utils.js");
 const DOCS_URL = 'https://reactonrails.com/docs/';
+const DEFAULT_GIT_AUTHOR_NAME = 'React on Rails Generator';
+const DEFAULT_GIT_AUTHOR_EMAIL = 'generator@reactonrails.invalid';
+const SUPPORTED_RAILTIES_MAJORS = [7, 8];
+// Keep this renderer intentionally minimal. It renders Rails' installed
+// gitignore/gitattributes templates and falls back to bundled defaults when:
+// - railties is unavailable in the current Ruby environment, or
+// - railties major version is outside SUPPORTED_RAILTIES_MAJORS.
+const RAILS_GIT_TEMPLATE_RENDERER = `
+require "erb"
+
+class ReactOnRailsGitTemplateOptions
+  def api? = false
+
+  def [](key)
+    key == :skip_active_record ? false : nil
+  end
+end
+
+class ReactOnRailsGitTemplateContext
+  def keeps? = true
+
+  def skip_storage? = false
+
+  def options = ReactOnRailsGitTemplateOptions.new
+
+  def get_binding
+    binding
+  end
+end
+
+spec = Gem::Specification.find_by_name("railties")
+railties_major = spec.version.segments.first
+unless [${SUPPORTED_RAILTIES_MAJORS.join(', ')}].include?(railties_major)
+  warn "Unsupported railties major version for git template rendering: #{spec.version}"
+  exit 1
+end
+template_path = File.join(spec.gem_dir, "lib/rails/generators/rails/app/templates", ARGV[0])
+template = File.read(template_path)
+print ERB.new(template, trim_mode: "-").result(ReactOnRailsGitTemplateContext.new.get_binding)
+`;
+// Fallback copy of the Rails git scaffold (validated against Rails 7.2 templates)
+// for environments where rendering the installed railties templates is unavailable.
+const RAILS_GITIGNORE_FALLBACK = `# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# Temporary files generated by your text editor or operating system
+# belong in git's global ignore instead:
+# \`$XDG_CONFIG_HOME/git/ignore\` or \`~/.config/git/ignore\`
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files.
+/.env*
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore node modules.
+/node_modules
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+
+/public/assets
+
+# Ignore key files for decrypting credentials and more.
+/config/*.key
+`;
+const RAILS_GITATTRIBUTES_FALLBACK = `# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored
+`;
 function cleanupAppDirectory(appPath, appName, cleanupSuccessMessage, cleanupFallbackMessage) {
     if (!fs_1.default.existsSync(appPath)) {
         return;
@@ -46,7 +134,7 @@ function bundleAddArgs(gemName, localPath, strict = true) {
     return args;
 }
 function buildGeneratorArgs(options) {
-    const args = [];
+    const args = ['--new-app'];
     if (options.template === 'typescript') {
         args.push('--typescript');
     }
@@ -63,10 +151,9 @@ function buildGeneratorArgs(options) {
     // --force makes the generator overwrite conflicting files without prompting,
     // which is safe for a freshly scaffolded app with no custom content yet.
     args.push('--force');
-    // The newly created app directory is not a git repo yet, so the generator's
-    // uncommitted-changes check would always warn. --ignore-warnings bypasses all
-    // generator validation warnings (git, Node version, package manager) which is
-    // acceptable for a fresh app where prerequisites were already checked above.
+    // Keep the create-app flow non-interactive. --ignore-warnings bypasses generator
+    // validation warnings (git, Node version, package manager) because the CLI
+    // already checked prerequisites and is driving a fresh-app automation path.
     args.push('--ignore-warnings');
     return args;
 }
@@ -102,6 +189,30 @@ function rewriteFileIfPresent(filePath, transform) {
         fs_1.default.writeFileSync(filePath, updated, 'utf8');
     }
 }
+function readInstalledRailsGitTemplate(appPath, templateName) {
+    try {
+        const renderedTemplate = (0, utils_js_1.execCaptureArgs)('ruby', ['-e', RAILS_GIT_TEMPLATE_RENDERER, templateName], appPath);
+        return renderedTemplate.length > 0 ? `${renderedTemplate}\n` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function railsGitScaffold(appPath) {
+    const renderedGitignore = readInstalledRailsGitTemplate(appPath, 'gitignore.tt');
+    const renderedGitattributes = readInstalledRailsGitTemplate(appPath, 'gitattributes.tt');
+    return {
+        gitignore: renderedGitignore ?? RAILS_GITIGNORE_FALLBACK,
+        gitattributes: renderedGitattributes ?? RAILS_GITATTRIBUTES_FALLBACK,
+    };
+}
+function restoreRailsGitScaffold(appPath) {
+    // Rails omits .gitignore/.gitattributes when rails new runs with --skip-git.
+    // Recreate the defaults so the educational commit history stays clean.
+    const scaffold = railsGitScaffold(appPath);
+    fs_1.default.writeFileSync(path_1.default.join(appPath, '.gitignore'), scaffold.gitignore, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(appPath, '.gitattributes'), scaffold.gitattributes, 'utf8');
+}
 function normalizeGeneratedPackageManager(appPath, packageManager) {
     if (packageManager !== 'pnpm') {
         return;
@@ -133,7 +244,95 @@ function normalizeGeneratedPackageManager(appPath, packageManager) {
     });
     (0, utils_js_1.logStepDone)('pnpm configuration applied');
 }
-function printSuccessMessage(appName, route) {
+function ensureGitRepository(appPath) {
+    if (fs_1.default.existsSync(path_1.default.join(appPath, '.git'))) {
+        return;
+    }
+    (0, utils_js_1.execLiveArgs)('git', ['init'], appPath);
+}
+function readGitConfig(appPath, key) {
+    try {
+        const value = (0, utils_js_1.execCaptureArgs)('git', ['config', '--get', key], appPath);
+        return value === '' ? null : value;
+    }
+    catch {
+        return null;
+    }
+}
+function educationalGitEnv(appPath) {
+    const userName = readGitConfig(appPath, 'user.name') ?? DEFAULT_GIT_AUTHOR_NAME;
+    const userEmail = readGitConfig(appPath, 'user.email') ?? DEFAULT_GIT_AUTHOR_EMAIL;
+    return {
+        ...process.env,
+        GIT_AUTHOR_NAME: userName,
+        GIT_AUTHOR_EMAIL: userEmail,
+        GIT_COMMITTER_NAME: userName,
+        GIT_COMMITTER_EMAIL: userEmail,
+    };
+}
+function gitHasPendingChanges(appPath) {
+    try {
+        return (0, utils_js_1.execCaptureArgs)('git', ['status', '--porcelain'], appPath) !== '';
+    }
+    catch {
+        return false;
+    }
+}
+function createEducationalCommit(appPath, subject, body, educationalGitEnvForCommit) {
+    ensureGitRepository(appPath);
+    if (!gitHasPendingChanges(appPath)) {
+        return false;
+    }
+    // The educational history intentionally snapshots each full scaffold step.
+    (0, utils_js_1.execLiveArgs)('git', ['add', '-A'], appPath);
+    (0, utils_js_1.execLiveArgs)('git', ['-c', 'commit.gpgsign=false', 'commit', '-m', subject, '-m', body], appPath, educationalGitEnvForCommit());
+    return true;
+}
+function railsBaselineCommitMessage() {
+    return {
+        subject: 'Create Rails app with PostgreSQL',
+        body: 'Generate the fresh Rails baseline before adding React on Rails.',
+    };
+}
+function reactOnRailsGemCommitMessage() {
+    return {
+        subject: 'Add react_on_rails gem',
+        body: 'Install the OSS gem so the next commit can run the React on Rails generator.',
+    };
+}
+function reactOnRailsProCommitMessage(modeFlag) {
+    return {
+        subject: 'Add react_on_rails_pro gem',
+        body: `Install the Pro gem required by ${modeFlag} before running the generator.`,
+    };
+}
+function generatorCommitMessage(options) {
+    const language = options.template === 'typescript' ? 'TypeScript' : 'JavaScript';
+    const bundler = options.rspack ? 'Rspack' : 'Webpack';
+    if (options.rsc) {
+        return {
+            subject: `Install React Server Components with ${language} and ${bundler}`,
+            body: 'Run react_on_rails:install --rsc to add the generated home page, HelloServer example, and Pro RSC wiring.',
+        };
+    }
+    if (options.pro) {
+        return {
+            subject: `Install React on Rails Pro with ${language} and ${bundler}`,
+            body: 'Run react_on_rails:install --pro to add the generated home page, SSR example, and Pro Node renderer wiring.',
+        };
+    }
+    return {
+        subject: `Install React on Rails with ${language} and ${bundler}`,
+        body: 'Run react_on_rails:install to add the generated home page, SSR example, and development workflow.',
+    };
+}
+function pnpmCommitMessage() {
+    return {
+        subject: 'Normalize the generated app for pnpm',
+        body: 'Convert npm artifacts to pnpm, remove package-lock.json, and update bin/setup to use pnpm install.',
+    };
+}
+function printSuccessMessage(appName, educationalCommitsEnabled) {
     console.log('');
     (0, utils_js_1.logSuccess)(`Created ${appName} with React on Rails!`);
     console.log('');
@@ -144,7 +343,16 @@ function printSuccessMessage(appName, route) {
     console.log('');
     (0, utils_js_1.logInfo)('Note: The generated app uses PostgreSQL by default. Start PostgreSQL before running bin/rails db:prepare.');
     console.log('');
-    (0, utils_js_1.logInfo)(`Then visit http://localhost:3000/${route}`);
+    (0, utils_js_1.logInfo)('Then visit http://localhost:3000');
+    (0, utils_js_1.logInfo)('bin/dev will try to open the generated home page on first successful boot.');
+    console.log('');
+    if (educationalCommitsEnabled) {
+        (0, utils_js_1.logInfo)('Educational commits skip GPG signing so scaffold automation does not block on local signer prompts.');
+        (0, utils_js_1.logInfo)('Educational git history: git log --oneline --reverse');
+    }
+    else {
+        (0, utils_js_1.logInfo)('Educational git history is partial because git commit automation was skipped after an earlier failure.');
+    }
     console.log('');
     (0, utils_js_1.logInfo)(`Documentation: ${DOCS_URL}`);
     console.log('');
@@ -175,24 +383,49 @@ function validateAppName(name) {
 function createApp(appName, options) {
     const appPath = path_1.default.resolve(process.cwd(), appName);
     const proRequested = options.pro || options.rsc;
+    let educationalCommitsEnabled = true;
+    let cachedEducationalGitEnv = null;
     let proModeLabel = null;
-    if (options.rsc) {
-        proModeLabel = '--rsc';
-    }
-    else if (options.pro) {
-        proModeLabel = '--pro';
+    if (proRequested) {
+        proModeLabel = options.rsc ? '--rsc' : '--pro';
     }
     const baseSteps = 3; // rails new + add react_on_rails + run generator
     const totalSteps = baseSteps + (proRequested ? 1 : 0);
     let currentStep = 1;
     const reactOnRailsGemPath = localGemPath('REACT_ON_RAILS_GEM_PATH');
     const reactOnRailsProGemPath = proRequested ? localGemPath('REACT_ON_RAILS_PRO_GEM_PATH') : null;
+    function educationalGitEnvForCommits() {
+        if (!cachedEducationalGitEnv) {
+            // The baseline commit happens before git init; in that case git config falls back
+            // to the user's global identity, which is the behavior we want here.
+            cachedEducationalGitEnv = educationalGitEnv(appPath);
+        }
+        return cachedEducationalGitEnv;
+    }
+    function recordEducationalCommit(subject, body) {
+        if (!educationalCommitsEnabled) {
+            return;
+        }
+        try {
+            createEducationalCommit(appPath, subject, body, educationalGitEnvForCommits);
+        }
+        catch (error) {
+            educationalCommitsEnabled = false;
+            (0, utils_js_1.logInfo)(`Educational git history paused after "${subject}" because git commit automation failed. The app scaffold will continue.`);
+            if (error instanceof Error && error.message) {
+                console.error(`Git debug info: ${error.message}`);
+            }
+        }
+    }
     // Step 1: Create Rails application
     // appName is validated by validateAppName() to be ^[a-zA-Z][a-zA-Z0-9]*([_-][a-zA-Z0-9]+)*$ only,
     // so it's always a simple directory name safe to use with rails new.
     (0, utils_js_1.logStep)(currentStep, totalSteps, 'Creating Rails application...');
     try {
-        (0, utils_js_1.execLiveArgs)('rails', ['new', appName, '--database=postgresql', '--skip-javascript']);
+        (0, utils_js_1.execLiveArgs)('rails', ['new', appName, '--database=postgresql', '--skip-javascript', '--skip-git']);
+        restoreRailsGitScaffold(appPath);
+        const { subject, body } = railsBaselineCommitMessage();
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('Rails application created');
     }
     catch (error) {
@@ -212,6 +445,8 @@ function createApp(appName, options) {
             (0, utils_js_1.logInfo)(`Using local react_on_rails gem path: ${reactOnRailsGemPath}`);
         }
         (0, utils_js_1.execLiveArgs)('bundle', reactOnRailsArgs, appPath);
+        const { subject, body } = reactOnRailsGemCommitMessage();
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('react_on_rails gem added');
     }
     catch (error) {
@@ -231,6 +466,8 @@ function createApp(appName, options) {
                 (0, utils_js_1.logInfo)(`Using local react_on_rails_pro gem path: ${reactOnRailsProGemPath}`);
             }
             (0, utils_js_1.execLiveArgs)('bundle', reactOnRailsProArgs, appPath);
+            const { subject, body } = reactOnRailsProCommitMessage(proModeLabel ?? '--pro');
+            recordEducationalCommit(subject, body);
             (0, utils_js_1.logStepDone)('react_on_rails_pro gem added');
         }
         catch (error) {
@@ -251,6 +488,8 @@ function createApp(appName, options) {
             ...process.env,
             REACT_ON_RAILS_PACKAGE_MANAGER: options.packageManager,
         });
+        const { subject, body } = generatorCommitMessage(options);
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('React on Rails setup complete');
     }
     catch (error) {
@@ -263,6 +502,10 @@ function createApp(appName, options) {
     }
     try {
         normalizeGeneratedPackageManager(appPath, options.packageManager);
+        if (options.packageManager === 'pnpm') {
+            const { subject, body } = pnpmCommitMessage();
+            recordEducationalCommit(subject, body);
+        }
     }
     catch (error) {
         (0, utils_js_1.logError)(`Failed to finish ${options.packageManager} setup. The app was created, but package manager normalization did not complete.`);
@@ -280,6 +523,6 @@ function createApp(appName, options) {
     }
     // Final success
     (0, utils_js_1.logStepDone)('Done!');
-    printSuccessMessage(appName, options.rsc ? 'hello_server' : 'hello_world');
+    printSuccessMessage(appName, educationalCommitsEnabled);
 }
 //# sourceMappingURL=create-app.js.map

package/lib/index.js

@@ -110,11 +110,18 @@ What it does:
   1. Creates a new Rails app with PostgreSQL
   2. Adds required gem(s) (react_on_rails, plus react_on_rails_pro for --pro/--rsc)
   3. Runs the React on Rails generator (Shakapacker, components, webpack config)
+  4. Creates educational git commits for each major scaffold step
 
 After setup, run bin/dev and visit:
-  - http://localhost:3000/hello_world (default and --pro)
-  - http://localhost:3000/hello_server (--rsc)
+  - http://localhost:3000 (generated home page)
+  - /hello_world (default and --pro example page)
+  - /hello_server (--rsc example page)
 
+Inspect the generated setup history with:
+  - git log --oneline --reverse
+
+The generated app includes one git commit per logical setup step.`)
+    .addHelpText('after', `
 --pro and --rsc support both JavaScript and TypeScript templates.
 
 Documentation: https://reactonrails.com/docs/`)

package/lib/utils.d.ts

@@ -6,6 +6,7 @@
  * - Callers must still ensure `command` and `args` come from trusted/validated values.
  */
 export declare function execLiveArgs(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): void;
+export declare function execCaptureArgs(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): string;
 export declare function getCommandVersion(command: string): string | null;
 export declare function detectPackageManager(): 'npm' | 'pnpm' | null;
 export declare function logStep(current: number, total: number, message: string): void;

package/lib/utils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execLiveArgs = execLiveArgs;
+exports.execCaptureArgs = execCaptureArgs;
 exports.getCommandVersion = getCommandVersion;
 exports.detectPackageManager = detectPackageManager;
 exports.logStep = logStep;
@@ -13,6 +14,10 @@ exports.logSuccess = logSuccess;
 exports.logInfo = logInfo;
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
+function childEnv(env) {
+    // Always inherit PATH, HOME, and the rest of process.env; callers only add/override keys.
+    return env ? { ...process.env, ...env } : process.env;
+}
 /**
  * Execute a command and stream output to the current terminal.
  *
@@ -24,15 +29,39 @@ function execLiveArgs(command, args, cwd, env) {
     const result = (0, child_process_1.spawnSync)(command, args, {
         stdio: 'inherit',
         cwd,
-        ...(env ? { env } : {}),
+        env: childEnv(env),
     });
     if (result.error) {
         throw result.error;
     }
+    if (result.status === null) {
+        throw new Error(`Command "${command}" was terminated by ${result.signal ?? 'unknown signal'}`);
+    }
     if (result.status !== 0) {
         throw new Error(`Command "${command}" exited with code ${result.status}`);
     }
 }
+function execCaptureArgs(command, args, cwd, env) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        stdio: 'pipe',
+        encoding: 'utf8',
+        cwd,
+        env: childEnv(env),
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status === null) {
+        throw new Error(`Command "${command}" was terminated by ${result.signal ?? 'unknown signal'}`);
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr?.trim();
+        throw new Error(stderr && stderr.length > 0
+            ? `Command "${command}" exited with code ${result.status}: ${stderr}`
+            : `Command "${command}" exited with code ${result.status}`);
+    }
+    return result.stdout?.trim() ?? '';
+}
 function getCommandVersion(command) {
     try {
         return (0, child_process_1.execFileSync)(command, ['--version'], { encoding: 'utf8', stdio: 'pipe' }).trim();

package/lib/validators.d.ts

@@ -2,6 +2,7 @@ import { ValidationResult } from './types.js';
 export declare function validateNode(): ValidationResult;
 export declare function validateRuby(): ValidationResult;
 export declare function validateRails(): ValidationResult;
+export declare function validateGit(): ValidationResult;
 export declare function validatePackageManager(pm: 'npm' | 'pnpm'): ValidationResult;
 export interface PrerequisiteResults {
     allValid: boolean;

package/lib/validators.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateNode = validateNode;
 exports.validateRuby = validateRuby;
 exports.validateRails = validateRails;
+exports.validateGit = validateGit;
 exports.validatePackageManager = validatePackageManager;
 exports.validateAll = validateAll;
 const utils_js_1 = require("./utils.js");
@@ -85,6 +86,19 @@ function validateRails() {
     }
     return { valid: true, message: firstLine };
 }
+function validateGit() {
+    const gitVersion = (0, utils_js_1.getCommandVersion)('git');
+    if (!gitVersion) {
+        return {
+            valid: false,
+            message: 'git is not installed or not found in PATH.\n\n' +
+                'create-react-on-rails-app now records the generated app as a step-by-step git history.\n' +
+                'Install git, then try again:\n' +
+                '  https://git-scm.com/downloads',
+        };
+    }
+    return { valid: true, message: gitVersion.split('\n')[0].trim() };
+}
 function validatePackageManager(pm) {
     const version = (0, utils_js_1.getCommandVersion)(pm);
     if (!version) {
@@ -100,6 +114,7 @@ function validateAll(packageManager) {
         { name: 'Node.js', result: validateNode() },
         { name: 'Ruby', result: validateRuby() },
         { name: 'Rails', result: validateRails() },
+        { name: 'git', result: validateGit() },
         { name: 'Package Manager', result: validatePackageManager(packageManager) },
     ];
     const allValid = results.every((r) => r.result.valid);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-react-on-rails-app",
-  "version": "16.5.1",
+  "version": "16.6.0-rc.0",
   "description": "Create React on Rails applications with a single command",
   "bin": {
     "create-react-on-rails-app": "./bin/create-react-on-rails-app.js"