Rename folders since the template package generator now creates a package for "dotnet new" as well as Yeoman

templates/package-builder/src/build/build.ts

@@ -0,0 +1,160 @@
+import * as glob from 'glob';
+import * as gitignore from 'gitignore-parser';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as _ from 'lodash';
+import * as mkdirp from 'mkdirp';
+import * as rimraf from 'rimraf';
+import * as childProcess from 'child_process';
+
+const isWindows = /^win/.test(process.platform);
+const textFileExtensions = ['.gitignore', 'template_gitignore', '.config', '.cs', '.cshtml', 'Dockerfile', '.html', '.js', '.json', '.jsx', '.md', '.nuspec', '.ts', '.tsx', '.xproj'];
+const yeomanGeneratorSource = './src/yeoman';
+
+const templates: { [key: string]: { dir: string, dotNetNewId: string, displayName: string } } = {
+    'angular-2': { dir: '../../templates/Angular2Spa/', dotNetNewId: 'Angular', displayName: 'Angular 2' },
+    'knockout': { dir: '../../templates/KnockoutSpa/', dotNetNewId: 'Knockout', displayName: 'Knockout.js' },
+    'react-redux': { dir: '../../templates/ReactReduxSpa/', dotNetNewId: 'ReactRedux', displayName: 'React.js and Redux' },
+    'react': { dir: '../../templates/ReactSpa/', dotNetNewId: 'React', displayName: 'React.js' }
+};
+
+function isTextFile(filename: string): boolean {
+    return textFileExtensions.indexOf(path.extname(filename).toLowerCase()) >= 0;
+}
+
+function writeFileEnsuringDirExists(root: string, filename: string, contents: string | Buffer) {
+    let fullPath = path.join(root, filename);
+    mkdirp.sync(path.dirname(fullPath));
+    fs.writeFileSync(fullPath, contents);
+}
+
+function listFilesExcludingGitignored(root: string): string[] {
+    // Note that the gitignore files, prior to be written by the generator, are called 'template_gitignore'
+    // instead of '.gitignore'. This is a workaround for Yeoman doing strange stuff with .gitignore files
+    // (it renames them to .npmignore, which is not helpful).
+    let gitIgnorePath = path.join(root, 'template_gitignore');
+    let gitignoreEvaluator = fs.existsSync(gitIgnorePath)
+        ? gitignore.compile(fs.readFileSync(gitIgnorePath, 'utf8'))
+        : { accepts: () => true };
+    return glob.sync('**/*', { cwd: root, dot: true, nodir: true })
+        .filter(fn => gitignoreEvaluator.accepts(fn));
+}
+
+function writeTemplate(sourceRoot: string, destRoot: string, contentReplacements: { from: RegExp, to: string }[], filenameReplacements: { from: RegExp, to: string }[]) {
+    listFilesExcludingGitignored(sourceRoot).forEach(fn => {
+        let sourceContent = fs.readFileSync(path.join(sourceRoot, fn));
+
+        // For text files, replace hardcoded values with template tags
+        if (isTextFile(fn)) {
+            let sourceText = sourceContent.toString('utf8');
+            contentReplacements.forEach(replacement => {
+                sourceText = sourceText.replace(replacement.from, replacement.to);
+            });
+
+            sourceContent = new Buffer(sourceText, 'utf8');
+        }
+
+        // Also apply replacements in filenames
+        filenameReplacements.forEach(replacement => {
+            fn = fn.replace(replacement.from, replacement.to);
+        });
+
+        writeFileEnsuringDirExists(destRoot, fn, sourceContent);
+    });
+}
+
+function copyRecursive(sourceRoot: string, destRoot: string, matchGlob: string) {
+    glob.sync(matchGlob, { cwd: sourceRoot, dot: true, nodir: true })
+        .forEach(fn => {
+            const sourceContent = fs.readFileSync(path.join(sourceRoot, fn));
+            writeFileEnsuringDirExists(destRoot, fn, sourceContent);
+        });
+}
+
+function buildYeomanNpmPackage() {
+    const outputRoot = './dist/generator-aspnetcore-spa';
+    const outputTemplatesRoot = path.join(outputRoot, 'app/templates');
+    rimraf.sync(outputTemplatesRoot);
+
+    // Copy template files
+    const filenameReplacements = [
+        { from: /.*\.xproj$/, to: 'tokenreplace-namePascalCase.xproj' }
+    ];
+    const contentReplacements = [
+        { from: /\bWebApplicationBasic\b/g, to: '<%= namePascalCase %>' },
+        { from: /<ProjectGuid>[0-9a-f\-]{36}<\/ProjectGuid>/g, to: '<ProjectGuid><%= projectGuid %></ProjectGuid>' },
+        { from: /<RootNamespace>.*?<\/RootNamespace>/g, to: '<RootNamespace><%= namePascalCase %></RootNamespace>'},
+        { from: /\s*<BaseIntermediateOutputPath.*?<\/BaseIntermediateOutputPath>/g, to: '' },
+        { from: /\s*<OutputPath.*?<\/OutputPath>/g, to: '' },
+    ];
+    _.forEach(templates, (templateConfig, templateName) => {
+        const outputDir = path.join(outputTemplatesRoot, templateName);
+        writeTemplate(templateConfig.dir, outputDir, contentReplacements, filenameReplacements);
+    });
+
+    // Also copy the generator files (that's the compiled .js files, plus all other non-.ts files)
+    const tempRoot = './tmp';
+    copyRecursive(path.join(tempRoot, 'yeoman'), outputRoot, '**/*.js');
+    copyRecursive(yeomanGeneratorSource, outputRoot, '**/!(*.ts)');
+
+    // Clean up
+    rimraf.sync(tempRoot);
+}
+
+function buildDotNetNewNuGetPackage() {
+    const outputRoot = './dist/dotnetnew';
+    rimraf.sync(outputRoot);
+
+    // Copy template files
+    const sourceProjectName = 'WebApplicationBasic';
+    const projectGuid = '00000000-0000-0000-0000-000000000000';
+    const filenameReplacements = [
+        { from: /.*\.xproj$/, to: `${sourceProjectName}.xproj` },
+        { from: /\btemplate_gitignore$/, to: '.gitignore' }
+    ];
+    const contentReplacements = [
+        { from: /<ProjectGuid>[0-9a-f\-]{36}<\/ProjectGuid>/g, to: `<ProjectGuid>${projectGuid}</ProjectGuid>` },
+        { from: /<RootNamespace>.*?<\/RootNamespace>/g, to: `<RootNamespace>${sourceProjectName}</RootNamespace>`},
+        { from: /\s*<BaseIntermediateOutputPath.*?<\/BaseIntermediateOutputPath>/g, to: '' },
+        { from: /\s*<OutputPath.*?<\/OutputPath>/g, to: '' },
+    ];
+    _.forEach(templates, (templateConfig, templateName) => {
+        const templateOutputDir = path.join(outputRoot, 'templates', templateName);
+        const templateOutputProjectDir = path.join(templateOutputDir, sourceProjectName);
+        writeTemplate(templateConfig.dir, templateOutputProjectDir, contentReplacements, filenameReplacements);
+
+        // Add a .netnew.json file
+        fs.writeFileSync(path.join(templateOutputDir, '.netnew.json'), JSON.stringify({
+            author: 'Microsoft',
+            classifications: [ 'Standard>>Quick Starts' ],
+            name: `ASP.NET Core SPA with ${templateConfig.displayName}`,
+            groupIdentity: `Microsoft.AspNetCore.Spa.${templateConfig.dotNetNewId}`,
+            identity: `Microsoft.AspNetCore.Spa.${templateConfig.dotNetNewId}`,
+            shortName: `aspnetcorespa-${templateConfig.dotNetNewId.toLowerCase()}`,
+            tags: { language: 'C#' },
+            guids: [ projectGuid ],
+            sourceName: sourceProjectName
+        }, null, 2));
+    });
+
+    // Invoke NuGet to create the final package
+    const yeomanPackageVersion = JSON.parse(fs.readFileSync(path.join(yeomanGeneratorSource, 'package.json'), 'utf8')).version;
+    writeTemplate('./src/dotnetnew', outputRoot, [
+        { from: /\{version\}/g, to: yeomanPackageVersion },
+    ], []);
+    const nugetExe = path.join(process.cwd(), './bin/NuGet.exe');
+    const nugetStartInfo = { cwd: outputRoot, stdio: 'inherit' };
+    if (isWindows) {
+        // Invoke NuGet.exe directly
+        childProcess.spawnSync(nugetExe, ['pack'], nugetStartInfo);
+    } else {
+        // Invoke via Mono (relying on that being available)
+        childProcess.spawnSync('mono', [nugetExe, 'pack'], nugetStartInfo);
+    }
+
+    // Clean up
+    rimraf.sync('./tmp');
+}
+
+buildYeomanNpmPackage();
+buildDotNetNewNuGetPackage();

templates/package-builder/src/dotnetnew/Microsoft.AspNetCore.Spa.Templates.nuspec

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
+    <metadata>
+        <id>Microsoft.AspNetCore.Spa.Templates</id>
+        <version>{version}</version>
+        <title>Class Library and Console Application Templates for .NET Core</title>
+        <authors>Microsoft</authors>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>My package description.</description>
+        <dependencies>
+            <group targetFramework=".NETCoreApp,Version=v1.0">
+                <dependency id="Microsoft.TemplateEngine.Orchestrator.RunnableProjects" version="1.0.0" />
+            </group>
+        </dependencies>
+    </metadata>
+    <files>
+        <file src="templates/**" />
+    </files>
+</package>

templates/package-builder/src/yeoman/.gitignore

@@ -0,0 +1 @@
+/node_modules/

templates/package-builder/src/yeoman/app/index.ts

@@ -0,0 +1,77 @@
+import * as path from 'path';
+import * as yeoman from 'yeoman-generator';
+import * as uuid from 'node-uuid';
+import * as glob from 'glob';
+const yosay = require('yosay');
+const toPascalCase = require('to-pascal-case');
+
+const templates = [
+    { value: 'angular-2', name: 'Angular 2' },
+    { value: 'knockout', name: 'Knockout' },
+    { value: 'react', name: 'React' },
+    { value: 'react-redux', name: 'React with Redux' }
+];
+
+class MyGenerator extends yeoman.Base {
+    private _answers: any;
+
+    constructor(args: string | string[], options: any) {
+        super(args, options);
+        this.log(yosay('Welcome to the ASP.NET Core Single-Page App generator!'));
+    }
+
+    prompting() {
+        const done = this.async();
+
+        this.prompt([{
+            type: 'list',
+            name: 'framework',
+            message: 'Framework',
+            choices: templates
+        }, {
+            type: 'input',
+            name: 'name',
+            message: 'Your project name',
+            default: this.appname
+        }], answers => {
+            this._answers = answers;
+            this._answers.namePascalCase = toPascalCase(answers.name);
+            this._answers.projectGuid = uuid.v4();
+            done();
+        });
+    }
+
+    writing() {
+        var templateRoot = this.templatePath(this._answers.framework);
+        glob.sync('**/*', { cwd: templateRoot, dot: true, nodir: true }).forEach(fn => {
+            // Token replacement in filenames
+            let outputFn = fn.replace(/tokenreplace\-([^\.\/]*)/g, (substr, token) => this._answers[token]);
+
+            // Rename template_gitignore to .gitignore in output
+            if (path.basename(fn) === 'template_gitignore') {
+                outputFn = path.join(path.dirname(fn), '.gitignore');
+            }
+
+            this.fs.copyTpl(
+                path.join(templateRoot, fn),
+                this.destinationPath(outputFn),
+                this._answers
+            );
+        });
+    }
+
+    installingDeps() {
+        this.installDependencies({
+            npm: true,
+            bower: false,
+            callback: () => {
+                this.spawnCommandSync('dotnet', ['restore']);
+                this.spawnCommandSync('./node_modules/.bin/webpack', ['--config', 'webpack.config.vendor.js']);
+                this.spawnCommandSync('./node_modules/.bin/webpack');
+            }
+        });
+    }
+}
+
+declare var module: any;
+(module).exports = MyGenerator;

templates/package-builder/src/yeoman/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "generator-aspnetcore-spa",
+  "version": "0.2.3",
+  "description": "Single-Page App templates for ASP.NET Core",
+  "author": "Microsoft",
+  "license": "Apache-2.0",
+  "files": [
+    "app"
+  ],
+  "keywords": [
+    "yeoman-generator"
+  ],
+  "dependencies": {
+    "glob": "^7.0.3",
+    "node-uuid": "^1.4.7",
+    "to-pascal-case": "^1.0.0",
+    "yeoman-generator": "^0.20.2",
+    "yosay": "^1.1.1"
+  }
+}