.`, where the hash is the SHA of the commit being reverted.
### Type
Must be one of the following:
* **feat**: A new feature
* **fix**: A bug fix
* **docs**: Documentation only changes
* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
semi-colons, etc)
* **refactor**: A code change that neither fixes a bug nor adds a feature
* **perf**: A code change that improves performance
* **test**: Adding missing tests or correcting existing tests
* **build** Changes that affect the build system, CI configuration or external dependencies (example scopes: gulp, broccoli, npm)
* **chore**: Other changes that don't modify `src` or `test` files
### Scope
The scope could be anything specifying place of the commit change. For example
`Compiler`, `ElementInjector`, etc.
### Subject
The subject contains succinct description of the change:
* use the imperative, present tense: "change" not "changed" nor "changes"
* don't capitalize first letter
* no dot (.) at the end
### Body
Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with previous behavior.
### Footer
The footer should contain any information about **Breaking Changes** and is also the place to
reference GitHub issues that this commit **Closes**.
**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
A detailed explanation can be found in this [document][commit-message-format].
##
<%= dasherizedModuleName %> Works!
angular-cli-0.0.34/addon/ng2/blueprints/component/files/__path__/__name__.component.spec.ts 0000664 0000000 0000000 00000002011 12707725453 0031616 0 ustar 00root root 0000000 0000000 import {
beforeEachProviders,
describe,
ddescribe,
expect,
iit,
it,
inject,
injectAsync,
ComponentFixture,
TestComponentBuilder
} from 'angular2/testing';
import {provide} from 'angular2/core';<% if (route) { %>
import {Router, RouteParams} from 'angular2/router';<% } %>
import {<%= classifiedModuleName %>Component} from './<%= dasherizedModuleName %>.component';<% if (route) { %>
class MockRouter {
registerPrimaryOutlet() { }
}
class MockRouteParams {
get() { return 1; }
}<% } %>
describe('<%= classifiedModuleName %> Component', () => {
<% if (route) { %>
beforeEachProviders(() => [
provide(Router, { useClass: MockRouter }),
provide(RouteParams, { useClass: MockRouteParams }),
]);
<% } else { %>
beforeEachProviders((): any[] => []);
<% } %>
it('should ...', injectAsync([TestComponentBuilder], (tcb:TestComponentBuilder) => {
return tcb.createAsync(<%= classifiedModuleName %>Component).then((fixture: ComponentFixture) => {
fixture.detectChanges();
});
}));
});
angular-cli-0.0.34/addon/ng2/blueprints/component/files/__path__/__name__.component.ts 0000664 0000000 0000000 00000001415 12707725453 0030674 0 ustar 00root root 0000000 0000000 import {Component, OnInit} from 'angular2/core';<% if (route) { %>
import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS} from 'angular2/router';<% } %>
@Component({
moduleId: __moduleName,
selector: '<%= dasherizedModuleName %>',<% if(inlineTemplate) { %>
template: `
<%= dasherizedModuleName %> Works!
<% if (route) { %>
>
`
})
class TestComponent {}
describe('<%= classifiedModuleName %> Directive', () => {
beforeEachProviders((): any[] => []);
it('should ...', injectAsync([TestComponentBuilder], (tcb:TestComponentBuilder) => {
return tcb.createAsync(TestComponent).then((fixture: ComponentFixture) => {
fixture.detectChanges();
});
}));
});
angular-cli-0.0.34/addon/ng2/blueprints/directive/files/__path__/__name__.directive.ts 0000664 0000000 0000000 00000000237 12707725453 0030625 0 ustar 00root root 0000000 0000000 import {Directive} from 'angular2/core';
@Directive({
selector: '<%= rawEntityName %>'
})
export class <%= classifiedModuleName %> {
constructor() {}
}
angular-cli-0.0.34/addon/ng2/blueprints/directive/files/__path__/index.ts 0000664 0000000 0000000 00000000124 12707725453 0026236 0 ustar 00root root 0000000 0000000 export {<%= classifiedModuleName %>} from './<%= dasherizedModuleName %>.directive'; angular-cli-0.0.34/addon/ng2/blueprints/directive/index.js 0000664 0000000 0000000 00000003122 12707725453 0023373 0 ustar 00root root 0000000 0000000 var path = require('path');
var Blueprint = require('ember-cli/lib/models/blueprint');
var dynamicPathParser = require('../../utilities/dynamic-path-parser');
var addBarrelRegistration = require('../../utilities/barrel-management');
var getFiles = Blueprint.prototype.files;
module.exports = {
description: '',
availableOptions: [
{ name: 'flat', type: Boolean, default: true }
],
normalizeEntityName: function (entityName) {
var parsedPath = dynamicPathParser(this.project, entityName);
this.dynamicPath = parsedPath;
this.rawEntityName = parsedPath.name;
return parsedPath.name;
},
locals: function (options) {
return {
dynamicPath: this.dynamicPath.dir,
flat: options.flat,
rawEntityName: this.rawEntityName
};
},
files: function() {
var fileList = getFiles.call(this);
if (this.options && this.options.flat) {
fileList = fileList.filter(p => p.indexOf('index.ts') <= 0);
}
return fileList;
},
fileMapTokens: function (options) {
// Return custom template variables here.
return {
__path__: () => {
var dir = this.dynamicPath.dir;
if (!options.locals.flat) {
dir += path.sep + options.dasherizedModuleName;
}
this.generatePath = dir;
return dir;
}
};
},
afterInstall: function(options) {
if (!options.flat) {
return addBarrelRegistration(
this,
this.generatePath);
} else {
return addBarrelRegistration(
this,
this.generatePath,
options.entity.name + '.directive');
}
}
};
angular-cli-0.0.34/addon/ng2/blueprints/ng2/ 0000775 0000000 0000000 00000000000 12707725453 0020440 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/ 0000775 0000000 0000000 00000000000 12707725453 0021542 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/.clang-format 0000664 0000000 0000000 00000000111 12707725453 0024106 0 ustar 00root root 0000000 0000000 Language: JavaScript
BasedOnStyle: Google
ColumnLimit: 100
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/angular-cli-build.js 0000664 0000000 0000000 00000000316 12707725453 0025373 0 ustar 00root root 0000000 0000000 /* global require, module */
var Angular2App = require('angular-cli/lib/broccoli/angular2-app');
module.exports = function(defaults) {
return new Angular2App(defaults, {
vendorNpmFiles: []
});
};
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/angular-cli.json 0000664 0000000 0000000 00000000022 12707725453 0024625 0 ustar 00root root 0000000 0000000 {
"routes": []
} angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/config/ 0000775 0000000 0000000 00000000000 12707725453 0023007 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/config/environment.dev.ts 0000664 0000000 0000000 00000000064 12707725453 0026500 0 ustar 00root root 0000000 0000000 export const environment = {
production: false
};
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/config/environment.js 0000664 0000000 0000000 00000000237 12707725453 0025713 0 ustar 00root root 0000000 0000000 /* jshint node: true */
module.exports = function(environment) {
return {
environment: environment,
baseURL: '/',
locationType: 'auto'
};
};
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/config/environment.prod.ts 0000664 0000000 0000000 00000000063 12707725453 0026665 0 ustar 00root root 0000000 0000000 export const environment = {
production: true
};
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/e2e/ 0000775 0000000 0000000 00000000000 12707725453 0022215 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/e2e/app.e2e.ts 0000664 0000000 0000000 00000000610 12707725453 0024014 0 ustar 00root root 0000000 0000000 import { <%= jsComponentName %>Page } from './app.po';
describe('<%= htmlComponentName %> App', function() {
let page: <%= jsComponentName %>Page;
beforeEach(() => {
page = new <%= jsComponentName %>Page();
})
it('should display message saying app works', () => {
page.navigateTo();
expect(page.getParagraphText()).toEqual('<%= htmlComponentName %> Works!');
});
});
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/e2e/app.po.ts 0000664 0000000 0000000 00000000302 12707725453 0023755 0 ustar 00root root 0000000 0000000 export class <%= jsComponentName %>Page {
navigateTo() {
return browser.get('/');
}
getParagraphText() {
return element(by.css('<%= htmlComponentName %>-app p')).getText();
}
}
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/e2e/tsconfig.json 0000664 0000000 0000000 00000000564 12707725453 0024731 0 ustar 00root root 0000000 0000000 {
"compileOnSave": false,
"compilerOptions": {
"declaration": false,
"emitDecoratorMetadata": true,
"experimentalDecorators": true,
"mapRoot": "",
"module": "commonjs",
"moduleResolution": "node",
"noEmitOnError": true,
"noImplicitAny": false,
"rootDir": ".",
"sourceMap": true,
"sourceRoot": "/",
"target": "es5"
}
}
angular-cli-0.0.34/addon/ng2/blueprints/ng2/files/e2e/typings.d.ts 0000664 0000000 0000000 00000000056 12707725453 0024505 0 ustar 00root root 0000000 0000000 ///
<%= htmlComponentName %> Works!
<%= jsComponentName %>
.
return prefix +
json.replace(/(^\s+template:\s*`)([\s\S\n]*?)(`,?.*$)/m, function(_, prefix, t, suffix) {
return prefix + t + ''
],
run: function(commandOptions, rawArgs:Array) {
var keyword = rawArgs[0];
var docTask = new DocTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
return docTask.run(keyword);
}
});
module.exports = DocCommand; angular-cli-0.0.34/addon/ng2/commands/e2e.js 0000664 0000000 0000000 00000000665 12707725453 0020404 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
var Command = require('ember-cli/lib/models/command');
var E2ETask = require('../tasks/e2e');
module.exports = Command.extend({
name: 'e2e',
description: 'Run e2e tests in existing project',
works: 'insideProject',
run: function () {
var e2eTask = new E2ETask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
return e2eTask.run();
}
});
angular-cli-0.0.34/addon/ng2/commands/easter-egg.ts 0000664 0000000 0000000 00000001735 12707725453 0021765 0 ustar 00root root 0000000 0000000 import * as Command from 'ember-cli/lib/models/command';
import * as Promise from 'ember-cli/lib/ext/promise';
import * as chalk from 'chalk';
function pickOne(of: string[]): string {
return of[Math.floor(Math.random() * of.length)];
}
module.exports = function(name) {
return Command.extend({
name: name,
works: 'insideProject',
run: function (commandOptions, rawArgs): Promise {
var stringUtils = require('ember-cli/lib/utilities/string');
this[stringUtils.camelize(this.name)](commandOptions, rawArgs);
return Promise.resolve();
},
makeThisAwesome: function() {
const phrase = pickOne([
`You're on it, there's nothing for me to do!`,
`Let's take a look... nope, it's all good!`,
`You're doing fine.`,
`You're already doing great.`,
`Nothing to do; already awesome. Exiting.`,
`Error 418: As Awesome As Can Get.`
]);
console.log(chalk.green(phrase));
}
});
};
angular-cli-0.0.34/addon/ng2/commands/format.js 0000664 0000000 0000000 00000000724 12707725453 0021215 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
var Command = require('ember-cli/lib/models/command');
var FormatTask = require('../tasks/format');
module.exports = Command.extend({
name: 'format',
description: 'Formats code in existing project',
works: 'insideProject',
run: function () {
var formatTask =
new FormatTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
return formatTask.run();
}
});
angular-cli-0.0.34/addon/ng2/commands/generate.ts 0000664 0000000 0000000 00000001746 12707725453 0021536 0 ustar 00root root 0000000 0000000 import * as EmberGenerateCommand from 'ember-cli/lib/commands/generate';
import * as fs from 'fs';
import * as path from 'path';
import * as SilentError from 'silent-error';
const GenerateCommand = EmberGenerateCommand.extend({
name: 'generate',
beforeRun: function(rawArgs) {
if (!rawArgs.length) {
return;
}
// map the blueprint name to allow for aliases
rawArgs[0] = mapBlueprintName(rawArgs[0]);
if (!fs.existsSync(path.join(__dirname, '..', 'blueprints', rawArgs[0]))) {
SilentError.debugOrThrow('angular-cli/commands/generate', `Invalid blueprint: ${rawArgs[0]}`);
}
return EmberGenerateCommand.prototype.beforeRun.apply(this, arguments);
}
});
function mapBlueprintName(name) {
let mappedName = aliasMap[name];
return mappedName ? mappedName : name;
}
const aliasMap = {
'c': 'component',
'd': 'directive',
'p': 'pipe',
'r': 'route',
's': 'service'
};
module.exports = GenerateCommand;
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/get.ts 0000664 0000000 0000000 00000001376 12707725453 0020522 0 ustar 00root root 0000000 0000000 import * as chalk from 'chalk';
import * as Command from 'ember-cli/lib/models/command';
import {CliConfig} from '../models/config';
const GetCommand = Command.extend({
name: 'get',
description: 'Set a value in the configuration.',
works: 'outsideProject',
availableOptions: [],
run: function (commandOptions, rawArgs): Promise {
return new Promise(resolve => {
const value = new CliConfig().get(rawArgs[0]);
if (value === null) {
console.error(chalk.red('Value cannot be found.'));
} else if (typeof value == 'object') {
console.log(JSON.stringify(value));
} else {
console.log(value);
}
resolve();
});
}
});
module.exports = GetCommand;
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/github-pages-deploy.ts 0000664 0000000 0000000 00000013272 12707725453 0023612 0 ustar 00root root 0000000 0000000 import * as Command from 'ember-cli/lib/models/command';
import * as SilentError from 'silent-error';
import { exec } from 'child_process';
import * as Promise from 'ember-cli/lib/ext/promise';
import * as chalk from 'chalk';
import * as fs from 'fs';
import * as fse from 'fs-extra';
import * as path from 'path';
import * as BuildTask from 'ember-cli/lib/tasks/build';
import * as win from 'ember-cli/lib/utilities/windows-admin';
import * as CreateGithubRepo from '../tasks/create-github-repo';
const fsReadFile = Promise.denodeify(fs.readFile);
const fsWriteFile = Promise.denodeify(fs.writeFile);
const fsReadDir = Promise.denodeify(fs.readdir);
const fsCopy = Promise.denodeify(fse.copy);
module.exports = Command.extend({
name: 'github-pages:deploy',
aliases: ['gh-pages:deploy'],
description: 'Build the test app for production, commit it into a git branch, setup GitHub repo and push to it',
works: 'insideProject',
availableOptions: [
{
name: 'message',
type: String,
default: 'new gh-pages version',
description: 'The commit message to include with the build, must be wrapped in quotes.'
}, {
name: 'environment',
type: String,
default: 'production',
description: 'The Angular environment to create a build for'
}, {
name: 'branch',
type: String,
default: 'gh-pages',
description: 'The git branch to push your pages to'
}, {
name: 'skip-build',
type: Boolean,
default: false,
description: 'Skip building the project before deploying'
}, {
name: 'gh-token',
type: String,
default: '',
description: 'Github token'
}, {
name: 'gh-username',
type: String,
default: '',
description: 'Github username'
}],
run: function(options, rawArgs) {
var ui = this.ui;
var root = this.project.root;
var execOptions = {
cwd: root
};
var projectName = this.project.pkg.name;
let initialBranch;
// declared here so that tests can stub exec
const execPromise = Promise.denodeify(exec);
var buildTask = new BuildTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
var buildOptions = {
environment: options.environment,
outputPath: 'dist/'
};
var createGithubRepoTask = new CreateGithubRepo({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
var createGithubRepoOptions = {
projectName,
ghUsername: options.ghUsername,
ghToken: options.ghToken
};
return checkForPendingChanges()
.then(build)
.then(saveStartingBranchName)
.then(createGitHubRepoIfNeeded)
.then(checkoutGhPages)
.then(copyFiles)
.then(updateBaseHref)
.then(addAndCommit)
.then(returnStartingBranch)
.then(pushToGitRepo)
.then(printProjectUrl);
function checkForPendingChanges() {
return execPromise('git status --porcelain')
.then(stdout => {
if (/\w+/m.test(stdout)) {
let msg = 'Uncommitted file changes found! Please commit all changes before deploying.';
return Promise.reject(new SilentError(msg));
}
});
}
function build() {
if (options.skipBuild) return Promise.resolve();
return win.checkWindowsElevation(ui)
.then(() => buildTask.run(buildOptions));
}
function saveStartingBranchName() {
return execPromise('git rev-parse --abbrev-ref HEAD')
.then((stdout) => initialBranch = stdout);
}
function createGitHubRepoIfNeeded() {
return execPromise('git remote -v')
.then(function(stdout) {
if (!/origin\s+(https:\/\/|git@)github\.com/m.test(stdout)) {
return createGithubRepoTask.run(createGithubRepoOptions);
}
});
}
function checkoutGhPages() {
return execPromise(`git checkout ${options.branch}`)
.catch(createGhPagesBranch)
}
function createGhPagesBranch() {
return execPromise(`git checkout --orphan ${options.branch}`)
.then(() => execPromise('git rm --cached -r .', execOptions))
.then(() => execPromise('git add .gitignore', execOptions))
.then(() => execPromise('git clean -f -d', execOptions))
.then(() => execPromise(`git commit -m \"initial ${options.branch} commit\"`));
}
function copyFiles() {
return fsReadDir('dist')
.then((files) => Promise.all(files.map((file) => fsCopy(path.join('dist', file), path.join('.', file)))))
}
function updateBaseHref() {
let indexHtml = path.join(root, 'index.html');
return fsReadFile(indexHtml, 'utf8')
.then((data) => data.replace(/'],
_defaultBlueprint: function () {
if (this.project.isEmberCLIAddon()) {
return 'addon';
} else {
return 'ng2';
}
},
run: function (commandOptions, rawArgs) {
if (commandOptions.dryRun) {
commandOptions.skipNpm = true;
commandOptions.skipBower = true;
}
var installBlueprint = new this.tasks.InstallBlueprint({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
// needs an explicit check in case it's just 'undefined'
// due to passing of options from 'new' and 'addon'
if (commandOptions.skipGit === false) {
var gitInit = new GitInit({
ui: this.ui,
project: this.project
});
}
if (!commandOptions.skipNpm) {
var npmInstall = new this.tasks.NpmInstall({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
}
if (!commandOptions.skipBower) {
var bowerInstall = new this.tasks.BowerInstall({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
}
var project = this.project;
var packageName = commandOptions.name !== '.' && commandOptions.name || project.name();
if (!packageName) {
var message = 'The `ng ' + this.name + '` command requires a ' +
'package.json in current folder with name attribute or a specified name via arguments. ' +
'For more details, use `ng help`.';
return Promise.reject(new SilentError(message));
}
var blueprintOpts = {
dryRun: commandOptions.dryRun,
blueprint: commandOptions.blueprint || this._defaultBlueprint(),
rawName: packageName,
targetFiles: rawArgs || '',
rawArgs: rawArgs.toString()
};
if (!validProjectName(packageName)) {
return Promise.reject(
new SilentError('We currently do not support a name of `' + packageName + '`.'));
}
blueprintOpts.blueprint = normalizeBlueprint(blueprintOpts.blueprint);
return installBlueprint.run(blueprintOpts)
.then(function () {
if (commandOptions.skipGit === false) {
return gitInit.run(commandOptions, rawArgs);
}
}.bind(this))
.then(function () {
if (!commandOptions.skipNpm) {
return npmInstall.run({
verbose: commandOptions.verbose,
optional: false
});
}
})
.then(function () {
if (!commandOptions.skipBower) {
return bowerInstall.run({
verbose: commandOptions.verbose
});
}
});
}
});
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/lint.ts 0000664 0000000 0000000 00000000625 12707725453 0020705 0 ustar 00root root 0000000 0000000 import * as Command from 'ember-cli/lib/models/command';
import * as LintTask from '../tasks/lint';
module.exports = Command.extend({
name: 'lint',
description: 'Lints code in existing project',
works: 'insideProject',
run: function () {
var lintTask = new LintTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
return lintTask.run();
}
});
angular-cli-0.0.34/addon/ng2/commands/new.ts 0000664 0000000 0000000 00000005114 12707725453 0020526 0 ustar 00root root 0000000 0000000 import * as chalk from 'chalk';
import * as Command from 'ember-cli/lib/models/command';
import * as Project from 'ember-cli/lib/models/project';
import * as SilentError from 'silent-error';
import * as validProjectName from 'ember-cli/lib/utilities/valid-project-name';
const normalizeBlueprint = require('ember-cli/lib/utilities/normalize-blueprint-option');
const InitCommand = require('./init');
const NewCommand = Command.extend({
name: 'new',
description: `Creates a new directory and runs ${chalk.green('ng init')} in it.`,
works: 'outsideProject',
availableOptions: [
{ name: 'dry-run', type: Boolean, default: false, aliases: ['d'] },
{ name: 'verbose', type: Boolean, default: false, aliases: ['v'] },
{ name: 'blueprint', type: String, default: 'ng2', aliases: ['b'] },
{ name: 'skip-npm', type: Boolean, default: false, aliases: ['sn'] },
{ name: 'skip-bower', type: Boolean, default: true, aliases: ['sb'] },
{ name: 'skip-git', type: Boolean, default: false, aliases: ['sg'] },
{ name: 'directory', type: String, aliases: ['dir'] },
],
run: function (commandOptions, rawArgs) {
const packageName = rawArgs.shift();
if (!packageName) {
return Promise.reject(new SilentError(
`The "ng ${this.name}" command requires a name argument to be specified. ` +
`For more details, use "ng help".`));
}
commandOptions.name = packageName;
if (commandOptions.dryRun) {
commandOptions.skipGit = true;
}
if (packageName === '.') {
return Promise.reject(new SilentError(
`Trying to generate an application structure in this directory? Use "ng init" ` +
`instead.`));
}
if (!validProjectName(packageName)) {
return Promise.reject(
new SilentError(`We currently do not support a name of "${packageName}".`));
}
commandOptions.blueprint = normalizeBlueprint(commandOptions.blueprint);
if (!commandOptions.directory) {
commandOptions.directory = packageName;
}
const createAndStepIntoDirectory =
new this.tasks.CreateAndStepIntoDirectory({ ui: this.ui, analytics: this.analytics });
const initCommand = new InitCommand({
ui: this.ui,
analytics: this.analytics,
tasks: this.tasks,
project: Project.nullProject(this.ui, this.cli)
});
return createAndStepIntoDirectory
.run({
directoryName: commandOptions.directory,
dryRun: commandOptions.dryRun
})
.then(initCommand.run.bind(initCommand, commandOptions, rawArgs));
}
});
module.exports = NewCommand;
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/set.ts 0000664 0000000 0000000 00000001212 12707725453 0020523 0 ustar 00root root 0000000 0000000 import * as Command from 'ember-cli/lib/models/command';
import {CliConfig} from '../models/config';
const SetCommand = Command.extend({
name: 'set',
description: 'Set a value in the configuration.',
works: 'outsideProject',
availableOptions: [
{ name: 'global', type: Boolean, default: false, aliases: ['g'] },
],
run: function (commandOptions, rawArgs): Promise {
return new Promise(resolve => {
const config = new CliConfig();
config.set(rawArgs[0], rawArgs[1], commandOptions.force);
config.save();
resolve();
});
}
});
module.exports = SetCommand;
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/test.js 0000664 0000000 0000000 00000003763 12707725453 0020712 0 ustar 00root root 0000000 0000000 'use strict';
var Promise = require('ember-cli/lib/ext/promise');
var TestCommand = require('ember-cli/lib/commands/test');
var win = require('ember-cli/lib/utilities/windows-admin');
var BuildTask = require('ember-cli/lib/tasks/build');
var BuildWatchTask = require('ember-cli/lib/tasks/build-watch');
var TestTask = require('../tasks/test');
module.exports = TestCommand.extend({
availableOptions: [
{ name: 'watch', type: Boolean, default: true, aliases: ['w'] },
{ name: 'browsers', type: String },
{ name: 'colors', type: Boolean },
{ name: 'log-level', type: String },
{ name: 'port', type: Number },
{ name: 'reporters', type: String }
],
run: function (commandOptions) {
var buildWatchTask =
new BuildWatchTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
var buildTask = new BuildTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
var testTask = new TestTask({
ui: this.ui,
analytics: this.analytics,
project: this.project
});
var buildOptions = {
environment: 'development',
outputPath: 'dist/'
};
if (commandOptions.watch) {
return win.checkWindowsElevation(this.ui)
.then(
() => {
// perform initial build to avoid race condition
return buildTask.run(buildOptions);
},
() => {
/* handle build error to allow watch mode to start */
})
.then(() => {
return Promise.all([buildWatchTask.run(buildOptions), testTask.run(commandOptions)]);
});
} else {
// if not watching ensure karma is doing a single run
commandOptions.singleRun = true;
return win.checkWindowsElevation(this.ui)
.then(() => {
return buildTask.run(buildOptions);
})
.then(() => {
return testTask.run(commandOptions);
});
}
}
});
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/commands/version.ts 0000664 0000000 0000000 00000002617 12707725453 0021427 0 ustar 00root root 0000000 0000000 import * as Command from 'ember-cli/lib/models/command';
import * as path from 'path';
import * as child_process from 'child_process';
const VersionCommand = Command.extend({
name: 'version',
description: 'outputs angular-cli version',
aliases: ['v', '--version', '-v'],
works: 'everywhere',
availableOptions: [{
name: 'verbose',
type: Boolean, 'default': false
}],
run: function (options) {
var versions = process.versions;
var pkg = require(path.resolve(__dirname, '..', '..', '..', 'package.json'));
versions['os'] = process.platform + ' ' + process.arch;
var alwaysPrint = ['node', 'os'];
var ngCliVersion = pkg.version;
if (!__dirname.match(/node_modules/)) {
var gitBranch = '??';
try {
var gitRefName = '' + child_process.execSync('git symbolic-ref HEAD', {cwd: __dirname});
gitBranch = path.basename(gitRefName.replace('\n', ''));
} catch (e) {
}
ngCliVersion = `local (v${pkg.version}, branch: ${gitBranch})`;
}
this.printVersion('angular-cli', ngCliVersion);
for (var module in versions) {
if (options.verbose || alwaysPrint.indexOf(module) > -1) {
this.printVersion(module, versions[module]);
}
}
},
printVersion: function (module, version) {
this.ui.writeLine(module + ': ' + version);
}
});
module.exports = VersionCommand;
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/index.js 0000664 0000000 0000000 00000001533 12707725453 0017232 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
module.exports = {
name: 'ng2',
includedCommands: function () {
return {
'new': require('./commands/new'),
'generate': require('./commands/generate'),
'init': require('./commands/init'),
'test': require('./commands/test'),
'e2e': require('./commands/e2e'),
'lint': require('./commands/lint'),
'format': require('./commands/format'),
'version': require('./commands/version'),
'completion': require('./commands/completion'),
'doc': require('./commands/doc'),
'github-pages-deploy': require('./commands/github-pages-deploy'),
// Easter eggs.
'make-this-awesome': require('./commands/easter-egg')('make-this-awesome'),
// Configuration.
'set': require('./commands/set'),
'get': require('./commands/get')
};
}
};
angular-cli-0.0.34/addon/ng2/models/ 0000775 0000000 0000000 00000000000 12707725453 0017046 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/models/config.ts 0000664 0000000 0000000 00000006222 12707725453 0020665 0 ustar 00root root 0000000 0000000 import * as fs from 'fs';
import * as path from 'path';
export const CLI_CONFIG_FILE_NAME = 'angular-cli.json';
export interface CliConfigJson {
routes?: { [name: string]: any },
packages?: { [name: string]: any }
}
function _findUp(name: string, from: string) {
let currentDir = from;
while (currentDir && currentDir != '/') {
const p = path.join(currentDir, name);
if (fs.existsSync(p)) {
return p;
}
currentDir = path.resolve(currentDir, '..');
}
return null;
}
export class CliConfig {
constructor(private _config: CliConfigJson = CliConfig.fromProject()) {}
save(path: string = CliConfig.configFilePath()) {
if (!path) {
throw new Error('Could not find config path.');
}
fs.writeFileSync(path, JSON.stringify(this._config, null, 2), { encoding: 'utf-8' });
}
set(jsonPath: string, value: any, force: boolean = false): boolean {
let { parent, name, remaining } = this._findParent(jsonPath);
while (force && remaining) {
if (remaining.indexOf('.') != -1) {
// Create an empty map.
// TODO: create the object / array based on the Schema of the configuration.
parent[name] = {};
}
}
parent[name] = value;
return true;
}
get(jsonPath: string): any {
let { parent, name, remaining } = this._findParent(jsonPath);
if (remaining || !(name in parent)) {
return null;
} else {
return parent[name];
}
}
private _validatePath(jsonPath: string) {
if (!jsonPath.match(/^(?:[-_\w\d]+(?:\[\d+\])*\.)*(?:[-_\w\d]+(?:\[\d+\])*)$/)) {
throw `Invalid JSON path: "${jsonPath}"`;
}
}
private _findParent(jsonPath: string): { parent: any, name: string | number, remaining?: string } {
this._validatePath(jsonPath);
let parent: any = null;
let current: any = this._config;
const splitPath = jsonPath.split('.');
let name: string | number = '';
while (splitPath.length > 0) {
const m = splitPath.shift().match(/^(.*?)(?:\[(\d+)\])*$/);
name = m[1];
const index: string = m[2];
parent = current;
current = current[name];
if (current === null || current === undefined) {
return {
parent,
name,
remaining: (!isNaN(index) ? `[${index}]` : '') + splitPath.join('.')
};
}
if (!isNaN(index)) {
name = index;
parent = current;
current = current[index];
if (current === null || current === undefined) {
return {
parent,
name,
remaining: splitPath.join('.')
};
}
}
}
return { parent, name };
}
static configFilePath(projectPath?: string): string {
// Find the configuration, either where specified, in the angular-cli project
// (if it's in node_modules) or from the current process.
return (projectPath && _findUp(CLI_CONFIG_FILE_NAME, projectPath))
|| _findUp(CLI_CONFIG_FILE_NAME, __dirname)
|| _findUp(CLI_CONFIG_FILE_NAME, process.cwd());
}
static fromProject(): CliConfigJson {
const configPath = this.configFilePath();
return configPath ? require(configPath) : {};
}
}
angular-cli-0.0.34/addon/ng2/package.json 0000664 0000000 0000000 00000000266 12707725453 0020055 0 ustar 00root root 0000000 0000000 {
"name": "ng2",
"version": "0.0.0",
"description": "An addon to generate an ng2 project",
"author": "rodyhaddad",
"license": "MIT",
"keywords": [
"ember-addon"
]
} angular-cli-0.0.34/addon/ng2/tasks/ 0000775 0000000 0000000 00000000000 12707725453 0016710 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/tasks/create-github-repo.ts 0000664 0000000 0000000 00000005171 12707725453 0022752 0 ustar 00root root 0000000 0000000 import * as Promise from 'ember-cli/lib/ext/promise';
import * as Task from 'ember-cli/lib/models/task';
import * as SilentError from 'silent-error';
import { exec } from 'child_process';
import * as https from 'https';
module.exports = Task.extend({
run: function(commandOptions) {
var ui = this.ui;
let promise;
// declared here so that tests can stub exec
const execPromise = Promise.denodeify(exec);
if (/.+/.test(commandOptions.ghToken) && /\w+/.test(commandOptions.ghUsername)) {
promise = Promise.resolve({
ghToken: commandOptions.ghToken,
ghUsername: commandOptions.ghUsername
});
} else {
ui.writeLine("\nIn order to deploy this project via GitHub Pages, we must first create a repository for it.");
ui.writeLine("It's safer to use a token than to use a password, so you will need to create one.\n");
ui.writeLine("Go to the following page and click 'Generate new token'.");
ui.writeLine("https://github.com/settings/tokens\n");
ui.writeLine("Choose 'public_repo' as scope and then click 'Generate token'.\n");
promise = ui.prompt([
{
name: 'ghToken',
type: 'input',
message: 'Please enter GitHub token you just created (used only once to create the repo):',
validate: function(token) {
return /.+/.test(token);
}
}, {
name: 'ghUsername',
type: 'input',
message: 'and your GitHub user name:',
validate: function(userName) {
return /\w+/.test(userName);
}
}]);
}
return promise
.then((answers) => {
return new Promise(function(resolve, reject) {
var postData = JSON.stringify({
'name': commandOptions.projectName
});
var req = https.request({
hostname: 'api.github.com',
port: 443,
path: '/user/repos',
method: 'POST',
headers: {
'Authorization': `token ${answers.ghToken}`,
'Content-Type': 'application/json',
'Content-Length': postData.length,
'User-Agent': 'angular-cli-github-pages'
}
});
req.on('response', function(response) {
if (response.statusCode === 201) {
resolve(execPromise(`git remote add origin git@github.com:${answers.ghUsername}/${commandOptions.projectName}.git`))
} else {
reject(new SilentError(`Failed to create GitHub repo. Error: ${response.statusCode} ${response.statusMessage}`));
}
});
req.write(postData);
req.end();
});
});
}
});
angular-cli-0.0.34/addon/ng2/tasks/doc.ts 0000664 0000000 0000000 00000000465 12707725453 0020032 0 ustar 00root root 0000000 0000000 import * as Task from 'ember-cli/lib/models/task';
import * as opn from 'opn';
const DocTask = Task.extend({
run: function(keyword: string) {
var searchUrl = `https://angular.io/docs/ts/latest/api/#!?apiFilter=${keyword}`;
return opn(searchUrl, { wait: false });
}
});
module.exports = DocTask; angular-cli-0.0.34/addon/ng2/tasks/e2e.js 0000664 0000000 0000000 00000000440 12707725453 0017717 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
var Promise = require('ember-cli/lib/ext/promise');
var Task = require('ember-cli/lib/models/task');
var exec = Promise.denodeify(require('shelljs').exec);
module.exports = Task.extend({
run: function () {
return exec('npm run e2e');
}
});
angular-cli-0.0.34/addon/ng2/tasks/format.js 0000664 0000000 0000000 00000001174 12707725453 0020541 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
var Promise = require('ember-cli/lib/ext/promise');
var Task = require('ember-cli/lib/models/task');
var exec = Promise.denodeify(require('child_process').exec);
module.exports = Task.extend({
run: function () {
var chalk = require('chalk');
var ui = this.ui;
return exec('npm run format')
.then(function () {
ui.writeLine(chalk.green('Successfully formatted files.'));
})
.catch(function (/*error*/) {
ui.writeLine(chalk.red(
'Couldn\'t do \'npm run format\'. Please check this script exists in your package.json.'));
});
}
});
angular-cli-0.0.34/addon/ng2/tasks/git-init.js 0000664 0000000 0000000 00000003125 12707725453 0020773 0 ustar 00root root 0000000 0000000 'use strict';
var Promise = require('ember-cli/lib/ext/promise');
var exec = Promise.denodeify(require('child_process').exec);
var path = require('path');
var pkg = require('../package.json');
var fs = require('fs');
var template = require('lodash/template');
var Task = require('ember-cli/lib/models/task');
var gitEnvironmentVariables = {
GIT_AUTHOR_NAME: 'angular-cli',
GIT_AUTHOR_EMAIL: 'angular-cli@angular.io',
get GIT_COMMITTER_NAME() {
return this.GIT_AUTHOR_NAME;
},
get GIT_COMMITTER_EMAIL() {
return this.GIT_AUTHOR_EMAIL;
}
};
module.exports = Task.extend({
run: function (commandOptions) {
var chalk = require('chalk');
var ui = this.ui;
if (commandOptions.skipGit) {
return Promise.resolve();
}
return exec('git --version')
.then(function () {
return exec('git init')
.then(function () {
return exec('git add .');
})
.then(function () {
var commitTemplate = fs.readFileSync(
path.join(__dirname, '../utilities/INITIAL_COMMIT_MESSAGE.txt'));
var commitMessage = template(commitTemplate)(pkg);
return exec(
'git commit -m "' + commitMessage + '"', { env: gitEnvironmentVariables });
})
.then(function () {
ui.writeLine(chalk.green('Successfully initialized git.'));
});
})
.catch(function (/*error*/) {
// if git is not found or an error was thrown during the `git`
// init process just swallow any errors here
});
}
});
module.exports.overrideCore = true;
angular-cli-0.0.34/addon/ng2/tasks/lint.ts 0000664 0000000 0000000 00000001130 12707725453 0020221 0 ustar 00root root 0000000 0000000 import * as Promise from 'ember-cli/lib/ext/promise';
import * as Task from 'ember-cli/lib/models/task';
import * as chalk from 'chalk';
import {exec} from 'child_process';
module.exports = Task.extend({
run: function () {
var ui = this.ui;
return new Promise(function(resolve) {
exec('npm run lint', (err, stdout) => {
ui.writeLine(stdout);
if (err) {
ui.writeLine(chalk.red('Lint errors found in the listed files.'));
} else {
ui.writeLine(chalk.green('All files pass linting.'));
}
resolve();
});
});
}
});
angular-cli-0.0.34/addon/ng2/tasks/test.js 0000664 0000000 0000000 00000002010 12707725453 0020216 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
var Promise = require('ember-cli/lib/ext/promise');
var Task = require('ember-cli/lib/models/task');
var path = require('path');
// require dependencies within the target project
function requireDependency(root, moduleName) {
var packageJson = require(path.join(root, 'node_modules', moduleName, 'package.json'));
var main = path.normalize(packageJson.main);
return require(path.join(root, 'node_modules', moduleName, main));
}
module.exports = Task.extend({
run: function (options) {
var projectRoot = this.project.root;
return new Promise(function (resolve) {
var karma = requireDependency(projectRoot, 'karma');
var karmaConfig = path.join(projectRoot, 'karma.conf');
// Convert browsers from a string to an array
if (options.browsers) {
options.browsers = options.browsers.split(',');
}
options.configFile = karmaConfig;
var karmaServer = new karma.Server(options, resolve);
karmaServer.start();
});
}
});
angular-cli-0.0.34/addon/ng2/utilities/ 0000775 0000000 0000000 00000000000 12707725453 0017576 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/addon/ng2/utilities/INITIAL_COMMIT_MESSAGE.txt 0000664 0000000 0000000 00000000571 12707725453 0023647 0 ustar 00root root 0000000 0000000 chore: initial commit from angular-cli
_ _ _
__ _ _ __ __ _ _ _| | __ _ _ __ ___| (_)
/ _ | _ \ / _ | | | | |/ _ | __|____ / __| | |
| (_| | | | | (_| | |_| | | (_| | | |_____| (__| | |
\____|_| |_|\__ |\____|_|\____|_| \___|_|_|
|___/
angular-cli-0.0.34/addon/ng2/utilities/barrel-management.js 0000664 0000000 0000000 00000001232 12707725453 0023513 0 ustar 00root root 0000000 0000000 var path = require('path');
var EOL = require('os').EOL;
module.exports = addBarrelRegistration;
function addBarrelRegistration(blueprint, installationDir, fileName) {
var parts = installationDir.split(path.sep);
var idx = parts.lastIndexOf('shared');
if (idx < parts.length -2) {
return Promise.resolve();
}
var sharedDir = parts.slice(0, idx + 1).join(path.sep);
var relativeParts = parts.splice(idx + 1);
if (fileName) {
relativeParts.push(fileName);
}
var importFrom = './' + relativeParts.join('/');
return blueprint.insertIntoFile(
sharedDir + path.sep + 'index.ts',
`export * from '${importFrom}';${EOL}`
);
}
angular-cli-0.0.34/addon/ng2/utilities/completion.sh 0000664 0000000 0000000 00000003461 12707725453 0022307 0 ustar 00root root 0000000 0000000 ###-begin-ng-completion###
#
# ng command completion script
#
# Installation: ng completion >> ~/.bashrc (or ~/.zshrc)
#
ng_opts='new init build serve generate autocomplete e2e format lint test version'
init_opts='--dry-run --verbose --blueprint --skip-npm --skip-bower --name'
new_opts='--dry-run --verbose --blueprint --skip-npm --skip-bower --skip-git --directory'
build_opts='--environment --output-path --watch --watcher'
serve_opts='--port --host --proxy --insecure-proxy --watcher --live-reload --live-reload-host
--live-reload-port --environment --output-path --ssl --ssl-key --ssl-cert'
generate_opts='component directive pipe route service'
test_opts='--watch --browsers --colors --log-level --port --reporters'
if type complete &>/dev/null; then
_ng_completion() {
local cword pword opts
COMPREPLY=()
cword=${COMP_WORDS[COMP_CWORD]}
pword=${COMP_WORDS[COMP_CWORD - 1]}
case ${pword} in
ng) opts=$ng_opts ;;
i|init) opts=$init_opts ;;
new) opts=$new_opts ;;
b|build) opts=$build_opts ;;
s|serve|server) opts=$serve_opts ;;
g|generate) opts=$generate_opts ;;
test) opts=$test_opts ;;
esac
COMPREPLY=( $(compgen -W '${opts}' -- $cword) )
return 0
}
complete -o default -F _ng_completion ng
elif type compctl &>/dev/null; then
_ng_completion () {
local words cword opts
read -Ac words
read -cn cword
let cword-=1
case $words[cword] in
ng) opts=$ng_opts ;;
i|init) opts=$init_opts ;;
new) opts=$new_opts ;;
b|build) opts=$build_opts ;;
s|serve|server) opts=$serve_opts ;;
g|generate) opts=$generate_opts ;;
test) opts=$test_opts ;;
esac
setopt shwordsplit
reply=($opts)
unset shwordsplit
}
compctl -K _ng_completion ng
fi
###-end-ng-completion### angular-cli-0.0.34/addon/ng2/utilities/dynamic-path-parser.js 0000664 0000000 0000000 00000004543 12707725453 0024012 0 ustar 00root root 0000000 0000000 var path = require('path');
var process = require('process');
var fs = require('fs');
module.exports = function dynamicPathParser(project, entityName) {
var projectRoot = project.root;
var appRoot = path.join('src', 'client', 'app');
var cwd = process.env.PWD;
var rootPath = path.join(projectRoot, appRoot);
var outputPath = path.join(rootPath, entityName);
if (entityName.indexOf(path.sep) === 0) {
outputPath = path.join(rootPath, entityName.substr(1));
} else if (cwd.indexOf(rootPath) >= 0) {
outputPath = path.join(cwd, entityName);
} else if (cwd.indexOf(path.join(projectRoot, 'src', 'client')) >= 0) {
if (entityName.indexOf('app') === 0) {
outputPath = path.join(cwd, entityName);
} else {
outputPath = path.join(cwd, 'app', entityName);
}
} else if (cwd.indexOf(path.join(projectRoot, 'src')) >= 0) {
if (entityName.indexOf(path.join('client', 'app')) === 0) {
outputPath = path.join(cwd, entityName);
} else if (entityName.indexOf('client') === 0) {
outputPath = path.join(cwd, 'app', entityName);
} else {
outputPath = path.join(cwd, 'client', 'app', entityName);
}
}
if (!fs.existsSync(outputPath)) {
// Verify the path exists on disk.
var parsedOutputPath = path.parse(outputPath);
var parts = parsedOutputPath.dir.split(path.sep).slice(1);
var newPath = parts.reduce((tempPath, part) => {
// if (tempPath === '') {
// return part;
// }
var withoutPlus = path.join(tempPath, path.sep, part);
var withPlus = path.join(tempPath, path.sep, '+' + part);
if (fs.existsSync(withoutPlus)) {
return withoutPlus;
} else if (fs.existsSync(withPlus)) {
return withPlus;
}
throw `Invalid path: "${withoutPlus}"" is not a valid path.`
}, parsedOutputPath.root);
outputPath = path.join(newPath, parsedOutputPath.name);
}
if (outputPath.indexOf(rootPath) < 0) {
throw `Invalid path: "${entityName}" cannot be ` +
`above the "${appRoot}" directory`;
}
var adjustedPath = outputPath.replace(projectRoot, '');
var parsedPath = path.parse(adjustedPath);
if (parsedPath.dir.indexOf(path.sep) === 0) {
parsedPath.dir = parsedPath.dir.substr(1);
}
parsedPath.dir = parsedPath.dir === path.sep ? '' : parsedPath.dir;
parsedPath.appRoot = appRoot
return parsedPath;
}; angular-cli-0.0.34/bin/ 0000775 0000000 0000000 00000000000 12707725453 0014560 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/bin/ng 0000775 0000000 0000000 00000002736 12707725453 0015122 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
'use strict';
// Provide a title to the process in `ps`
process.title = 'angular-cli';
const resolve = require('resolve');
const exit = require('exit');
const packageJson = require('../package.json');
const Leek = require('leek');
resolve('angular-cli', { basedir: process.cwd() },
function (error, projectLocalCli) {
var cli;
if (error) {
// If there is an error, resolve could not find the ember-cli
// library from a package.json. Instead, include it from a relative
// path to this script file (which is likely a globally installed
// npm package). Most common cause for hitting this is `ember new`
cli = require('../lib/cli');
} else {
// No error implies a projectLocalCli, which will load whatever
// version of ember-cli you have installed in a local package.json
cli = require(projectLocalCli);
}
if ('default' in cli) {
cli = cli['default'];
}
cli({
cliArgs: process.argv.slice(2),
inputStream: process.stdin,
outputStream: process.stdout,
Leek: CustomLeek
}).then(function (result) {
var exitCode = typeof result === 'object' ? result.exitCode : result;
exit(exitCode);
});
function CustomLeek(options) {
options.trackingCode = packageJson.trackingCode;
options.globalName = packageJson.name;
options.name = packageJson.name;
options.version = packageJson.version;
return new Leek(options);
}
});
angular-cli-0.0.34/docs/ 0000775 0000000 0000000 00000000000 12707725453 0014740 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/docs/design/ 0000775 0000000 0000000 00000000000 12707725453 0016211 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/docs/design/ngConfig.md 0000664 0000000 0000000 00000012636 12707725453 0020275 0 ustar 00root root 0000000 0000000 # ngConfig - Design
## Goals
Currently, a project scaffolded with the CLI have no way of specifying options and configurations affecting their projects. There are ways to affect the build (with the `angular-cli-build.js` file), but the following questions cannot be answered without actual project options:
* Where in my directory is my karma.conf file?
* What is my firebase database URL?
* Where is my client code?
* How can I use a different lazy-loading boundary prefix (or none at all)?
* Any other backend I want to run prior to `ng serve`?
# Proposed Solution
Since the data is static, we only need to keep it in a static store somewhere.
One solution would be to keep the data in the `package.json`. Unfortunately, the metadata contains too much data and the `package.json` file would become unmanageable.
Instead of polluting the package file, a `angular-cli.json` file will be created that contains all the values. Access to that file will be allowed to the user if he knows the structure of the file (unknown keys will be kept but ignored), and it's easy to read and write. We can also keep the file formatted.
## Fallback
There should be two `angular-cli.json` files; one for the project and a general one. The general one should contain information that can be useful when scaffolding new apps, or informations about the user.
The project `angular-cli.json` goes into the project root. The global configuration should live at `$HOME/.angular-cli.json`.
## Structure
The structure should be defined by a JSON schema (see [here](http://json-schema.org/)). The schema will be used to generate the `d.ts`, but that file will be kept in the file system along the schema for IDEs.
Every PR that would change the schema should include the update to the `d.ts`.
# API
## CLI
#### Getting values
The new command `get` should be used to output values on the terminal. It takes a set of flags and an optional array of [paths](#path);
* `--glob` or `-g`; the path follows a glob format, where `*` can be replaced by any amount of characters and `?` by a single character. This will output `name=value` for each values matched.
Otherwise, outputs the value of the path passed in. If multiple paths are passed in, they follow the format of `name=value`.
#### Setting values
The new command `set` should be used to set values in the local configuration file. It takes a set of flags and an optional array of `[path](#path)=value`;
* `--global`; sets the value in the global configuration.
* `--remove`; removes the key (no value should be passed in).
The schema needs to be taken into account when setting the value of the field;
* If the field is a number, the string received from the command line is parsed. `NaN` throws an error.
* If the field is an object, an error is thrown.
* If the path is inside an object but the object hasn't been defined yet, sets the object with empty values (use the schema to create a valid object).
#### PathappData
The `angular-cli` key in the generated app should be used for `angular-cli` specific data.
This includes the CLI configuration itself, as well as third-parties library configuration.
Third-parties can store data that will be passed to the app, and can use that data themselves.
That data can be anything. Any keys starting with either `$` or `_` will be ignored and not
passed to the client. It could be used for builds or scaffolding information.
During installation, there's a step to prompt the user for data. The schema contains a prompt
text and a default value. The default value type is used to convert the string entered by the
user. The key used in `appPrompt` is the key saved in appData.
Example:
```typescript
{ // ...
"angular-cli": {
"appPrompt": {
"number": {
"prompt": "Please enter a number:",
"defaultValue": 0
},
"url": {
"prompt": "URL of your website:",
"defaultValue": "${homepage}"
},
}
}
}
```
The default value is necessary as a `quiet` mode is enforced, using default values to fill
in the data without user interaction. The special strings `${...}` can be used to replace
with special values in the default string values. The values are taken from the `package.json`.
We use a declarative style to enforce sensible defaults and make sure developers think about
this. *In the case where developers want more complex interaction, they can use the
install/uninstall hooks to prompt users.* But 3rd party libraries developers need to be aware
that those hooks might not prompt users (no STDIN) and throw an error.
# Providers
Adding Angular providers to the app should be seamless. The install process will create a
`providers.js` from all the providers contained in all the dependencies. The User can blacklist
providers it doesn't want.
The `providers.js` file will always be overwritten by the `install` / `uninstall` process. It
needs to exist for toolings to be able to understand dependencies. These providers are global
to the application.
In order to blacklist providers from being global, the user can use the `--no-global-providers`
flag during installation, or can change the dependencies by using `ng providers`. As an example:
```bash
ng new my-todo-app
ng generate component database
ng install --no-global-providers angularfirebase2
ng providers database angularfirebase2
```
Or, alternatively, the user can add its own providers and dependencies to its components.
# Dependencies
Because dependencies are handled by `npm`, we don't have to handle it.
# Typings
Typings should be added, but failure to find typings should not be a failure of installation. The
user might still want to install custom typings himself in the worst case.
The `typings` package can be used to install/verify that typings exist. If the typings do not exist natively, we should tell the user to install the ambient version if he wants to.
# Index.html
We do not touch the `index.html` file during the installation task. The default page should
link to a SystemJS configuration file that is auto generated by the CLI and not user
configurable (see SystemJS below). If the user install a third party library, like jQuery, and
wants to use it, they have to import it using `import * as $ from 'vendor/jquery'`.
The `index.html` also includes a section to configure SystemJS that can be managed by the user.
This is separate from the generated code.
# SystemJS
It is important that SystemJS works without any modifications by the user. It is also important
to leave the liberty to the user to change the SystemJS configuration so that it fits their needs.
We will not use SystemJS bundles in development. This is for better debugging, future proofing
(when moving the build system) and better CDN support, as many of the loaded files will end up
being pulled from a CDN in production. During the `ng build` process for production, the
SystemJS configuration script will be rebuilt to fetch from the CDN.
# Upgrade Strategy
The upgrade process simply uses NPM. If new appData is added, it should be added manually using
a migration hook for `postinstall`.
# Remaining Problems
1. Installing dependencies of packages need to be further sketched out.
2. Need to add a full fledged example with Firebase.
angular-cli-0.0.34/index.js 0000664 0000000 0000000 00000000112 12707725453 0015447 0 ustar 00root root 0000000 0000000 /* jshint node: true */
'use strict';
module.exports = {
name: 'ng'
};
angular-cli-0.0.34/lib/ 0000775 0000000 0000000 00000000000 12707725453 0014556 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/lib/broccoli/ 0000775 0000000 0000000 00000000000 12707725453 0016352 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/lib/broccoli/angular-broccoli-compass.js 0000664 0000000 0000000 00000003367 12707725453 0023607 0 ustar 00root root 0000000 0000000 /* jshint node: true, esversion: 6 */
'use strict';
const requireOrNull = require('./require-or-null');
const Plugin = require('broccoli-caching-writer');
const fse = require('fs-extra');
const path = require('path');
const Funnel = require('broccoli-funnel');
let sass = requireOrNull('node-sass');
let compass = requireOrNull('compass');
if (!sass || !compass) {
sass = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/node-sass`);
compass = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/compass-importer`);
}
class CompassPlugin extends Plugin {
constructor(inputNodes, options) {
super(inputNodes, {});
options = options || {};
Plugin.call(this, inputNodes, {
cacheInclude: [/\.scss$/, /\.sass$/]
});
this.options = options;
}
build() {
this.listEntries().forEach(e => {
let fileName = path.resolve(e.basePath, e.relativePath);
this.compile(fileName, this.inputPaths[0], this.outputPath);
});
}
compile(fileName, inputPath, outputPath) {
let sassOptions = Object.assign(this.options, {
data: '@import "compass"; .transition { @include transition(all); }',
file: fileName,
includePaths: [inputPath].concat(this.options.inputPaths || []),
importer: compass
});
let result = sass.renderSync(sassOptions);
let filePath = fileName.replace(inputPath, outputPath).replace(/\.s[ac]ss$/, '.css');
fse.outputFileSync(filePath, result.css, 'utf8');
}
}
exports.makeBroccoliTree = (sourceDir, options) => {
if (sass && compass) {
let compassSrcTree = new Funnel(sourceDir, {
include: ['**/*.scss', '**/*.sass'],
allowEmpty: true
});
return new CompassPlugin([compassSrcTree], options);
}
};
angular-cli-0.0.34/lib/broccoli/angular-broccoli-less.js 0000664 0000000 0000000 00000002705 12707725453 0023103 0 ustar 00root root 0000000 0000000 /* jshint node: true, esversion: 6 */
'use strict';
const requireOrNull = require('./require-or-null');
const Plugin = require('broccoli-caching-writer');
const fs = require('fs');
const fse = require('fs-extra');
const path = require('path');
const Funnel = require('broccoli-funnel');
let less = requireOrNull('less');
if (!less) {
less = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/less`);
}
class LESSPlugin extends Plugin {
constructor(inputNodes, options) {
super(inputNodes, {});
options = options || {};
Plugin.call(this, inputNodes, {
cacheInclude: [/\.less$/]
});
this.options = options;
}
build() {
return Promise.all(this.listEntries().map(e => {
let fileName = path.resolve(e.basePath, e.relativePath);
return this.compile(fileName, this.inputPaths[0], this.outputPath);
}));
}
compile(fileName, inputPath, outputPath) {
let content = fs.readFileSync(fileName, 'utf8');
return less.render(content, this.options)
.then(output => {
let filePath = fileName.replace(inputPath, outputPath).replace(/\.less$/, '.css');
fse.outputFileSync(filePath, output.css, 'utf8');
});
}
}
exports.makeBroccoliTree = (sourceDir, options) => {
if (less) {
let lessSrcTree = new Funnel(sourceDir, {
include: ['**/*.less'],
allowEmpty: true
});
return new LESSPlugin([lessSrcTree], options);
}
};
angular-cli-0.0.34/lib/broccoli/angular-broccoli-sass.js 0000664 0000000 0000000 00000004140 12707725453 0023101 0 ustar 00root root 0000000 0000000 /* jshint node: true, esversion: 6 */
'use strict';
const requireOrNull = require('./require-or-null');
const Plugin = require('broccoli-caching-writer');
const fse = require('fs-extra');
const path = require('path');
const Funnel = require('broccoli-funnel');
let sass = requireOrNull('node-sass');
if (!sass) {
sass = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/node-sass`);
}
class SASSPlugin extends Plugin {
constructor(inputNodes, options) {
super(inputNodes, {});
options = options || {};
Plugin.call(this, inputNodes, {
cacheInclude: [/\.scss$/, /\.sass$/]
});
this.options = options;
}
build() {
this.listFiles().forEach(fileName => {
// Normalize is necessary for changing `\`s into `/`s on windows.
this.compile(path.normalize(fileName),
path.normalize(this.inputPaths[0]),
path.normalize(this.outputPath));
});
}
compile(fileName, inputPath, outputPath) {
const outSourceName = fileName.replace(inputPath, outputPath);
const outFileName = outSourceName.replace(/\.s[ac]ss$/, '.css');
// We overwrite file, outFile and include the file path for the includePath.
// We also make sure the options don't include a data field.
const sassOptions = Object.assign(this.options, {
file: fileName,
outFile: outFileName,
includePaths: [inputPath].concat(this.options.includePaths || [])
});
delete sassOptions.data;
const result = sass.renderSync(sassOptions);
fse.outputFileSync(outFileName, result.css, 'utf-8');
}
}
exports.makeBroccoliTree = (sourceDir, options) => {
options = options || {};
// include sass support only if compass-importer is not installed
let compass = requireOrNull('compass-importer');
if (!compass) {
compass = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/compass-importer`);
}
if (sass && !compass) {
let sassSrcTree = new Funnel(sourceDir, {
include: ['**/*.sass', '**/*.scss'],
allowEmpty: true
});
return new SASSPlugin([sassSrcTree], options);
}
};
angular-cli-0.0.34/lib/broccoli/angular-broccoli-stylus.js 0000664 0000000 0000000 00000003051 12707725453 0023473 0 ustar 00root root 0000000 0000000 /* jshint node: true, esversion: 6 */
'use strict';
const requireOrNull = require('./require-or-null');
const Plugin = require('broccoli-caching-writer');
const fs = require('fs');
const fse = require('fs-extra');
const path = require('path');
const Funnel = require('broccoli-funnel');
let stylus = requireOrNull('stylus');
if (!stylus) {
stylus = requireOrNull(`${process.env.PROJECT_ROOT}/node_modules/stylus`);
}
class StylusPlugin extends Plugin {
constructor(inputNodes, options) {
super(inputNodes, {});
options = options || {};
Plugin.call(this, inputNodes, {
cacheInclude: [/\.styl$/]
});
this.options = options;
}
build() {
return Promise.all(this.listEntries().map(e => {
let fileName = path.resolve(e.basePath, e.relativePath);
return this.compile(fileName, this.inputPaths[0], this.outputPath);
}));
}
compile(fileName, inputPath, outputPath) {
let content = fs.readFileSync(fileName, 'utf8');
const options = Object.assign(this.options, {
filename: path.basename(fileName)
});
return stylus.render(content, options, function(err, css) {
let filePath = fileName.replace(inputPath, outputPath).replace(/\.styl$/, '.css');
fse.outputFileSync(filePath, css, 'utf8');
});
}
}
exports.makeBroccoliTree = (sourceDir, options) => {
if (stylus) {
let stylusSrcTree = new Funnel(sourceDir, {
include: ['**/*.styl'],
allowEmpty: true
});
return new StylusPlugin([stylusSrcTree], options);
}
};
angular-cli-0.0.34/lib/broccoli/angular2-app.js 0000664 0000000 0000000 00000025052 12707725453 0021205 0 ustar 00root root 0000000 0000000 'use strict';
const fs = require('fs');
const glob = require('glob');
const path = require('path');
const isProduction = require('./is-production');
const BroccoliPlugin = require('broccoli-writer');
const BroccoliConfigReplace = require('./broccoli-config-replace');
const BroccoliTypescript = require('./broccoli-typescript');
const BroccoliSwManifest = require('./service-worker-manifest').default;
const BroccoliFunnel = require('broccoli-funnel');
const BroccoliMergeTrees = require('broccoli-merge-trees');
const BroccoliUglify = require('broccoli-uglify-js');
const Project = require('ember-cli/lib/models/project');
class Angular2App extends BroccoliPlugin {
constructor(project, inputNode, options) {
if (!options) {
options = inputNode;
inputNode = null;
}
super();
options = options || {};
this._options = options;
this._sourceDir = options.sourceDir || 'src/client';
this._inputNode = inputNode || this._sourceDir;
this._destDir = options.destDir || '';
// By default, add all spec files to the tsCompiler.
this._tsCompiler = options.tsCompiler || {
additionalFiles: ['**/*.spec.ts']
};
this._initProject();
this._notifyAddonIncluded();
this._tree = this._buildTree();
}
/**
* For backward compatibility.
* @public
* @method toTree
* @return {BroccoliPlugin} A broccoli plugin.
*/
toTree() {
// eslint-disable-next-line no-console
console.warn('Angular2App is now a broccoli plugin. Calling toTree() is deprecated.');
return this;
}
/**
* @override
*/
read(readTree) {
return this._tree.read(readTree);
}
/**
* @override
*/
cleanup() {
return this._tree.cleanup();
}
/**
* Create and return the app build system tree that:
* - Get the `assets` tree
* - Get the TS tree
* - Get the TS src tree
* - Get the index.html tree
* - Get the NPM modules tree
* - Apply/remove stuff based on the environment (dev|prod)
* - Return the app trees to be extended
*
* @private
* @method _buildTree
* @return {BroccoliFunnel} The app trees that can be used to extend the build.
*/
_buildTree() {
var assetTree = this._getAssetsTree();
var tsTree = this._getTsTree();
var indexTree = this._getIndexTree();
var vendorNpmTree = this._getVendorNpmTree();
var excludeDotfilesTree = this._getPublicTree();
var buildTrees = [assetTree, tsTree, indexTree, vendorNpmTree];
if (fs.existsSync('public')) {
buildTrees.push(excludeDotfilesTree);
}
buildTrees = buildTrees.concat(
require('./angular-broccoli-sass').makeBroccoliTree(this._inputNode,
this._options.sassCompiler),
require('./angular-broccoli-less').makeBroccoliTree(this._inputNode,
this._options.lessCompiler),
require('./angular-broccoli-stylus').makeBroccoliTree(this._inputNode,
this._options.stylusCompiler),
require('./angular-broccoli-compass').makeBroccoliTree(this._inputNode,
this._options.compassCompiler)
).filter(x => !!x);
var merged = BroccoliMergeTrees(buildTrees, { overwrite: true });
return new BroccoliFunnel(BroccoliMergeTrees([merged, new BroccoliSwManifest([merged])]), {
destDir: this._destDir
});
}
/**
* @private
* @method _initProject
* @param {Object} options
*/
_initProject() {
this.project = Project.closestSync(process.cwd());
// project root dir env used on angular-cli side for including packages from project
process.env.PROJECT_ROOT = process.env.PROJECT_ROOT || this.project.root;
}
/**
* @private
* @method _notifyAddonIncluded
*/
_notifyAddonIncluded() {
this.initializeAddons();
this.project.addons = this.project.addons.filter(function (addon) {
addon.app = this;
if (!addon.isEnabled || addon.isEnabled()) {
if (addon.included) {
addon.included(this);
}
return addon;
}
}, this);
}
/**
* Loads and initializes addons for this project.
* Calls initializeAddons on the Project.
*
* @private
* @method initializeAddons
*/
initializeAddons() {
this.project.initializeAddons();
}
/**
* Returns the content for a specific type (section) for index.html.
*
* Currently supported types:
* - 'head'
* //- 'config-module'
* //- 'app'
* //- 'head-footer'
* //- 'test-header-footer'
* //- 'body-footer'
* //- 'test-body-footer'
*
* Addons can also implement this method and could also define additional
* types (eg. 'some-addon-section').
*
* @private
* @method _contentFor
* @param {RegExP} match Regular expression to match against
* @param {String} type Type of content
* @return {String} The content.
*/
_contentFor(match, type) {
var content = [];
/*switch (type) {
case 'head': this._contentForHead(content, config); break;
case 'config-module': this._contentForConfigModule(content, config); break;
case 'app-boot': this._contentForAppBoot(content, config); break;
}*/
content = this.project.addons.reduce(function (content, addon) {
var addonContent = addon.contentFor ? addon.contentFor(type) : null;
if (addonContent) {
return content.concat(addonContent);
}
return content;
}, content);
return content.join('\n');
}
/**
* @private
* @method _getReplacePatterns
* @return Array Replace patterns.
*/
_getReplacePatterns() {
return [{
match: /\{\{content-for ['"](.+)["']\}\}/g,
replacement: isProduction ? '' : this._contentFor.bind(this)
}];
}
/**
* Returns the tree for app/index.html.
*
* @private
* @method _getIndexTree
* @return {Tree} Tree for app/index.html.
*/
_getIndexTree() {
var htmlName = 'index.html';
var files = [
'index.html'
];
var index = new BroccoliFunnel(this._inputNode, {
files: files,
description: 'BroccoliFunnel: index.html'
});
return BroccoliConfigReplace(index, {
files: [htmlName],
patterns: this._getReplacePatterns()
});
}
/**
* Returns the source root dir tree.
*
* @private
* @method _getSourceTree
* @return {Tree} Tree for the src dir.
*/
_getSourceTree() {
return new BroccoliFunnel(this._inputNode, {
include: ['*.ts', '**/*.ts', '**/*.d.ts'],
destDir: this._sourceDir
});
}
/**
* Returns the typings tree.
*
* @private
* @method _getTypingsTree
* @return {Tree} Tree for the src dir.
*/
_getTypingsTree() {
return new BroccoliFunnel('typings', {
include: ['browser.d.ts', 'browser/**'],
destDir: 'typings'
});
}
/**
* Returns the TS tree.
*
* @private
* @method _getTsTree
* @return {Tree} Tree for TypeScript files.
*/
_getTsTree() {
var typingsTree = this._getTypingsTree();
var sourceTree = this._getSourceTree();
var configTree = this._getConfigTree();
var tsConfigPath = path.join(this._sourceDir, 'tsconfig.json');
var tsconfig = JSON.parse(fs.readFileSync(tsConfigPath, 'utf-8'));
// Add all glob files to files. In some cases we don't want to specify
let globFiles = this._tsCompiler.additionalFiles;
if (globFiles) {
if (typeof globFiles == 'string') {
globFiles = [globFiles];
}
for (const g of globFiles) {
const files = glob(g, { sync: true, cwd: this._sourceDir, root: this._sourceDir });
tsconfig.files = tsconfig.files.concat(files);
}
}
// Remove dupes in tsconfig.files.
const fileNameMap = {};
tsconfig.files = tsconfig.files.filter(fileName => {
if (fileNameMap[fileName]) {
return false;
}
fileNameMap[fileName] = true;
return true;
});
// Because the tsconfig does not include the source directory, add this as the first path
// element.
tsconfig.files = tsconfig.files.map(name => path.join(this._sourceDir, name));
var mergedTree = BroccoliMergeTrees([sourceTree, typingsTree, configTree], { overwrite: true });
var tsTree = new BroccoliTypescript(mergedTree, tsconfig);
var tsTreeExcludes = ['*.d.ts', 'tsconfig.json'];
var excludeSpecFiles = '**/*.spec.*';
if (isProduction) {
tsTreeExcludes.push(excludeSpecFiles);
tsTree = BroccoliUglify(tsTree);
}
tsTree = new BroccoliFunnel(tsTree, {
srcDir: this._sourceDir,
exclude: tsTreeExcludes
});
return tsTree;
}
/**
* Returns the `vendorNpm` tree by merging the CLI dependencies plus the ones
* passed by the user.
*
* @private
* @method _getVendorNpmTree
* @return {Tree} The NPM tree.
*/
_getVendorNpmTree() {
var vendorNpmFiles = [
'systemjs/dist/system-polyfills.js',
'systemjs/dist/system.src.js',
'es6-shim/es6-shim.js',
'angular2/bundles/angular2-polyfills.js',
'rxjs/bundles/Rx.js',
'angular2/bundles/angular2.dev.js',
'angular2/bundles/http.dev.js',
'angular2/bundles/router.dev.js',
'angular2/bundles/upgrade.dev.js'
];
if (this._options.vendorNpmFiles) {
vendorNpmFiles = vendorNpmFiles.concat(this._options.vendorNpmFiles);
}
return new BroccoliFunnel('node_modules', {
include: vendorNpmFiles,
destDir: 'vendor'
});
}
/**
* Returns the `assets` tree.
*
* @private
* @method _getAssetsTree
* @return {Tree} The assets tree.
*/
_getAssetsTree() {
return new BroccoliFunnel(this._inputNode, {
exclude: [
'**/*.ts',
'**/*.js',
'**/*.scss',
'**/*.sass',
'**/*.less',
'**/*.styl'
],
allowEmpty: true
});
}
/**
* Returns the `excludeDotfiles` tree.
*
* @private
* @method _getPublicTree
* @return {Tree} The dotfiles exclusion tree.
*/
_getPublicTree() {
return new BroccoliFunnel('public', {
exclude: ['**/.*'],
allowEmpty: true
});
}
/**
* Returns the config files tree.
*
* @private
* @method _getConfigTree
* @return {Tree} The config files tree.
*/
_getConfigTree() {
var envConfigFile = isProduction ? 'environment.prod.ts' : 'environment.dev.ts';
return new BroccoliFunnel('config', {
include: [envConfigFile],
destDir: 'src/client/app',
getDestinationPath: () => 'environment.ts'
});
}
}
module.exports = Angular2App;
angular-cli-0.0.34/lib/broccoli/broccoli-config-replace.js 0000664 0000000 0000000 00000003546 12707725453 0023370 0 ustar 00root root 0000000 0000000 'use strict';
var fs = require('fs-extra');
var path = require('path');
var Writer = require('broccoli-writer');
function CustomReplace(inputTree, options) {
if (!(this instanceof CustomReplace)) {
return new CustomReplace(inputTree, options);
}
Writer.call(this, inputTree, options); // this._super();
this.inputTree = inputTree;
this.options = options;
}
CustomReplace.prototype = Object.create(Writer.prototype);
CustomReplace.prototype.constructor = CustomReplace;
CustomReplace.prototype.write = function (readTree, destDir) {
var inputDir;
return readTree(this.inputTree)
.then(function (path) {
inputDir = path;
return {
inputDir: inputDir,
destDir: destDir
};
})
.then(this.process.bind(this));
};
CustomReplace.prototype.process = function (results) {
var files = this.options.files;
for (var i = 0, l = files.length; i < l; i++) {
var file = files[i];
var filePath = path.join(results.inputDir, file);
var destPath = path.join(results.destDir, file);
this.processFile(filePath, destPath);
}
};
CustomReplace.prototype.processFile = function (filePath, destPath) {
var contents = fs.readFileSync(filePath, { encoding: 'utf8' });
for (var i = 0, l = this.options.patterns.length; i < l; i++) {
// jshint loopfunc:true
var pattern = this.options.patterns[i];
var replacement = pattern.replacement;
if (typeof pattern.replacement === 'function') {
replacement = function () {
var args = Array.prototype.slice.call(arguments);
return pattern.replacement.apply(null, args);
};
}
contents = contents.replace(pattern.match, replacement);
}
if (!fs.existsSync(path.dirname(destPath))) {
fs.mkdirsSync(path.dirname(destPath));
}
fs.writeFileSync(destPath, contents, { encoding: 'utf8' });
};
module.exports = CustomReplace;
angular-cli-0.0.34/lib/broccoli/broccoli-typescript.js 0000664 0000000 0000000 00000024257 12707725453 0022722 0 ustar 00root root 0000000 0000000 'use strict';
const Plugin = require('broccoli-caching-writer');
const fs = require('fs');
const fse = require('fs-extra');
const path = require('path');
const ts = require('typescript');
const FS_OPTS = {
encoding: 'utf-8'
};
/**
* Broccoli plugin that implements incremental Typescript compiler.
*
* It instantiates a typescript compiler instance that keeps all the state about the project and
* can re-emit only the files that actually changed.
*
* Limitations: only files that map directly to the changed source file via naming conventions are
* re-emitted. This primarily affects code that uses `const enum`s, because changing the enum value
* requires global emit, which can affect many files.
*/
class BroccoliTypeScriptCompiler extends Plugin {
constructor(inputPath, options) {
super([inputPath], {});
this._fileRegistry = Object.create(null);
this._rootFilePaths = [];
this._tsOpts = null;
this._tsServiceHost = null;
this._tsService = null;
this._options = options;
if (options.files) {
this._rootFilePaths = options.files.splice(0);
}
}
build() {
if (!this._tsServiceHost) {
this._createServiceHost();
}
this._doIncrementalBuild();
}
_doIncrementalBuild() {
var errorMessages = [];
var entries = this.listEntries();
const inputPath = this.inputPaths[0];
const pathsToEmit = [];
entries.forEach(entry => {
const tsFilePath = path.join(inputPath, entry.relativePath);
if (!tsFilePath.match(/\.ts$/) || !fs.existsSync(tsFilePath)) {
return;
}
if (!this._fileRegistry[tsFilePath]) {
// Not in the registry? Add it.
this._addNewFileEntry(entry);
// We need to add the file to the rootFiles as well, as otherwise it _might_
// not get compiled. It needs to be referenced at some point, and unless we
// add the spec files first (which we don't know the order), it won't.
// So make every new files an entry point instead.
// TODO(hansl): We need to investigate if we should emit files that are not
// referenced. This doesn't take that into account.
this._tsServiceHost.fileNames.push(tsFilePath);
pathsToEmit.push(tsFilePath);
} else if (this._fileRegistry[tsFilePath].version >= entry.mtime) {
// Nothing to do for this file. Just link the cached outputs.
this._fileRegistry[tsFilePath].outputs.forEach(absoluteFilePath => {
const outputFilePath = absoluteFilePath.replace(this.cachePath, this.outputPath);
fse.mkdirsSync(path.dirname(outputFilePath));
fs.symlinkSync(absoluteFilePath, outputFilePath);
});
} else {
this._fileRegistry[tsFilePath].version = entry.mtime;
pathsToEmit.push(tsFilePath);
}
});
if (pathsToEmit.length > 0) {
// Force the TS Service to recreate the program (ie. call synchronizeHostData).
this._tsServiceHost.projectVersion++;
pathsToEmit.forEach(tsFilePath => {
var output = this._tsService.getEmitOutput(tsFilePath);
if (output.emitSkipped) {
const allDiagnostics = this._tsService.getCompilerOptionsDiagnostics()
.concat(this._tsService.getSyntacticDiagnostics(tsFilePath))
.concat(this._tsService.getSemanticDiagnostics(tsFilePath));
const errors = this._collectErrors(allDiagnostics);
if (errors) {
// Rebuild it next incremental pass.
delete this._fileRegistry[tsFilePath];
errorMessages.push(errors);
}
} else {
output.outputFiles.forEach(o => {
this._outputFile(o.name, o.text, this._fileRegistry[tsFilePath]);
});
}
});
}
if (errorMessages.length) {
var error = new Error('Typescript found the following errors:\n' + errorMessages.join('\n'));
error['showStack'] = false;
throw error;
}
}
_createServiceHost() {
// the conversion is a bit awkward, see https://github.com/Microsoft/TypeScript/issues/5276
// in 1.8 use convertCompilerOptionsFromJson
this._tsOpts = ts.parseJsonConfigFileContent(this._options, null, null).options;
this._tsOpts.rootDir = '';
this._tsOpts.outDir = '';
this._tsServiceHost = new CustomLanguageServiceHost(
this._tsOpts, this._rootFilePaths, this._fileRegistry, this.inputPaths[0]);
this._tsService = ts.createLanguageService(this._tsServiceHost, ts.createDocumentRegistry());
}
_collectErrors(allDiagnostics) {
const errors = allDiagnostics.map(diagnostic => {
const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
if (diagnostic.file) {
const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
const line = position.line;
const character = position.character;
return ` ${diagnostic.file.fileName} (${line + 1}, ${character + 1}): ${message}`;
} else {
return ` Error: ${message}`;
}
});
if (errors.length) {
return errors.join('\n');
}
}
_outputFile(absoluteFilePath, fileContent, registry) {
absoluteFilePath = path.resolve(this.cachePath, absoluteFilePath);
// Replace the input path by the output.
absoluteFilePath = absoluteFilePath.replace(this.inputPaths[0], this.cachePath);
const outputFilePath = absoluteFilePath.replace(this.cachePath, this.outputPath);
if (registry) {
registry.outputs.add(absoluteFilePath);
}
fse.mkdirsSync(path.dirname(absoluteFilePath));
const content = this.fixSourceMapSources(fileContent);
fs.writeFileSync(absoluteFilePath, content, FS_OPTS);
fse.mkdirsSync(path.dirname(outputFilePath));
fs.symlinkSync(absoluteFilePath, outputFilePath);
}
_addNewFileEntry(entry, checkDuplicates /* = true */) {
if (checkDuplicates === undefined) {
checkDuplicates = true;
}
const p = path.join(this.inputPaths[0], entry.relativePath);
if (checkDuplicates && this._fileRegistry[p]) {
throw `Trying to add a new entry to an already existing one: "${p}`;
}
this._fileRegistry[p] = {
version: entry.mtime,
outputs: new Set()
};
}
/**
* There is a bug in TypeScript 1.6, where the sourceRoot and inlineSourceMap properties
* are exclusive. This means that the sources property always contains relative paths
* (e.g, ../../../../angular2/src/di/injector.ts).
*
* Here, we normalize the sources property and remove the ../../../
*
* This issue is fixed in https://github.com/Microsoft/TypeScript/pull/5620.
* Once we switch to TypeScript 1.8, we can remove this method.
*/
fixSourceMapSources(content) {
try {
var marker = '//# sourceMappingURL=data:application/json;base64,';
var index = content.indexOf(marker);
if (index == -1)
return content;
var base = content.substring(0, index + marker.length);
var sourceMapBit = new Buffer(content.substring(index + marker.length), 'base64').toString('utf8');
var sourceMaps = JSON.parse(sourceMapBit);
var source = sourceMaps.sources[0];
sourceMaps.sources = [source.substring(source.lastIndexOf('../') + 3)];
return '' + base + new Buffer(JSON.stringify(sourceMaps)).toString('base64');
} catch (e) {
return content;
}
}
}
class CustomLanguageServiceHost {
constructor(compilerOptions, fileNames, fileRegistry, treeInputPath) {
this.compilerOptions = compilerOptions;
this.fileNames = fileNames;
this.fileRegistry = fileRegistry;
this.treeInputPath = treeInputPath;
this.currentDirectory = treeInputPath;
this.defaultLibFilePath = ts.getDefaultLibFilePath(compilerOptions).replace(/\\/g, '/');
this.projectVersion = 0;
}
getScriptFileNames() {
return this.fileNames;
}
getScriptVersion(fileName) {
fileName = path.resolve(this.treeInputPath, fileName);
return this.fileRegistry[fileName] && this.fileRegistry[fileName].version.toString();
}
getProjectVersion() {
return this.projectVersion.toString();
}
/**
* This method is called quite a bit to lookup 3 kinds of paths:
* 1/ files in the fileRegistry
* - these are the files in our project that we are watching for changes
* - in the future we could add caching for these files and invalidate the cache when
* the file is changed lazily during lookup
* 2/ .d.ts and library files not in the fileRegistry
* - these are not our files, they come from tsd or typescript itself
* - these files change only rarely but since we need them very rarely, it's not worth the
* cache invalidation hassle to cache them
* 3/ bogus paths that typescript compiler tries to lookup during import resolution
* - these paths are tricky to cache since files come and go and paths that was bogus in the
* past might not be bogus later
*
* In the initial experiments the impact of this caching was insignificant (single digit %) and
* not worth the potential issues with stale cache records.
*/
getScriptSnapshot(tsFilePath) {
var absoluteTsFilePath;
if (tsFilePath == this.defaultLibFilePath || path.isAbsolute(tsFilePath)) {
absoluteTsFilePath = tsFilePath;
} else if (this.compilerOptions.moduleResolution === 2 /* NodeJs */ &&
tsFilePath.match(/^node_modules/)) {
absoluteTsFilePath = path.resolve(tsFilePath);
} else if (tsFilePath.match(/^rxjs/)) {
absoluteTsFilePath = path.resolve('node_modules', tsFilePath);
} else {
absoluteTsFilePath = path.join(this.treeInputPath, tsFilePath);
}
if (!fs.existsSync(absoluteTsFilePath)) {
// TypeScript seems to request lots of bogus paths during import path lookup and resolution,
// so we we just return undefined when the path is not correct.
return undefined;
}
return ts.ScriptSnapshot.fromString(fs.readFileSync(absoluteTsFilePath, FS_OPTS));
}
getCurrentDirectory() {
return this.currentDirectory;
}
getCompilationSettings() {
return this.compilerOptions;
}
getDefaultLibFileName(/* options */) {
// ignore options argument, options should not change during the lifetime of the plugin
return this.defaultLibFilePath;
}
}
module.exports = BroccoliTypeScriptCompiler;
angular-cli-0.0.34/lib/broccoli/is-production.js 0000664 0000000 0000000 00000000110 12707725453 0021477 0 ustar 00root root 0000000 0000000 module.exports = (/(^production$|^prod$)/).test(process.env.EMBER_ENV);
angular-cli-0.0.34/lib/broccoli/require-or-null.js 0000664 0000000 0000000 00000000241 12707725453 0021747 0 ustar 00root root 0000000 0000000 /* jshint node: true, esversion: 6 */
'use strict';
module.exports = function(name) {
try {
return require(name);
} catch (e) {
return null;
}
};
angular-cli-0.0.34/lib/broccoli/service-worker-manifest.js 0000664 0000000 0000000 00000006110 12707725453 0023461 0 ustar 00root root 0000000 0000000 'use strict';
const Plugin = require('broccoli-caching-writer');
var path = require('path');
var fs = require('fs');
var crypto = require('crypto');
var FILE_ENCODING = { encoding: 'utf-8' };
var MANIFEST_FILE = 'manifest.appcache';
var FILE_HASH_PREFIX = '# sw.file.hash:';
class DiffingSWManifest extends Plugin {
constructor(inputPath, options) {
super(inputPath, options);
this.options = options;
this.firstBuild = true;
this.manifest = {};
}
build() {
var manifest = this.manifest;
const files = this.listFiles();
// Removed files from the manifest that aren't part of the files.
Object.keys(manifest)
.filter((f) => files.indexOf(f) == -1)
.forEach((file) => delete manifest[file]);
// Merge the lists of added and changed paths and update their hashes in the manifest.
files
.filter((file) => file !== MANIFEST_FILE)
.forEach((file) => manifest[file] = this.computeFileHash(file));
var manifestPath = path.join(this.outputPath, MANIFEST_FILE);
fs.writeFileSync(manifestPath, this.generateManifest(manifest));
}
// Compute the hash of the given relative file.
computeFileHash(file) {
var contents = fs.readFileSync(file);
return crypto
.createHash('sha1')
.update(contents)
.digest('hex');
}
// Compute the hash of the bundle from the names and hashes of all included files.
computeBundleHash(files, manifest) {
var hash = crypto.createHash('sha1');
files.forEach((file) => hash.update(manifest[file] + ':' + file));
return hash.digest('hex');
}
// Generate the string contents of the manifest.
generateManifest(manifest) {
var files = Object.keys(manifest).sort();
var bundleHash = this.computeBundleHash(files, manifest);
var contents = files
.map((file) => {
return `# sw.file.hash: ${this.computeFileHash(file)}\n`
+ `${path.sep}${path.relative(this.inputPaths[0], file)}`;
})
.join('\n');
return 'CACHE MANIFEST\n'
+ '# sw.bundle: ng-cli\n'
+ `# sw.version: ${bundleHash}\n`
+ `${contents}\n`;
}
// Read the manifest from the cache and split it out into a dict of files to hashes.
readManifestFromCache() {
var contents = fs.readFileSync(path.join(this.outputPath, MANIFEST_FILE), FILE_ENCODING);
var manifest = {};
var hash = null;
contents
.split('\n')
.map((line) => line.trim())
.filter((line) => line !== 'CACHE MANIFEST')
.filter((line) => line !== '')
.filter((line) => !line.startsWith('#') || line.startsWith('# sw.'))
.forEach((line) => {
if (line.startsWith(FILE_HASH_PREFIX)) {
// This is a hash prefix for the next file in the list.
hash = line.substring(FILE_HASH_PREFIX.length).trim();
} else if (line.startsWith('/')) {
// This is a file belonging to the application.
manifest[line.substring(1)] = hash;
hash = null;
}
});
return manifest;
}
}
Object.defineProperty(exports, '__esModule', { value: true });
exports.default = DiffingSWManifest;
angular-cli-0.0.34/lib/cli/ 0000775 0000000 0000000 00000000000 12707725453 0015325 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/lib/cli/index.js 0000664 0000000 0000000 00000005731 12707725453 0017000 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
// This file hooks up on require calls to transpile TypeScript.
const fs = require('fs');
const ts = require('typescript');
const old = require.extensions['.ts'];
require.extensions['.ts'] = function(m, filename) {
// If we're in node module, either call the old hook or simply compile the
// file without transpilation. We do not touch node_modules/**.
// We do touch `angular-cli` files anywhere though.
if (!filename.match(/angular-cli/) && filename.match(/node_modules/)) {
if (old) {
return old(m, filename);
}
return m._compile(fs.readFileSync(filename), filename);
}
// Node requires all require hooks to be sync.
const source = fs.readFileSync(filename).toString();
try {
const result = ts.transpile(source, {
target: ts.ScriptTarget.ES5,
module: ts.ModuleKind.CommonJs
});
// Send it to node to execute.
return m._compile(result, filename);
} catch (err) {
console.error('Error while running script "' + filename + '":');
console.error(err.stack);
throw err;
}
};
/**
* Monkey patch `ember-cli/lib/utilities/find-build-file` to find our build
* file when looking for `ember-cli-build.js`. This needs to be the first
* thing that happens before we `require()` any ember files.
*
* TODO: Remove this hack and replace it with some configuration when/if we
* move away from ember. Or when ember allows us to configure this in
* an addon.
*/
const findBuildFileRequirePath = 'ember-cli/lib/utilities/find-build-file';
const originalFindBuildFile = require(findBuildFileRequirePath);
const mod = require.cache[require.resolve(findBuildFileRequirePath)];
mod.exports = function patchedFindBuildFile(name) {
if (name == 'ember-cli-build.js') {
const result = originalFindBuildFile.call(this, 'angular-cli-build.js');
// Fallback to ember-cli-build if angular-cli-build isn't found.
if (result) {
return result;
}
}
return originalFindBuildFile.apply(this, arguments);
};
const cli = require('ember-cli/lib/cli');
const path = require('path');
module.exports = function(options) {
const oldStdoutWrite = process.stdout.write;
process.stdout.write = function (line) {
line = line.toString();
if (line.match(/version:|WARNING:/)) {
return;
}
line = line.replace(/ember-cli(?!.com)/g, 'angular-cli')
.replace(/ember(?!-cli.com)/g, 'ng');
return oldStdoutWrite.apply(process.stdout, arguments);
};
const oldStderrWrite = process.stderr.write;
process.stderr.write = function (line) {
line = line.toString()
.replace(/ember-cli(?!.com)/g, 'angular-cli')
.replace(/ember(?!-cli.com)/g, 'ng');
return oldStderrWrite.apply(process.stdout, arguments);
};
options.cli = {
name: 'ng',
root: path.join(__dirname, '..', '..'),
npmPackage: 'angular-cli'
};
// ensure the environemnt variable for dynamic paths
process.env.PWD = process.env.PWD || process.cwd();
return cli(options);
}
angular-cli-0.0.34/lib/config/ 0000775 0000000 0000000 00000000000 12707725453 0016023 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/lib/config/schema.json 0000664 0000000 0000000 00000003622 12707725453 0020161 0 ustar 00root root 0000000 0000000 {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Angular CLI Config Schema",
"type": "object",
"properties": {
"project": {
"description": "The global configuration of the project.",
"type": "object",
"properties": {
"version": {
"type": "string"
},
"name": {
"type": "string"
}
},
"additionalProperties": false
},
"apps": {
"description": "Properties of the different applications in this project.",
"type": "array",
"items": {
"type": "object",
"properties": {
"root": "string",
"tsconfig": "string"
},
"additionalProperties": false
},
"additionalProperties": false
},
"addons": {
"description": "Configuration reserved for installed third party addons.",
"type": "array",
"items": {
"type": "object",
"properties": {},
"additionalProperties": true
}
},
"packages": {
"description": "Configuration reserved for installed third party packages.",
"type": "array",
"items": {
"type": "object",
"properties": {},
"additionalProperties": true
}
},
"e2e": {
"type": "object",
"properties": {
"protractor": {
"type": "object",
"properties": {
"config": {
"type": "string"
}
},
"additionalProperties": false
}
},
"additionalProperties": false
},
"test": {
"type": "object",
"properties": {
"karma": {
"type": "object",
"properties": {
"config": {
"type": "string"
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}
angular-cli-0.0.34/package.json 0000664 0000000 0000000 00000003432 12707725453 0016300 0 ustar 00root root 0000000 0000000 {
"name": "angular-cli",
"version": "0.0.34",
"description": "CLI tool for Angular2",
"main": "lib/cli/index.js",
"trackingCode": "UA-8594346-19",
"bin": {
"ng": "./bin/ng"
},
"keywords": [],
"scripts": {
"test": "node tests/runner",
"lint": "eslint ."
},
"repository": {
"type": "git",
"url": "https://github.com/angular/angular-cli.git"
},
"engines": {
"node": ">= 4.1.0"
},
"author": "Angular Authors",
"contributors": [
"Rody Haddad (http://rodyhaddad.com/)",
"Igor Minar "
],
"license": "MIT",
"bugs": {
"url": "https://github.com/angular/angular-cli/issues"
},
"homepage": "https://github.com/angular/angular-cli",
"dependencies": {
"broccoli": "^1.0.0-beta.6",
"broccoli-caching-writer": "^2.2.1",
"broccoli-concat": "^2.2.0",
"broccoli-funnel": "^1.0.1",
"broccoli-merge-trees": "^1.1.1",
"broccoli-uglify-js": "^0.1.3",
"broccoli-writer": "^0.1.1",
"chalk": "^1.1.1",
"ember-cli": "2.4.2",
"exit": "^0.1.2",
"fs-extra": "^0.26.6",
"glob": "^7.0.3",
"leek": "0.0.21",
"lodash": "^4.6.1",
"multidep": "^2.0.0",
"opn": "4.0.1",
"resolve": "^1.1.7",
"shelljs": "^0.6.0",
"silent-error": "^1.0.0",
"symlink-or-copy": "^1.0.1",
"typescript": "^1.8.7",
"typings": "^0.7.9"
},
"ember-addon": {
"paths": [
"./addon/ng2/"
]
},
"devDependencies": {
"chai": "^3.5.0",
"clang-format": "^1.0.37",
"eslint": "^2.4.0",
"exists-sync": "0.0.3",
"minimatch": "^3.0.0",
"mocha": "^2.4.5",
"mock-fs": "^3.8.0",
"object-assign": "^4.0.1",
"rewire": "^2.5.1",
"sinon": "^1.17.3",
"through": "^2.3.8",
"tslint": "^3.6.0",
"walk-sync": "^0.2.6"
}
}
angular-cli-0.0.34/tests/ 0000775 0000000 0000000 00000000000 12707725453 0015152 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/tests/acceptance/ 0000775 0000000 0000000 00000000000 12707725453 0017240 5 ustar 00root root 0000000 0000000 angular-cli-0.0.34/tests/acceptance/dynamic-path-parser.spec.js 0000664 0000000 0000000 00000010354 12707725453 0024402 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('chai').expect;
var path = require('path');
var dynamicPathParser = require('../../addon/ng2/utilities/dynamic-path-parser');
var mockFs = require('mock-fs');
var appDir = `src${path.sep}client${path.sep}app`;
describe('dynamic path parser', () => {
var project;
var entityName = 'temp-name';
var rootName = path.parse(process.cwd()).root + 'project';
beforeEach(() => {
project = { root: rootName };
var mockFolder = {};
mockFolder[rootName] = {
src: {
client: {
app: {
'index.html': '',
'temp-name': {}
}
}
}
};
mockFs(mockFolder);
});
afterEach(() => {
mockFs.restore();
});
it('parse from proj root dir', () => {
process.env.PWD = project.root;
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(appDir);
expect(result.name).to.equal(entityName);
});
it('parse from proj src dir', () => {
process.env.PWD = path.join(project.root, 'src');
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(appDir);
expect(result.name).to.equal(entityName);
});
it(`parse from proj src${path.sep}client dir`, () => {
process.env.PWD = path.join(project.root, 'src', 'client');
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(appDir);
expect(result.name).to.equal(entityName);
});
it(`parse from proj src${path.sep}client${path.sep}app dir`, () => {
process.env.PWD = path.join(project.root, 'src', 'client', 'app');
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(appDir);
expect(result.name).to.equal(entityName);
});
it(`parse from proj src${path.sep}client${path.sep}app${path.sep}child-dir`, () => {
var mockFolder = {};
mockFolder[rootName] = {
src: {
client: {
app: {
'index.html': '',
'child-dir': {
'temp-name': {}
}
}
}
}
};
mockFs(mockFolder);
process.env.PWD = path.join(project.root, 'src', 'client', 'app', 'child-dir');
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(`${appDir}${path.sep}child-dir`);
expect(result.name).to.equal(entityName);
});
it(`parse from proj src${path.sep}client${path.sep}app${path.sep}child-dir w/ ..${path.sep}`, () => {
var mockFolder = {};
mockFolder[rootName] = {
src: {
client: {
app: {
'index.html': '',
'child-dir': {},
'temp-name': {}
}
}
}
};
mockFs(mockFolder);
process.env.PWD = path.join(project.root, 'src', 'client', 'app', 'child-dir');
var result = dynamicPathParser(project, '..' + path.sep + entityName);
expect(result.dir).to.equal(appDir);
expect(result.name).to.equal(entityName);
});
it(`parse from proj src${path.sep}client${path.sep}app${path.sep}child-dir${path.sep}grand-child-dir w/ ..${path.sep}`,
() => {
var mockFolder = {};
mockFolder[rootName] = {
src: {
client: {
app: {
'index.html': '',
'child-dir': {
'grand-child-dir': {},
'temp-name': {}
}
}
}
}
};
mockFs(mockFolder);
process.env.PWD = path.join(project.root, 'src', 'client', 'app', 'child-dir', 'grand-child-dir');
var result = dynamicPathParser(project, '..' + path.sep + entityName);
expect(result.dir).to.equal(`${appDir}${path.sep}child-dir`);
expect(result.name).to.equal(entityName);
});
it('auto look for dirs with a "+" when not specified', () => {
var mockFolder = {};
mockFolder[rootName] = {
src: {
client: {
app: {
'+my-route': {}
}
}
}
};
mockFs(mockFolder);
process.env.PWD = path.join(project.root, 'src', 'client', 'app', 'my-route');
var result = dynamicPathParser(project, entityName);
expect(result.dir).to.equal(`${appDir}${path.sep}+my-route`);
expect(result.name).to.equal(entityName);
});
});
angular-cli-0.0.34/tests/acceptance/generate-component.spec.js 0000664 0000000 0000000 00000015205 12707725453 0024324 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
'use strict';
var fs = require('fs-extra');
var ng = require('../helpers/ng');
var existsSync = require('exists-sync');
var expect = require('chai').expect;
var path = require('path');
var tmp = require('../helpers/tmp');
var root = process.cwd();
var conf = require('ember-cli/tests/helpers/conf');
var Promise = require('ember-cli/lib/ext/promise');
describe('Acceptance: ng generate component', function () {
before(conf.setup);
after(conf.restore);
beforeEach(function () {
return tmp.setup('./tmp').then(function () {
process.chdir('./tmp');
}).then(function () {
return ng(['new', 'foo', '--skip-npm', '--skip-bower']);
});
});
afterEach(function () {
this.timeout(10000);
return tmp.teardown('./tmp');
});
it('ng generate component my-comp', function () {
return ng(['generate', 'component', 'my-comp']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate component test' + path.sep + 'my-comp', function () {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test'));
return ng(['generate', 'component', 'test' + path.sep + 'my-comp']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate component test' + path.sep + '..' + path.sep + 'my-comp', function () {
return ng(['generate', 'component', 'test' + path.sep + '..' + path.sep + 'my-comp'])
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate component my-comp from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
return ng(['generate', 'component', 'my-comp'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate component child-dir' + path.sep + 'my-comp from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
return ng(['generate', 'component', 'child-dir' + path.sep + 'my-comp'])
})
.then(() => {
var testPath = path.join(
root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate component child-dir' + path.sep + '..' + path.sep + 'my-comp from a child dir',
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
return ng([
'generate', 'component', 'child-dir' + path.sep + '..' + path.sep + 'my-comp'
])
})
.then(() => {
var testPath =
path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate component ' + path.sep + 'my-comp from a child dir, gens under ' +
path.join('src', 'client', 'app'),
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
return ng(['generate', 'component', path.sep + 'my-comp'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate component ..' + path.sep + 'my-comp from root dir will fail', () => {
return ng(['generate', 'component', '..' + path.sep + 'my-comp']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '..', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(false);
});
});
it('ng generate component mycomp will fail: no dashes in name', () => {
return ng(['generate', 'component', 'mycomp'])
.then((exitCode) => {
expect(exitCode).to.equal(1);
});
});
it('ng generate component MYCOMP will fail: no dashes in name', () => {
return ng(['generate', 'component', 'MYCOMP'])
.then((exitCode) => {
expect(exitCode).to.equal(1);
});
});
it('ng generate component myComp will succeed', () => {
return ng(['generate', 'component', 'myComp'])
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate component my-comp --inline-template', function () {
return ng(['generate', 'component', 'my-comp', '--inline-template']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.html');
expect(existsSync(testPath)).to.equal(false);
});
});
it('ng generate component my-comp --inline-style', function () {
return ng(['generate', 'component', 'my-comp', '--inline-style']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-comp', 'my-comp.component.css');
expect(existsSync(testPath)).to.equal(false);
});
});
});
angular-cli-0.0.34/tests/acceptance/generate-directive.spec.js 0000664 0000000 0000000 00000013436 12707725453 0024304 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
'use strict';
var fs = require('fs-extra');
var ng = require('../helpers/ng');
var existsSync = require('exists-sync');
var expect = require('chai').expect;
var path = require('path');
var tmp = require('../helpers/tmp');
var root = process.cwd();
var conf = require('ember-cli/tests/helpers/conf');
var Promise = require('ember-cli/lib/ext/promise');
describe('Acceptance: ng generate directive', function () {
before(conf.setup);
after(conf.restore);
beforeEach(function () {
return tmp.setup('./tmp').then(function () {
process.chdir('./tmp');
}).then(function () {
return ng(['new', 'foo', '--skip-npm', '--skip-bower']);
});
});
afterEach(function () {
this.timeout(10000);
return tmp.teardown('./tmp');
});
it('ng generate flat directive', function () {
return ng(['generate', 'directive', 'flat']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'flat.directive.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate directive my-dir', function () {
return ng(['generate', 'directive', 'my-dir', '--flat', 'false']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate directive test' + path.sep + 'my-dir', function () {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test'));
return ng(['generate', 'directive', 'test' + path.sep + 'my-dir', '--flat', 'false']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate directive test' + path.sep + '..' + path.sep + 'my-dir', function () {
return ng(['generate', 'directive', 'test' + path.sep + '..' + path.sep + 'my-dir', '--flat', 'false'])
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate directive my-dir from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'directive', 'my-dir', '--flat', 'false'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate directive child-dir' + path.sep + 'my-dir from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'directive', 'child-dir' + path.sep + 'my-dir', '--flat', 'false'])
})
.then(() => {
var testPath = path.join(
root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate directive child-dir' + path.sep + '..' + path.sep + 'my-dir from a child dir',
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(
['generate', 'directive', 'child-dir' + path.sep + '..' + path.sep + 'my-dir', '--flat', 'false'])
})
.then(() => {
var testPath =
path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate directive ' + path.sep + 'my-dir from a child dir, gens under ' +
path.join('src', 'client', 'app'),
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'directive', path.sep + 'my-dir', '--flat', 'false'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate directive ..' + path.sep + 'my-dir from root dir will fail', () => {
return ng(['generate', 'directive', '..' + path.sep + 'my-dir']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '..', 'my-dir', 'my-dir.directive.ts');
expect(existsSync(testPath)).to.equal(false);
});
});
});
angular-cli-0.0.34/tests/acceptance/generate-pipe.spec.js 0000664 0000000 0000000 00000012206 12707725453 0023255 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
'use strict';
var fs = require('fs-extra');
var ng = require('../helpers/ng');
var existsSync = require('exists-sync');
var expect = require('chai').expect;
var path = require('path');
var tmp = require('../helpers/tmp');
var root = process.cwd();
var conf = require('ember-cli/tests/helpers/conf');
var Promise = require('ember-cli/lib/ext/promise');
describe('Acceptance: ng generate pipe', function () {
before(conf.setup);
after(conf.restore);
beforeEach(function () {
return tmp.setup('./tmp').then(function () {
process.chdir('./tmp');
}).then(function () {
return ng(['new', 'foo', '--skip-npm', '--skip-bower']);
});
});
afterEach(function () {
this.timeout(10000);
return tmp.teardown('./tmp');
});
it('ng generate pipe my-pipe', function () {
return ng(['generate', 'pipe', 'my-pipe']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate pipe test' + path.sep + 'my-pipe', function () {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test'));
return ng(['generate', 'pipe', 'test' + path.sep + 'my-pipe']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate pipe test' + path.sep + '..' + path.sep + 'my-pipe', function () {
return ng(['generate', 'pipe', 'test' + path.sep + '..' + path.sep + 'my-pipe']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate pipe my-pipe from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'pipe', 'my-pipe'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate pipe child-dir' + path.sep + 'my-pipe from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'pipe', 'child-dir' + path.sep + 'my-pipe'])
})
.then(() => {
var testPath = path.join(
root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate pipe child-dir' + path.sep + '..' + path.sep + 'my-pipe from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'pipe', 'child-dir' + path.sep + '..' + path.sep + 'my-pipe'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate pipe ' + path.sep + 'my-pipe from a child dir, gens under ' +
path.join('src', 'client', 'app'),
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'pipe', path.sep + 'my-pipe'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate pipe ..' + path.sep + 'my-pipe from root dir will fail', () => {
return ng(['generate', 'pipe', '..' + path.sep + 'my-pipe']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '..', 'my-pipe.pipe.ts');
expect(existsSync(testPath)).to.equal(false);
});
});
});
angular-cli-0.0.34/tests/acceptance/generate-route.spec.js 0000664 0000000 0000000 00000005752 12707725453 0023466 0 ustar 00root root 0000000 0000000 'use strict';
const ng = require('../helpers/ng');
const tmp = require('../helpers/tmp');
const conf = require('ember-cli/tests/helpers/conf');
const existsSync = require('exists-sync');
const expect = require('chai').expect;
const fs = require('fs');
const path = require('path');
const root = process.cwd();
const testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app');
function fileExpectations(lazy, expectation) {
const lazyPrefix = lazy ? '+' : '';
const dir = `${lazyPrefix}my-route`;
expect(existsSync(path.join(testPath, dir, 'my-route.component.ts'))).to.equal(expectation);
}
describe('Acceptance: ng generate route', function () {
before(conf.setup);
after(conf.restore);
beforeEach(function () {
return tmp.setup('./tmp').then(function () {
process.chdir('./tmp');
}).then(function () {
return ng(['new', 'foo', '--skip-npm', '--skip-bower']);
});
});
afterEach(function () {
this.timeout(10000);
return tmp.teardown('./tmp');
});
it('ng generate route my-route', function () {
return ng(['generate', 'route', 'my-route']).then(() => {
fileExpectations(true, true);
});
});
it('ng generate route my-route --lazy false', function () {
return ng(['generate', 'route', 'my-route', '--lazy', 'false']).then(() => {
fileExpectations(false, true);
});
});
it('ng generate route +my-route', function () {
return ng(['generate', 'route', '+my-route']).then(() => {
fileExpectations(true, true);
});
});
it('ng generate route +my-route/my-other', () => {
return ng(['generate', 'route', '+my-route'])
.then(() => ng(['generate', 'route', '+my-route/my-other', '--default']))
.then(() => ng(['generate', 'route', '+my-route/+my-other/my-third', '--default']))
.then(() => {
expect(existsSync(path.join(testPath, '+my-route/my-route.component.ts')))
.to.equal(true);
expect(existsSync(path.join(testPath, '+my-route/+my-other/my-other.component.ts')))
.to.equal(true);
expect(existsSync(path.join(testPath, '+my-route/+my-other/+my-third/my-third.component.ts')))
.to.equal(true);
const appContent = fs.readFileSync(path.join(testPath, 'foo.component.ts'), 'utf-8');
const myRouteContent = fs.readFileSync(path.join(testPath, '+my-route/my-route.component.ts'), 'utf-8');
const myOtherRouteContent = fs.readFileSync(path.join(testPath, '+my-route/+my-other/my-other.component.ts'), 'utf-8');
const myThirdRouteContent = fs.readFileSync(path.join(testPath, '+my-route/+my-other/+my-third/my-third.component.ts'), 'utf-8');
expect(appContent).to.match(/@RouteConfig\(\[[\s\S]+\/\+my-route\/\.\.\.[\s\S]+\]\)/m);
expect(myRouteContent).to.match(/@RouteConfig\(\[[\s\S]+\/my-other\/\.\.\.[\s\S]+\]\)/m);
expect(myOtherRouteContent).to.match(/@RouteConfig\(\[[\s\S]+\/my-third[^\.][\s\S]+\]\)/m);
expect(myThirdRouteContent).to.not.include('@RouteConfig');
});
});
});
angular-cli-0.0.34/tests/acceptance/generate-service.spec.js 0000664 0000000 0000000 00000012370 12707725453 0023762 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
'use strict';
var fs = require('fs-extra');
var ng = require('../helpers/ng');
var existsSync = require('exists-sync');
var expect = require('chai').expect;
var path = require('path');
var tmp = require('../helpers/tmp');
var root = process.cwd();
var conf = require('ember-cli/tests/helpers/conf');
var Promise = require('ember-cli/lib/ext/promise');
describe('Acceptance: ng generate service', function () {
before(conf.setup);
after(conf.restore);
beforeEach(function () {
return tmp.setup('./tmp').then(function () {
process.chdir('./tmp');
}).then(function () {
return ng(['new', 'foo', '--skip-npm', '--skip-bower']);
});
});
afterEach(function () {
this.timeout(10000);
return tmp.teardown('./tmp');
});
it('ng generate service my-svc', function () {
return ng(['generate', 'service', 'my-svc']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate service test' + path.sep + 'my-svc', function () {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test'));
return ng(['generate', 'service', 'test' + path.sep + 'my-svc']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'test', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate service test' + path.sep + '..' + path.sep + 'my-svc', function () {
return ng(['generate', 'service', 'test' + path.sep + '..' + path.sep + 'my-svc']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
});
});
it('ng generate service my-svc from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'service', 'my-svc'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate service child-dir' + path.sep + 'my-svc from a child dir', () => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'service', 'child-dir' + path.sep + 'my-svc'])
})
.then(() => {
var testPath = path.join(
root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'child-dir', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate service child-dir' + path.sep + '..' + path.sep + 'my-svc from a child dir',
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(
['generate', 'service', 'child-dir' + path.sep + '..' + path.sep + 'my-svc'])
})
.then(() => {
var testPath =
path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate service ' + path.sep + 'my-svc from a child dir, gens under ' +
path.join('src', 'client', 'app'),
() => {
fs.mkdirsSync(path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '1'));
return new Promise(function (resolve) {
process.chdir('./src');
resolve();
})
.then(() => process.chdir('./client'))
.then(() => process.chdir('./app'))
.then(() => process.chdir('./1'))
.then(() => {
process.env.CWD = process.cwd();
return ng(['generate', 'service', path.sep + 'my-svc'])
})
.then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(true);
}, err => console.log('ERR: ', err));
});
it('ng generate service ..' + path.sep + 'my-svc from root dir will fail', () => {
return ng(['generate', 'service', '..' + path.sep + 'my-svc']).then(() => {
var testPath = path.join(root, 'tmp', 'foo', 'src', 'client', 'app', '..', 'my-svc.service.ts');
expect(existsSync(testPath)).to.equal(false);
});
});
});
angular-cli-0.0.34/tests/acceptance/github-pages-deploy.spec.js 0000664 0000000 0000000 00000017567 12707725453 0024420 0 ustar 00root root 0000000 0000000 /*eslint-disable no-console */
'use strict';
var ng = require('../helpers/ng');
var tmp = require('../helpers/tmp');
var conf = require('ember-cli/tests/helpers/conf');
var Promise = require('ember-cli/lib/ext/promise');
var fs = require('fs');
var path = require('path');
var chai = require('chai');
var sinon = require('sinon');
var ExecStub = require('../helpers/exec-stub');
var https = require('https');
const expect = chai.expect;
const fsReadFile = Promise.denodeify(fs.readFile);
const fsWriteFile = Promise.denodeify(fs.writeFile);
const fsMkdir = Promise.denodeify(fs.mkdir);
describe('Acceptance: ng github-pages:deploy', function() {
let execStub;
let project = 'foo',
initialBranch = 'master',
branch = 'gh-pages',
message = 'new gh-pages version',
remote = 'origin git@github.com:username/project.git (fetch)';
function setupDist() {
return fsMkdir('./dist')
.then(() => {
let indexHtml = path.join(process.cwd(), 'dist', 'index.html');
let indexData = `project \n