create-ripple 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ripple",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Interactive CLI tool for creating Ripple applications",
   "type": "module",
   "license": "MIT",

package/src/constants.js

@@ -1,9 +1,3 @@
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
 /**
  * Available templates configuration
  */
@@ -15,6 +9,9 @@ export const TEMPLATES = [
 	}
 ];
 
-// Get the root directory of the monorepo
-export const REPO_ROOT = resolve(__dirname, '../../../');
-export const TEMPLATES_DIR = join(REPO_ROOT, 'templates');
+/**
+ * GitHub repository configuration
+ */
+export const GITHUB_REPO = 'trueadm/ripple';
+export const GITHUB_BRANCH = 'main'; // or whatever the default branch is
+export const GITHUB_TEMPLATES_DIRECTORY = 'templates';

package/src/lib/project-creator.js

@@ -1,10 +1,10 @@
 import { join } from 'node:path';
-import { existsSync, mkdirSync, cpSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, cpSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { green, dim } from 'kleur/colors';
 import ora from 'ora';
 
-import { getTemplatePath } from './templates.js';
+import { downloadTemplate, getLocalTemplatePath, isLocalDevelopment } from './templates.js';
 
 /**
  * Create a new Ripple project
@@ -29,24 +29,46 @@ export async function createProject({
 	console.log(dim(`Package manager: ${packageManager}`));
 	console.log();
 
-	const templatePath = getTemplatePath(template);
+	let templatePath;
+	let isTemporary = false;
 
-	if (!existsSync(templatePath)) {
-		throw new Error(`Template "${template}" not found at ${templatePath}`);
+	// Step 1: Get or download template
+	const spinner1 = ora('Preparing template...').start();
+	try {
+		if (isLocalDevelopment()) {
+			// Use local template for development
+			templatePath = getLocalTemplatePath(template);
+			if (!existsSync(templatePath)) {
+				throw new Error(`Local template "${template}" not found at ${templatePath}`);
+			}
+			spinner1.succeed('Local template located');
+		} else {
+			// Download template from GitHub
+			spinner1.text = 'Downloading template from GitHub...';
+			templatePath = await downloadTemplate(template);
+			isTemporary = true;
+			spinner1.succeed('Template downloaded');
+		}
+	} catch (error) {
+		spinner1.fail('Failed to prepare template');
+		throw error;
 	}
 
-	// Step 1: Create project directory
-	const spinner1 = ora('Creating project directory...').start();
+	// Step 2: Create project directory
+	const spinner2 = ora('Creating project directory...').start();
 	try {
 		mkdirSync(projectPath, { recursive: true });
-		spinner1.succeed('Project directory created');
+		spinner2.succeed('Project directory created');
 	} catch (error) {
-		spinner1.fail('Failed to create project directory');
+		spinner2.fail('Failed to create project directory');
+		if (isTemporary) {
+			rmSync(templatePath, { recursive: true, force: true });
+		}
 		throw error;
 	}
 
-	// Step 2: Copy template files
-	const spinner2 = ora('Copying template files...').start();
+	// Step 3: Copy template files
+	const spinner3 = ora('Copying template files...').start();
 	try {
 		cpSync(templatePath, projectPath, {
 			recursive: true,
@@ -61,32 +83,47 @@ export async function createProject({
 				);
 			}
 		});
-		spinner2.succeed('Template files copied');
+		spinner3.succeed('Template files copied');
 	} catch (error) {
-		spinner2.fail('Failed to copy template files');
+		spinner3.fail('Failed to copy template files');
+		if (isTemporary) {
+			rmSync(templatePath, { recursive: true, force: true });
+		}
 		throw error;
 	}
 
-	// Step 3: Update package.json
-	const spinner3 = ora('Configuring package.json...').start();
+	// Step 4: Update package.json
+	const spinner4 = ora('Configuring package.json...').start();
 	try {
 		updatePackageJson(projectPath, projectName, packageManager, typescript);
-		spinner3.succeed('Package.json configured');
+		spinner4.succeed('Package.json configured');
 	} catch (error) {
-		spinner3.fail('Failed to configure package.json');
+		spinner4.fail('Failed to configure package.json');
+		if (isTemporary) {
+			rmSync(templatePath, { recursive: true, force: true });
+		}
 		throw error;
 	}
 
-	// Step 4: Initialize Git (if requested)
+	// Step 5: Initialize Git (if requested)
 	if (gitInit) {
-		const spinner4 = ora('Initializing Git repository...').start();
+		const spinner5 = ora('Initializing Git repository...').start();
 		try {
 			execSync('git init', { cwd: projectPath, stdio: 'ignore' });
 			execSync('git add .', { cwd: projectPath, stdio: 'ignore' });
 			execSync('git commit -m "Initial commit"', { cwd: projectPath, stdio: 'ignore' });
-			spinner4.succeed('Git repository initialized');
+			spinner5.succeed('Git repository initialized');
+		} catch (error) {
+			spinner5.warn('Git initialization failed (optional)');
+		}
+	}
+
+	// Clean up temporary template directory
+	if (isTemporary) {
+		try {
+			rmSync(templatePath, { recursive: true, force: true });
 		} catch (error) {
-			spinner4.warn('Git initialization failed (optional)');
+			// Ignore cleanup errors
 		}
 	}
 

package/src/lib/templates.js

@@ -1,6 +1,13 @@
 import { join } from 'node:path';
-import { existsSync } from 'node:fs';
-import { TEMPLATES, TEMPLATES_DIR } from '../constants.js';
+import { existsSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import degit from 'degit';
+import { GITHUB_REPO, GITHUB_TEMPLATES_DIRECTORY, TEMPLATES } from '../constants.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 /**
  * Get template by name
@@ -32,25 +39,66 @@ export function getTemplateChoices() {
 }
 
 /**
- * Validate if template exists
+ * Validate if template exists in our template list
  * @param {string} templateName - The template name to validate
- * @returns {boolean} - True if template exists
+ * @returns {boolean} - True if template exists in TEMPLATES list
  */
 export function validateTemplate(templateName) {
 	if (!templateName) return false;
-
 	const template = getTemplate(templateName);
-	if (!template) return false;
+	return template !== null;
+}
+
+/**
+ * Download template from GitHub repository
+ * @param {string} templateName - The template name to download
+ * @returns {Promise<string>} - Path to downloaded template directory
+ */
+export async function downloadTemplate(templateName) {
+	if (!validateTemplate(templateName)) {
+		throw new Error(`Template "${templateName}" not found`);
+	}
 
-	const templatePath = join(TEMPLATES_DIR, templateName);
-	return existsSync(templatePath);
+	// Create a temporary directory for the template
+	const tempDir = join(tmpdir(), `ripple-template-${templateName}-${Date.now()}`);
+	mkdirSync(tempDir, { recursive: true });
+
+	// Use degit to download the specific template from GitHub
+	const repoUrl = `${GITHUB_REPO}/${GITHUB_TEMPLATES_DIRECTORY}/${templateName}`;
+	const emitter = degit(repoUrl, {
+		cache: false,
+		force: true,
+		verbose: false
+	});
+
+	try {
+		await emitter.clone(tempDir);
+		return tempDir;
+	} catch (error) {
+		throw new Error(`Failed to download template "${templateName}": ${error.message}`);
+	}
 }
 
 /**
- * Get template directory path
+ * Get template directory path (for local development)
  * @param {string} templateName - The template name
  * @returns {string} - Absolute path to template directory
  */
-export function getTemplatePath(templateName) {
-	return join(TEMPLATES_DIR, templateName);
+export function getLocalTemplatePath(templateName) {
+	// This is used for local development in the monorepo
+	// Navigate from packages/create-ripple/src/lib/ to templates/
+	const repoRoot = join(__dirname, '../../../../');
+	return join(repoRoot, 'templates', templateName);
+}
+
+/**
+ * Check if we're running in development mode (monorepo)
+ * @returns {boolean} - True if in development mode
+ */
+export function isLocalDevelopment() {
+	// Check if we're in the monorepo by looking for the templates directory
+	// Navigate from packages/create-ripple/src/lib/ to templates/
+	const repoRoot = join(__dirname, '../../../../');
+	const templatesDir = join(repoRoot, 'templates');
+	return existsSync(templatesDir);
 }

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

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'node
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createProject } from '../../src/lib/project-creator.js';
+import { getLocalTemplatePath, isLocalDevelopment, validateTemplate } from '../../src/lib/templates.js';
 
 // Mock ora for cleaner test output
 vi.mock('ora', () => ({
@@ -22,6 +23,21 @@ vi.mock('node:child_process', () => ({
 	execSync: vi.fn()
 }));
 
+// Mock degit to prevent actual network calls
+vi.mock('degit', () => ({
+	default: vi.fn(() => ({
+		clone: vi.fn().mockResolvedValue(undefined)
+	}))
+}));
+
+// Mock template functions globally
+vi.mock('../../src/lib/templates.js', () => ({
+	getLocalTemplatePath: vi.fn(),
+	isLocalDevelopment: vi.fn(),
+	downloadTemplate: vi.fn(),
+	validateTemplate: vi.fn()
+}));
+
 describe('createProject integration tests', () => {
 	let testDir;
 	let projectPath;
@@ -64,10 +80,10 @@ describe('createProject integration tests', () => {
 		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
-		}));
+		// Set up mocks for each test
+		vi.mocked(getLocalTemplatePath).mockReturnValue(templatePath);
+		vi.mocked(isLocalDevelopment).mockReturnValue(true);
+		vi.mocked(validateTemplate).mockReturnValue(true);
 	});
 
 	afterEach(() => {
@@ -150,20 +166,19 @@ describe('createProject integration tests', () => {
 	it('should handle missing template directory', async () => {
 		const invalidTemplatePath = join(testDir, 'non-existent-template');
 		
-		vi.doMock('../../src/lib/templates.js', () => ({
-			getTemplatePath: () => invalidTemplatePath
-		}));
+		// Override the mock for this specific test
+		vi.mocked(getLocalTemplatePath).mockReturnValue(invalidTemplatePath);
 
 		await expect(
 			createProject({
 				projectName: 'test-project',
 				projectPath,
-				template: 'non-existent',
+				template: 'basic',
 				packageManager: 'npm',
 				typescript: true,
 				gitInit: false
 			})
-		).rejects.toThrow('Template "non-existent" not found');
+		).rejects.toThrow('Local template "basic" not found');
 	});
 
 	it('should filter out unwanted files during copy', async () => {

package/tests/unit/templates.test.js

@@ -5,7 +5,9 @@ import {
 	getTemplateNames,
 	getTemplateChoices,
 	validateTemplate,
-	getTemplatePath,
+	getLocalTemplatePath,
+	isLocalDevelopment,
+	downloadTemplate
 } from '../../src/lib/templates.js';
 
 // Mock the constants
@@ -94,70 +96,65 @@ describe('getTemplateChoices', () => {
 });
 
 describe('validateTemplate', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		// Reset the mock to a default state for CI compatibility
-		const mockExistsSync = vi.mocked(existsSync);
-		mockExistsSync.mockReturnValue(false);
-	});
-
-	it('should return true for valid existing template', () => {
-		const mockExistsSync = vi.mocked(existsSync);
-		mockExistsSync.mockReturnValue(true);
+	it('should return true for valid template', () => {
 		const isValid = validateTemplate('basic');
 		expect(isValid).toBe(true);
-		expect(mockExistsSync).toHaveBeenCalledWith('/mock/templates/basic');
-	});
-
-	it('should return false for valid template that does not exist on filesystem', () => {
-		const mockExistsSync = vi.mocked(existsSync);
-		mockExistsSync.mockReturnValue(false);
-		const isValid = validateTemplate('basic');
-		expect(isValid).toBe(false);
 	});
 
 	it('should return false for invalid template name', () => {
-		const mockExistsSync = vi.mocked(existsSync);
 		const isValid = validateTemplate('non-existent');
 		expect(isValid).toBe(false);
-		expect(mockExistsSync).not.toHaveBeenCalled();
 	});
 
 	it('should return false for undefined template name', () => {
-		const mockExistsSync = vi.mocked(existsSync);
 		const isValid = validateTemplate();
 		expect(isValid).toBe(false);
-		expect(mockExistsSync).not.toHaveBeenCalled();
 	});
 
 	it('should return false for null template name', () => {
-		const mockExistsSync = vi.mocked(existsSync);
 		const isValid = validateTemplate(null);
 		expect(isValid).toBe(false);
-		expect(mockExistsSync).not.toHaveBeenCalled();
 	});
 
 	it('should return false for empty string template name', () => {
-		const mockExistsSync = vi.mocked(existsSync);
 		const isValid = validateTemplate('');
 		expect(isValid).toBe(false);
-		expect(mockExistsSync).not.toHaveBeenCalled();
 	});
 });
 
-describe('getTemplatePath', () => {
-	it('should return correct template path', () => {
-		const path = getTemplatePath('basic');
-		expect(path).toBe('/mock/templates/basic');
+describe('getLocalTemplatePath', () => {
+	it('should return correct local template path', () => {
+		const path = getLocalTemplatePath('basic');
+		expect(path).toContain('templates/basic');
 	});
 
 	it('should return path even for non-existent template', () => {
-		const path = getTemplatePath('non-existent');
-		expect(path).toBe('/mock/templates/non-existent');
+		const path = getLocalTemplatePath('non-existent');
+		expect(path).toContain('templates/non-existent');
 	});
 
 	it('should handle special characters in template name', () => {
-		const path = getTemplatePath('my-template.name');
-		expect(path).toBe('/mock/templates/my-template.name');
+		const path = getLocalTemplatePath('my-template.name');
+		expect(path).toContain('templates/my-template.name');
+	});
+});
+
+describe('isLocalDevelopment', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should return true when templates directory exists', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		mockExistsSync.mockReturnValue(true);
+		const isDev = isLocalDevelopment();
+		expect(isDev).toBe(true);
+	});
+
+	it('should return false when templates directory does not exist', () => {
+		const mockExistsSync = vi.mocked(existsSync);
+		mockExistsSync.mockReturnValue(false);
+		const isDev = isLocalDevelopment();
+		expect(isDev).toBe(false);
 	});
 });

package/vitest.config.js

@@ -16,7 +16,7 @@ export default defineConfig({
 				'**/*.config.js'
 			]
 		},
-		testTimeout: 30000, // 30 seconds for integration tests
+		testTimeout: 60000, // 60 seconds for integration tests
 		hookTimeout: 10000 // 10 seconds for setup/teardown
 	}
 });