create-ripple 0.1.0

package/src/lib/templates.js

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { TEMPLATES, TEMPLATES_DIR } from '../constants.js';
+
+/**
+ * Get template by name
+ * @param {string} templateName - The template name
+ * @returns {object|null} - Template object or null if not found
+ */
+export function getTemplate(templateName) {
+	return TEMPLATES.find((template) => template.name === templateName) || null;
+}
+
+/**
+ * Get all available template names
+ * @returns {string[]} - Array of template names
+ */
+export function getTemplateNames() {
+	return TEMPLATES.map((template) => template.name);
+}
+
+/**
+ * Get template choices for prompts
+ * @returns {object[]} - Array of choice objects for prompts
+ */
+export function getTemplateChoices() {
+	return TEMPLATES.map((template) => ({
+		title: template.display,
+		description: template.description,
+		value: template.name
+	}));
+}
+
+/**
+ * Validate if template exists
+ * @param {string} templateName - The template name to validate
+ * @returns {boolean} - True if template exists
+ */
+export function validateTemplate(templateName) {
+	if (!templateName) return false;
+
+	const template = getTemplate(templateName);
+	if (!template) return false;
+
+	const templatePath = join(TEMPLATES_DIR, templateName);
+	return existsSync(templatePath);
+}
+
+/**
+ * Get template directory path
+ * @param {string} templateName - The template name
+ * @returns {string} - Absolute path to template directory
+ */
+export function getTemplatePath(templateName) {
+	return join(TEMPLATES_DIR, templateName);
+}

package/src/lib/validation.js

@@ -0,0 +1,155 @@
+/**
+ * Validation utilities for project creation
+ */
+
+/**
+ * Validates a project name according to npm package naming rules
+ * @param {string} name - The project name to validate
+ * @returns {object} - Object with valid boolean and message string
+ */
+export function validateProjectName(name) {
+	if (typeof name !== 'string' || name === null || name === undefined) {
+		return {
+			valid: false,
+			message: 'Project name is required'
+		};
+	}
+
+	name = name.trim();
+
+	if (name.length === 0) {
+		return {
+			valid: false,
+			message: 'Project name cannot be empty'
+		};
+	}
+
+	// Check length (npm package names have a 214 character limit)
+	if (name.length > 214) {
+		return {
+			valid: false,
+			message: 'Project name must be less than 214 characters'
+		};
+	}
+
+	// Check for valid characters (npm allows lowercase letters, numbers, hyphens, and dots)
+	if (!/^[a-z0-9._-]+$/.test(name)) {
+		return {
+			valid: false,
+			message:
+				'Project name can only contain lowercase letters, numbers, hyphens, dots, and underscores'
+		};
+	}
+
+	// Cannot start with dot or underscore
+	if (name.startsWith('.') || name.startsWith('_')) {
+		return {
+			valid: false,
+			message: 'Project name cannot start with a dot or underscore'
+		};
+	}
+
+	// Cannot end with dot
+	if (name.endsWith('.')) {
+		return {
+			valid: false,
+			message: 'Project name cannot end with a dot'
+		};
+	}
+
+	// Cannot contain consecutive dots
+	if (name.includes('..')) {
+		return {
+			valid: false,
+			message: 'Project name cannot contain consecutive dots'
+		};
+	}
+
+	// Reserved names
+	const reservedNames = [
+		'node_modules',
+		'favicon.ico',
+		'con',
+		'prn',
+		'aux',
+		'nul',
+		'com1',
+		'com2',
+		'com3',
+		'com4',
+		'com5',
+		'com6',
+		'com7',
+		'com8',
+		'com9',
+		'lpt1',
+		'lpt2',
+		'lpt3',
+		'lpt4',
+		'lpt5',
+		'lpt6',
+		'lpt7',
+		'lpt8',
+		'lpt9'
+	];
+
+	if (reservedNames.includes(name.toLowerCase())) {
+		return {
+			valid: false,
+			message: `"${name}" is a reserved name and cannot be used`
+		};
+	}
+
+	return {
+		valid: true,
+		message: ''
+	};
+}
+
+/**
+ * Converts a project name to a valid directory name
+ * @param {string} name - The project name
+ * @returns {string} - A valid directory name
+ */
+export function sanitizeDirectoryName(name) {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9-]/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.replace(/-+/g, '-');
+}
+
+/**
+ * Validates directory path and checks if it's writable
+ * @param {string} path - The directory path to validate
+ * @returns {object} - Object with valid boolean and message string
+ */
+export function validateDirectoryPath(path) {
+	if (!path || typeof path !== 'string') {
+		return {
+			valid: false,
+			message: 'Directory path is required'
+		};
+	}
+
+	// Check if path is absolute or relative
+	if (path.startsWith('/') && path.length < 2) {
+		return {
+			valid: false,
+			message: 'Cannot create project in root directory'
+		};
+	}
+
+	// Check for invalid characters in path
+	if (/[<>:"|?*]/.test(path)) {
+		return {
+			valid: false,
+			message: 'Directory path contains invalid characters'
+		};
+	}
+
+	return {
+		valid: true,
+		message: ''
+	};
+}

package/tests/integration/cli.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CLI_PATH = join(__dirname, '../../src/index.js');
+
+describe('CLI Integration Tests', () => {
+	let testDir;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `cli-test-${Date.now()}`);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	// Helper function to run CLI commands
+	const runCLI = (args = [], input = '', timeout = 10000) => {
+		return new Promise((resolve, reject) => {
+			const child = spawn('node', [CLI_PATH, ...args], {
+				cwd: testDir,
+				stdio: 'pipe'
+			});
+
+			let stdout = '';
+			let stderr = '';
+
+			child.stdout.on('data', (data) => {
+				stdout += data.toString();
+			});
+
+			child.stderr.on('data', (data) => {
+				stderr += data.toString();
+			});
+
+			child.on('close', (code) => {
+				resolve({ code, stdout, stderr });
+			});
+
+			child.on('error', reject);
+
+			if (input) {
+				child.stdin.write(input);
+			}
+			child.stdin.end();
+
+			setTimeout(() => {
+				child.kill();
+				reject(new Error('Command timed out'));
+			}, timeout);
+		});
+	};
+
+	it('should show help when --help flag is used', async () => {
+		const result = await runCLI(['--help']);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Interactive CLI tool for creating Ripple applications');
+		expect(result.stdout).toContain('Usage: create-ripple-app');
+		expect(result.stdout).toContain('Arguments:');
+		expect(result.stdout).toContain('Options:');
+		expect(result.stdout).toContain('--template');
+		expect(result.stdout).toContain('--package-manager');
+	});
+
+	it('should show version when --version flag is used', async () => {
+		const result = await runCLI(['--version']);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+	});
+
+	it('should create project with all arguments provided', async () => {
+		const projectName = 'test-cli-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'npm',
+			'--no-git',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Welcome to Create Ripple App');
+		expect(result.stdout).toContain('Creating Ripple app');
+		expect(result.stdout).toContain('Project created successfully');
+		expect(result.stdout).toContain('Next steps:');
+		expect(result.stdout).toContain(`cd ${projectName}`);
+		expect(result.stdout).toContain('npm install');
+		expect(result.stdout).toContain('npm run dev');
+
+		expect(existsSync(join(testDir, projectName))).toBe(true);
+		expect(existsSync(join(testDir, projectName, 'package.json'))).toBe(true);
+	});
+
+	it('should handle invalid template gracefully', async () => {
+		const result = await runCLI([
+			'test-project',
+			'--template', 'invalid-template',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(1);
+		expect(result.stderr).toContain('Template "invalid-template" not found');
+		expect(result.stderr).toContain('Available templates:');
+	});
+
+	it('should handle invalid project name gracefully', async () => {
+		const result = await runCLI([
+			'Invalid Project Name!',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(1);
+		expect(result.stderr).toContain('Project name can only contain lowercase letters');
+	});
+
+	it('should show different package manager commands based on selection', async () => {
+		const projectName = 'test-pnpm-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'pnpm',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('pnpm install');
+		expect(result.stdout).toContain('pnpm dev');
+	});
+
+	it('should handle yarn package manager', async () => {
+		const projectName = 'test-yarn-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'yarn',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('yarn install');
+		expect(result.stdout).toContain('yarn dev');
+	});
+
+	it('should handle project directory that already exists (with --yes)', async () => {
+		const projectName = 'existing-project';
+		const projectPath = join(testDir, projectName);
+
+		mkdirSync(projectPath, { recursive: true });
+		writeFileSync(join(projectPath, 'existing-file.txt'), 'test');
+
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Project created successfully');
+	});
+
+	it('should validate all required dependencies are available', async () => {
+		const result = await runCLI(['--help']);
+		expect(result.code).toBe(0);
+		expect(result.stderr).toBe('');
+	});
+});

package/tests/integration/project-creator.test.js

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createProject } from '../../src/lib/project-creator.js';
+
+// Mock ora for cleaner test output
+vi.mock('ora', () => ({
+	default: () => ({
+		start: () => ({ succeed: vi.fn(), fail: vi.fn(), warn: vi.fn() }),
+		succeed: vi.fn(),
+		fail: vi.fn(),
+		warn: vi.fn()
+	})
+}));
+
+// Mock execSync to prevent actual git commands during tests
+vi.mock('node:child_process', () => ({
+	default: {
+		execSync: vi.fn()
+	},
+	execSync: vi.fn()
+}));
+
+describe('createProject integration tests', () => {
+	let testDir;
+	let projectPath;
+	let templatePath;
+
+	beforeEach(() => {
+		// Create a temporary test directory
+		testDir = join(tmpdir(), `create-ripple-test-${Date.now()}`);
+		mkdirSync(testDir, { recursive: true });
+		
+		projectPath = join(testDir, 'test-project');
+		templatePath = join(testDir, 'template');
+
+		// Create a mock template directory structure
+		mkdirSync(templatePath, { recursive: true });
+		mkdirSync(join(templatePath, 'src'), { recursive: true });
+		
+		// Create mock template files
+		writeFileSync(
+			join(templatePath, 'package.json'),
+			JSON.stringify({
+				name: 'vite-template-ripple',
+				version: '0.0.0',
+				type: 'module',
+				scripts: {
+					dev: 'vite',
+					build: 'vite build'
+				},
+				dependencies: {
+					ripple: '^0.2.29'
+				},
+				devDependencies: {
+					'vite-plugin-ripple': '^0.2.29',
+					prettier: '^3.6.2'
+				}
+			}, null, 2)
+		);
+
+		writeFileSync(join(templatePath, 'index.html'), '<!DOCTYPE html><html></html>');
+		writeFileSync(join(templatePath, 'src', 'App.ripple'), '<h1>Hello Ripple!</h1>');
+		writeFileSync(join(templatePath, 'README.md'), '# Template Project');
+
+		// Mock the getTemplatePath function
+		vi.doMock('../../src/lib/templates.js', () => ({
+			getTemplatePath: () => templatePath
+		}));
+	});
+
+	afterEach(() => {
+		// Clean up test directory
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+		vi.clearAllMocks();
+	});
+
+	it('should create a project successfully', async () => {
+		await createProject({
+			projectName: 'test-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'npm',
+			typescript: true,
+			gitInit: false
+		});
+
+		// Verify project directory was created
+		expect(existsSync(projectPath)).toBe(true);
+
+		// Verify files were copied
+		expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+		expect(existsSync(join(projectPath, 'index.html'))).toBe(true);
+		expect(existsSync(join(projectPath, 'src', 'App.ripple'))).toBe(true);
+		expect(existsSync(join(projectPath, 'README.md'))).toBe(true);
+
+		// Verify package.json was updated
+		const packageJson = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf-8'));
+		expect(packageJson.name).toBe('test-project');
+		expect(packageJson.description).toBe('A Ripple application created with create-ripple-app');
+		expect(packageJson.version).toBe('1.0.0');
+	});
+
+	it('should update package.json with correct package manager', async () => {
+		await createProject({
+			projectName: 'test-pnpm-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'pnpm',
+			typescript: true,
+			gitInit: false
+		});
+
+		const packageJson = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf-8'));
+		expect(packageJson.packageManager).toBe('pnpm@9.0.0');
+	});
+
+	it('should not add packageManager field for npm', async () => {
+		await createProject({
+			projectName: 'test-npm-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'npm',
+			typescript: true,
+			gitInit: false
+		});
+
+		const packageJson = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf-8'));
+		expect(packageJson.packageManager).toBeUndefined();
+	});
+
+	it('should update dependency versions', async () => {
+		await createProject({
+			projectName: 'test-deps-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'npm',
+			typescript: true,
+			gitInit: false
+		});
+
+		const packageJson = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf-8'));
+		expect(packageJson.dependencies.ripple).toBe('^0.2.35');
+		expect(packageJson.devDependencies['vite-plugin-ripple']).toBe('^0.2.29');
+	});
+
+	it('should handle missing template directory', async () => {
+		const invalidTemplatePath = join(testDir, 'non-existent-template');
+		
+		vi.doMock('../../src/lib/templates.js', () => ({
+			getTemplatePath: () => invalidTemplatePath
+		}));
+
+		await expect(
+			createProject({
+				projectName: 'test-project',
+				projectPath,
+				template: 'non-existent',
+				packageManager: 'npm',
+				typescript: true,
+				gitInit: false
+			})
+		).rejects.toThrow('Template "non-existent" not found');
+	});
+
+	it('should filter out unwanted files during copy', async () => {
+		// Add files that should be filtered out
+		mkdirSync(join(templatePath, 'node_modules'), { recursive: true });
+		writeFileSync(join(templatePath, 'node_modules', 'some-package.js'), 'module content');
+		writeFileSync(join(templatePath, 'package-lock.json'), '{}');
+		writeFileSync(join(templatePath, 'yarn.lock'), 'yarn lock content');
+		writeFileSync(join(templatePath, 'pnpm-lock.yaml'), 'pnpm lock content');
+
+		await createProject({
+			projectName: 'test-filter-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'npm',
+			typescript: true,
+			gitInit: false
+		});
+
+		// Verify filtered files were not copied
+		expect(existsSync(join(projectPath, 'node_modules'))).toBe(false);
+		expect(existsSync(join(projectPath, 'package-lock.json'))).toBe(false);
+		expect(existsSync(join(projectPath, 'yarn.lock'))).toBe(false);
+		expect(existsSync(join(projectPath, 'pnpm-lock.yaml'))).toBe(false);
+
+		// Verify other files were copied
+		expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+		expect(existsSync(join(projectPath, 'index.html'))).toBe(true);
+	});
+
+	it('should handle project creation in existing directory', async () => {
+		// Create the directory first
+		mkdirSync(projectPath, { recursive: true });
+		writeFileSync(join(projectPath, 'existing-file.txt'), 'existing content');
+
+		await createProject({
+			projectName: 'test-existing-project',
+			projectPath,
+			template: 'basic',
+			packageManager: 'npm',
+			typescript: true,
+			gitInit: false
+		});
+
+		// Verify project was created successfully
+		expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+		expect(existsSync(join(projectPath, 'existing-file.txt'))).toBe(true);
+	});
+});