honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore(tools): remove rtts from the repo. 

Closes #4107
This commit is contained in:
Rado Kirov 2015-09-09 19:00:22 -07:00 committed by Rado Kirov
parent 6a4a8a60ab
commit 63141ab9ab
15 changed files with 8 additions and 848 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
karma-js.conf.js
View File

@ -30,7 +30,6 @@ module.exports = function(config) {
exclude: [
'dist/js/dev/es5/**/e2e_test/**',
'dist/js/dev/es5/rtts_assert/**',
'dist/angular1_router.js'
],

1
modules/angular2/package.json
View File

@ -10,7 +10,6 @@
"dependencies": {
"traceur": "<%= packageJson.dependencies.traceur %>",
"reflect-metadata": "<%= packageJson.dependencies['reflect-metadata'] %>",
"rtts_assert": "<%= packageJson.version %>",
"rx": "<%= packageJson.dependencies['rx'] %>",
"zone.js": "<%= packageJson.dependencies['zone.js'] %>"
},

4
modules/angular2/src/test_lib/test_lib.ts
View File

@ -392,14 +392,12 @@ export class SpyObject {
return object;
}
rttsAssert(value) { return true; }
_createGuinnessCompatibleSpy(name): GuinessCompatibleSpy {
var newSpy: GuinessCompatibleSpy = <any>jasmine.createSpy(name);
newSpy.andCallFake = <any>newSpy.and.callFake;
newSpy.andReturn = <any>newSpy.and.returnValue;
newSpy.reset = <any>newSpy.calls.reset;
// return null by default to satisfy our rtts asserts
// revisit return null here (previously needed for rtts_assert).
newSpy.and.returnValue(null);
return newSpy;
}

3
modules/angular2/test/test_lib/test_lib_spec.ts
View File

@ -125,8 +125,7 @@ export function main() {
() => { expect(() => spyObj.someFunc()).not.toThrow(); });
it('should create a default spy that does not fail for numbers', () => {
// Need to return null instead of undefined so that rtts assert does
// not fail...
// Previously needed for rtts_assert. Revisit this behavior.
expect(spyObj.someFunc()).toBe(null);
});
});

1
modules/angular2_material/package.json
View File

@ -10,7 +10,6 @@
"dependencies": {
"angular2": "<%= packageJson.version %>",
"traceur": "<%= packageJson.dependencies.traceur %>",
"rtts_assert": "<%= packageJson.version %>",
"rx": "<%= packageJson.dependencies['rx'] %>",
"zone.js": "<%= packageJson.dependencies['zone.js'] %>"
},

2
modules/benchpress/src/webdriver/selenium_webdriver_adapter.ts
View File

@ -17,7 +17,7 @@ export class SeleniumWebDriverAdapter extends WebDriverAdapter {
thenable.then(
// selenium-webdriver uses an own Node.js context,
// so we need to convert data into objects of this context.
// (e.g. otherwise instanceof checks of rtts_assert would fail)
// Previously needed for rtts_asserts.
(data) => completer.resolve(convertToLocalProcess(data)), completer.reject);
return completer.promise;
}

60
modules/rtts_assert/README.js.md
View File

@ -1,60 +0,0 @@
# Rtts-Assert
A run-time type assertion library for JavaScript.
Designed to be used with [Traceur](https://github.com/google/traceur-compiler).
All sources are in ES6 format. They don't depend on any runtime
and can be used by any modern ES6 -> ES5 transpiler.
As a convenience, we provide you with `es5build.js`, a script to transpile the sources into es5
using [Google Traceur](https://github.com/google/traceur-compiler/).
License: Apache MIT 2.0
## API
```
// Asserting APIs:
// - generated by Traceur (based on type annotations)
// - can be also used in tests for instance
assert.type(something, Type);
assert.returnType(returnValue, Type);
assert.argumentTypes(firstArg, Type, secondArg, Type);
// this can be used anywhere in the code
// (useful inside test, when we don't wanna define an interface)
assert(value).is(...)
// Custom type assert:
// - i have a custom type
// - adding an assert methods
assert.define(MyUser, function(value) {
assert(value).is(Type, Type2); // or
assert(value, 'name').is(assert.string);
assert(value, 'contact').is(assert.structure({
email: assert.string,
cell: assert.string
}));
assert(value, 'contacts').is(assert.arrayOf(assert.structure({email: assert.string})));
});
// Define interface (an empty type with assert method)
// - returns an empty class with assert method
var Email = assert.define('IEmail', function(value) {
assert(value).is(String);
if (value.indexOf('@') !== -1) {
assert.fail('has to contain "@"');
}
});
// Predefined types
assert.string
assert.number
assert.boolean
assert.arrayOf(...types)
assert.structure(object)
```

18
modules/rtts_assert/package.json
View File

@ -1,18 +0,0 @@
{
"name": "rtts_assert",
"version": "<%= packageJson.version %>",
"description": "A run-time type assertion library for JavaScript",
"homepage": "<%= packageJson.homepage %>",
"bugs": "<%= packageJson.bugs %>",
"contributors": <%= JSON.stringify(packageJson.contributors) %>,
"license": "<%= packageJson.license %>",
"repository": <%= JSON.stringify(packageJson.repository) %>,
"devDependencies": {
"yargs": "2.3.*",
"gulp-sourcemaps": "1.3.*",
"gulp-traceur": "0.16.*",
"gulp": "^3.8.8",
"gulp-rename": "^1.2.0",
"through2": "^0.6.1"
}
}

1
modules/rtts_assert/rtts_assert.ts
View File

@ -1 +0,0 @@
export * from './src/rtts_assert';

369
modules/rtts_assert/src/rtts_assert.ts
View File

@ -1,369 +0,0 @@
var _global = typeof window === 'object' ? window : global;
// TODO(vojta):
// - extract into multiple files
// - different error types
// - simplify/humanize error messages
// - throw when invalid input (such as odd number of args into assert.argumentTypes)
var POSITION_NAME = ['', '1st', '2nd', '3rd'];
function argPositionName(i) {
var position = (i / 2) + 1;
return POSITION_NAME[position] || (position + 'th');
}
var primitives;
var genericType;
if (typeof _global['$traceurRuntime'] === 'object') {
primitives = _global['$traceurRuntime'].type;
genericType = _global['$traceurRuntime'].genericType;
} else {
// Allow to work without traceur runtime as well!
primitives = {
any: {name: 'any'},
boolean: {name: 'boolean'},
number: {name: 'number'},
string: {name: 'string'},
symbol: {name: 'symbol'}, void: {name: 'void'}
};
genericType = function(type, args) {
return { type: type, args: args }
}
}
Object.keys(primitives).forEach(function(name) { primitives[name].__assertName = name; });
export function proxy() {}
function assertArgumentTypes(...params) {
var actual, type;
var currentArgErrors;
var errors = [];
var msg;
for (var i = 0, l = params.length; i < l; i = i + 2) {
actual = params[i];
type = params[i + 1];
currentArgErrors = [];
// currentStack = [];
//
if (!isType(actual, type, currentArgErrors)) {
// console.log(JSON.stringify(errors, null, ' '));
// TODO(vojta): print "an instance of" only if T starts with uppercase.
errors.push(argPositionName(i) + ' argument has to be an instance of ' + prettyPrint(type) +
', got ' + prettyPrint(actual));
if (currentArgErrors.length) {
errors.push(currentArgErrors);
}
}
}
if (errors.length) {
throw new Error('Invalid arguments given!\n' + formatErrors(errors));
}
}
function prettyPrint(value, depth?) {
if (typeof(depth) === 'undefined') {
depth = 0;
}
if (depth++ > 3) {
return '[...]';
}
if (typeof value === 'undefined') {
return 'undefined';
}
if (typeof value === 'string') {
return '"' + value + '"';
}
if (typeof value === 'boolean') {
return value.toString();
}
if (value === null) {
return 'null';
}
if (typeof value === 'object') {
if (value.__assertName) {
return value.__assertName;
}
if (value.map && typeof value.map === 'function') {
return '[' + value.map((v) => prettyPrint(v, depth)).join(', ') + ']';
}
var properties = Object.keys(value);
var suffix = '}';
if (properties.length > 20) {
properties.length = 20;
suffix = ', ... }';
}
return '{' + properties.map((p) => p + ': ' + prettyPrint(value[p], depth)).join(', ') + suffix;
}
return value.__assertName || value.name || value.toString();
}
function isType(value, T, errors) {
if (T && T.type) {
// needed for generics.
// TODO(tbosch): read out T.args and do assertions based on them as well!
T = T.type;
}
if (T === primitives.void) {
return typeof value === 'undefined';
}
if (_isProxy(value)) {
return true;
}
if (T === primitives.any || value === null) {
return true;
}
if (T === primitives.string) {
return typeof value === 'string';
}
if (T === primitives.number) {
return typeof value === 'number';
}
if (T === primitives.boolean) {
return typeof value === 'boolean';
}
// var parentStack = currentStack;
// currentStack = [];
// shouldnt this create new stack?
if (typeof T.assert === 'function') {
var parentStack = currentStack;
var isValid;
currentStack = errors;
try {
isValid = T.assert(value);
} catch (e) {
fail(e.message);
isValid = false;
}
currentStack = parentStack;
if (typeof isValid === 'undefined') {
isValid = errors.length === 0;
}
return isValid;
// if (!currentStack.length) {
// currentStack = parentStack;
// return [];
// }
// var res = currentStack;
// currentStack = parentStack;
// return ['not instance of ' + prettyPrint(T), res];
}
return value instanceof T;
// if (!(value instanceof T)) {
// fail('not instance of ' + prettyPrint(T));
// }
// var res = currentStack;
// currentStack = parentStack;
// return res;
}
function _isProxy(obj) {
if (!obj || !obj.constructor || !obj.constructor.annotations) return false;
return obj.constructor.annotations.filter((a) => a instanceof proxy).length > 0;
}
function formatErrors(errors, indent = ' ') {
return errors.map((e) => {
if (typeof e === 'string') return indent + '- ' + e;
return formatErrors(e, indent + ' ');
})
.join('\n');
}
// assert a type of given value and throw if does not pass
var type: any =
function(actual, T) {
var errors = [];
// currentStack = [];
if (!isType(actual, T, errors)) {
// console.log(JSON.stringify(errors, null, ' '));
// TODO(vojta): print "an instance of" only if T starts with uppercase.
var msg = 'Expected an instance of ' + prettyPrint(T) + ', got ' + prettyPrint(actual) + '!';
if (errors.length) {
msg += '\n' + formatErrors(errors);
}
throw new Error(msg);
}
return actual;
}
function returnType(actual, T) {
var errors = [];
// currentStack = [];
if (!isType(actual, T, errors)) {
// console.log(JSON.stringify(errors, null, ' '));
// TODO(vojta): print "an instance of" only if T starts with uppercase.
var msg = 'Expected to return an instance of ' + prettyPrint(T) + ', got ' +
prettyPrint(actual) + '!';
if (errors.length) {
msg += '\n' + formatErrors(errors);
}
throw new Error(msg);
}
return actual;
}
// TODO(vojta): define these with DSL?
var string = type.string = define('string', function(value) { return typeof value === 'string'; });
var boolean = type.boolean =
define('boolean', function(value) { return typeof value === 'boolean'; });
var number = type.number = define('number', function(value) { return typeof value === 'number'; });
function arrayOf(...types) {
return assert.define('array of ' + types.map(prettyPrint).join('/'), function(value) {
if (assert(value).is(Array)) {
for (var i = 0; i < value.length; i++) {
assert(value[i]).is(...types);
}
}
});
}
function structure(definition) {
var properties = Object.keys(definition);
return assert.define('object with properties ' + properties.join(', '), function(value) {
if (assert(value).is(Object)) {
for (var i = 0; i < properties.length; i++) {
var property = properties[i];
assert(value[property]).is(definition[property]);
}
}
})
}
// I'm sorry, bad global state... to make the API nice ;-)
var currentStack = [];
function fail(message) {
currentStack.push(message);
}
function define(classOrName, check) {
var cls = classOrName;
if (typeof classOrName === 'string') {
cls = function() {};
cls.__assertName = classOrName;
}
cls.assert = function(value) {
// var parentStack = currentStack;
// currentStack = [];
return check(value);
// if (currentStack.length) {
// parentStack.push(currentStack)
// }
// currentStack = parentStack;
};
return cls;
}
var assert: any = function(value) {
return {
is: function is(...types) {
// var errors = []
var allErrors = [];
var errors;
for (var i = 0; i < types.length; i++) {
var type = types[i];
errors = [];
if (isType(value, type, errors)) {
return true;
}
// if no errors, merge multiple "is not instance of " into x/y/z ?
allErrors.push(prettyPrint(value) + ' is not instance of ' + prettyPrint(type));
if (errors.length) {
allErrors.push(errors);
}
}
// if (types.length > 1) {
// currentStack.push(['has to be ' + types.map(prettyPrint).join(' or '),
// ...allErrors]);
// } else {
currentStack.push(...allErrors);
// }
return false;
}
};
};
// PUBLIC API
// asserting API
// throw if no type provided
assert.type = type;
for (var prop in primitives) {
assert.type[prop] = primitives[prop];
}
assert.genericType = genericType;
// throw if odd number of args
assert.argumentTypes = assertArgumentTypes;
assert.returnType = returnType;
// define AP;
assert.define = define;
assert.fail = fail;
// primitive value type;
assert.string = string;
assert.number = number;
assert.boolean = boolean;
// custom types
assert.arrayOf = arrayOf;
assert.structure = structure;
export {assert}

367
modules/rtts_assert/test/rtts_assert_spec.ts
View File

@ -1,367 +0,0 @@
// # Assert.js
// A run-time type assertion library for JavaScript. Designed to be used with
// [Traceur](https://github.com/google/traceur-compiler).
import {assert} from '../rtts_assert';
// - [Basic Type Check](#basic-type-check)
// - [Custom Check](#custom-check)
// - [Primitive Values](#primitive-values)
// - [Describing more complex types](#describing-more-complex-types)
// - [assert.arrayOf](#assert-arrayof)
// - [assert.structure](#assert-structure)
// - [Integrating with Traceur](#integrating-with-traceur)
// Note: `assert` gets automatically included by traceur!
export function main() {
return;
describe('prettyPrint', () => {
function Type() {}
it('should limit the number of printed properties', () => {
var o = {};
for (var i = 0; i < 100; i++) {
o['p_' + i] = i;
}
try {
assert.type(o, Type);
throw 'fail!';
} catch (e) {
expect(e.message.indexOf('p_0')).toBeGreaterThan(-1);
expect(e.message.indexOf('...')).toBeGreaterThan(-1);
expect(e.message.indexOf('p_20')).toEqual(-1);
}
});
it('should limit the depth of printed properties', () => {
var o = {l1: {l2: {l3: {l4: {l5: {l6: 'deep'}}}}}};
expect(() => { assert.type(o, Type); })
.toThrowError('Expected an instance of Type, got {l1: {l2: {l3: {l4: [...]}}}}!');
});
});
// ## Basic Type Check
// By default, `instanceof` is used to check the type.
//
// Note that you can use `assert.type()` in unit tests or anywhere in your code.
// Most of the time, you will use it with Traceur.
// Jump to the [Traceur section](#integrating-with-traceur) to see an example of that.
describe('basic type check', function() {
function Type() {}
it('should pass', function() { assert.type(new Type(), Type); });
it('should fail', function() {
expect(() => assert.type(123, Type)).toThrowError('Expected an instance of Type, got 123!');
});
it('should allow null', function() { assert.type(null, Type); });
});
// ## Custom Check
// Often, `instanceof` is not flexible enough.
// In that case, your type can define its own `assert` method which will be used instead.
//
// See [Describing More Complex Types](#describing-more-complex-types) for examples how to
// define custom checks using `assert.define()`.
describe('custom check', function() {
function Type() {}
// the basic check can just return true/false, without specifying any reason
it('should pass when returns true', function() {
(<any>Type).assert = function(value) { return true; };
assert.type({}, Type);
});
it('should fail when returns false', function() {
(<any>Type).assert = function(value) { return false; };
expect(() => assert.type({}, Type)).toThrowError('Expected an instance of Type, got {}!');
});
// Using `assert.fail()` allows to report even multiple errors.
it('should fail when calls assert.fail()', function() {
(<any>Type).assert = function(value) {
assert.fail('not smart enough');
assert.fail('not blue enough');
};
expect(() => assert.type({}, Type))
.toThrowError('Expected an instance of Type, got {}!\n' +
' - not smart enough\n' +
' - not blue enough');
});
it('should fail when throws an exception', function() {
(<any>Type).assert = function(value) { throw new Error('not long enough'); };
expect(function() { assert.type(12345, Type); })
.toThrowError('Expected an instance of Type, got 12345!\n' +
' - not long enough');
});
});
// ## Primitive Values
// You don't want to check primitive values (such as strings, numbers, or booleans) using `typeof`
// rather than
// `instanceof`.
//
// Again, you probably won't write this code and rather use Traceur to do it for you, simply based
// on type annotations.
describe('primitive value check', function() {
var primitive = global['$traceurRuntime'].type;
describe('string', function() {
it('should pass', function() { assert.type('xxx', primitive.string); });
it('should fail', function() {
expect(() => assert.type(12345, primitive.string))
.toThrowError('Expected an instance of string, got 12345!');
});
it('should allow null', function() { assert.type(null, primitive.string); });
});
describe('number', function() {
it('should pass', function() { assert.type(123, primitive.number); });
it('should fail', function() {
expect(() => assert.type(false, primitive.number))
.toThrowError('Expected an instance of number, got false!');
});
it('should allow null', function() { assert.type(null, primitive.number); });
});
describe('boolean', function() {
it('should pass', function() {
expect(assert.type(true, primitive.boolean)).toEqual(true);
expect(assert.type(false, primitive.boolean)).toEqual(false);
});
it('should fail', function() {
expect(() => assert.type(123, primitive.boolean))
.toThrowError('Expected an instance of boolean, got 123!');
});
it('should allow null', function() { assert.type(null, primitive.boolean); });
});
});
// ## Describing more complex types
//
// Often, a simple type check using `instanceof` or `typeof` is not enough.
// That's why you can define custom checks using this DSL.
// The goal was to make them easy to compose and as descriptive as possible.
// Of course you can write your own DSL on the top of this.
describe('define', function() {
// If the first argument to `assert.define()` is a type (function), it will define `assert`
// method on that function.
//
// In this example, being a type of Type means being a either a function or object.
it('should define assert for an existing type', function() {
function Type() {}
assert.define(Type, function(value) { assert(value).is(Function, Object); });
assert.type({}, Type);
assert.type(function() {}, Type);
expect(() => assert.type('str', Type))
.toThrowError('Expected an instance of Type, got "str"!\n' +
' - "str" is not instance of Function\n' +
' - "str" is not instance of Object');
});
// If the first argument to `assert.define()` is a string,
// it will create an interface - basically an empty class with `assert` method.
it('should define an interface', function() {
var User = assert.define('MyUser', function(user) { assert(user).is(Object); });
assert.type({}, User);
expect(() => assert.type(12345, User))
.toThrowError('Expected an instance of MyUser, got 12345!\n' +
' - 12345 is not instance of Object');
});
// Here are a couple of more APIs to describe your custom types...
//
// ### assert.arrayOf
// Checks if the value is an array and if so, it checks whether all the items are one the given
// types.
// These types can be composed types, not just simple ones.
describe('arrayOf', function() {
var Titles = assert.define('ListOfTitles', function(value) {
assert(value).is(assert.arrayOf(assert.string, assert.number));
});
it('should pass', function() { assert.type(['one', 55, 'two'], Titles); });
it('should fail when non-array given', function() {
expect(() => assert.type('foo', Titles))
.toThrowError('Expected an instance of ListOfTitles, got "foo"!\n' +
' - "foo" is not instance of array of string/number\n' +
' - "foo" is not instance of Array');
});
it('should fail when an invalid item in the array', function() {
expect(() => assert.type(['aaa', true], Titles))
.toThrowError('Expected an instance of ListOfTitles, got ["aaa", true]!\n' +
' - ["aaa", true] is not instance of array of string/number\n' +
' - true is not instance of string\n' +
' - true is not instance of number');
});
});
// ### assert.structure
// Similar to `assert.arrayOf` which checks a content of an array,
// `assert.structure` checks if the value is an object with specific properties.
describe('structure', function() {
var User = assert.define('MyUser', function(value) {
assert(value).is(assert.structure({name: assert.string, age: assert.number}));
});
it('should pass', function() { assert.type({name: 'Vojta', age: 28}, User); });
it('should fail when non-object given', function() {
expect(() => assert.type(123, User))
.toThrowError('Expected an instance of MyUser, got 123!\n' +
' - 123 is not instance of object with properties name, age\n' +
' - 123 is not instance of Object');
});
it('should fail when an invalid property', function() {
expect(() => assert.type({name: 'Vojta', age: true}, User))
.toThrowError(
'Expected an instance of MyUser, got {name: "Vojta", age: true}!\n' +
' - {name: "Vojta", age: true} is not instance of object with properties name, age\n' +
' - true is not instance of number');
});
});
});
// ## Integrating with Traceur
//
// Manually calling `assert.type()` in your code is cumbersome. Most of the time, you'll want to
// have Traceur add the calls to `assert.type()` to your code based on type annotations.
//
// This has several advantages:
// - it's shorter and nicer,
// - you can easily ignore it when generating production code.
//
// You'll need to run Traceur with `--types=true --type-assertions=true
// --type-assertion-module="path/to/assert"`.
describe('Traceur', function() {
describe('arguments', function() {
function reverse(str: string) { return str ? reverse(str.substring(1)) + str[0] : '' }
it('should pass', function() { expect(reverse('angular')).toEqual('ralugna'); });
it('should fail', function() {
expect(() => reverse(<any>123))
.toThrowError('Invalid arguments given!\n' +
' - 1st argument has to be an instance of string, got 123');
});
});
describe('return value', function() {
function foo(bar): number { return bar; }
it('should pass', function() { expect(foo(123)).toEqual(123); });
it('should fail', function() {
expect(() => foo('bar'))
.toThrowError('Expected to return an instance of number, got "bar"!');
});
});
describe('variables', function() {
it('should pass', function() { var count: number = 1; });
it('should fail', function() {
expect(() => { var count: number = <any>true; })
.toThrowError('Expected an instance of number, got true!');
});
});
describe('void', function() {
function foo(bar?): void { return bar; }
it('should pass when not defined', function() {
function nonReturn(): void {}
function returnNothing(): void { return; }
function returnUndefined(): void { return undefined; }
foo();
foo(undefined);
nonReturn();
returnNothing();
returnUndefined();
});
it('should fail when a value returned', function() {
expect(() => foo('bar')).toThrowError('Expected to return an instance of void, got "bar"!');
});
it('should fail when null returned', function() {
expect(() => foo(null)).toThrowError('Expected to return an instance of void, got null!');
});
});
describe('generics', function() {
it('should pass', function() { var list: string[] = []; });
// TODO(tbosch): add assertions based on generics to rtts_assert
});
});
}

14
scripts/publish/npm_publish.sh
View File

@ -14,19 +14,6 @@ rm -fr $NPM_DIR
FILES='!(test|e2e_test|docs)'
DTS_FILES='*.d.ts'
function publishRttsAssert {
NAME='rtts_assert'
PUBLISH_DIR=$NPM_DIR/$NAME
rm -fr $PUBLISH_DIR
mkdir -p $PUBLISH_DIR
mkdir -p $PUBLISH_DIR/es6
cp -r $ROOT_DIR/dist/js/prod/es6/$NAME/$FILES $PUBLISH_DIR/es6
cp -r $ROOT_DIR/dist/js/cjs/$NAME/$FILES $PUBLISH_DIR
npm publish $PUBLISH_DIR
}
function publishModule {
NAME=$1
PUBLISH_DIR=$NPM_DIR/$NAME
@ -65,6 +52,5 @@ function publishModule {
npm publish $PUBLISH_DIR
}
publishRttsAssert
publishModule angular2
publishModule benchpress

6
tools/broccoli/trees/browser_tree.ts
View File

@ -131,10 +131,8 @@ module.exports = function makeBrowserTree(options, destinationPath) {
});
// Now we add a few more files to the es6 tree that the es5 tree should not see
['angular2', 'rtts_assert'].forEach(function(destDir) {
var extras = new Funnel('tools/build', {files: ['es5build.js'], destDir: destDir});
es6Tree = mergeTrees([es6Tree, extras]);
});
var extras = new Funnel('tools/build', {files: ['es5build.js'], destDir: 'angular2'});
es6Tree = mergeTrees([es6Tree, extras]);
var vendorScriptsTree = flatten(new Funnel('.', {
files: [

5
tools/broccoli/trees/dart_tree.ts
View File

@ -14,7 +14,6 @@ import dartfmt from '../broccoli-dartfmt';
import replace from '../broccoli-replace';
var global_excludes = [
'rtts_assert/**/*',
'angular2/http*',
'angular2/src/http/**/*',
'angular2/test/http/**/*',
@ -57,7 +56,6 @@ function stripModulePrefix(relativePath: string): string {
}
function getSourceTree() {
// Transpile everything in 'modules' except for rtts_assertions.
var tsInputTree = modulesFunnel(['**/*.js', '**/*.ts', '**/*.dart'], ['angular1_router/**/*']);
var transpiled = ts2dart(tsInputTree, {
generateLibraryName: true,
@ -149,8 +147,7 @@ function getDocsTree() {
var licenses = new MultiCopy('', {
srcPath: 'LICENSE',
targetPatterns: ['modules/*'],
exclude:
['*/rtts_assert', '*/angular2/src/http', '*/upgrade', '*/angular1_router'] // Not in dart.
exclude: ['*/angular2/src/http', '*/upgrade', '*/angular1_router'] // Not in dart.
});
licenses = stew.rename(licenses, stripModulePrefix);

4
tools/broccoli/trees/node_tree.ts
View File

@ -14,10 +14,10 @@ var projectRootDir = path.normalize(path.join(__dirname, '..', '..', '..', '..')
module.exports = function makeNodeTree(destinationPath) {
// list of npm packages that this build will create
var outputPackages = ['angular2', 'benchpress', 'rtts_assert'];
var outputPackages = ['angular2', 'benchpress'];
var modulesTree = new Funnel('modules', {
include: ['angular2/**', 'benchpress/**', 'rtts_assert/**', '**/e2e_test/**'],
include: ['angular2/**', 'benchpress/**', '**/e2e_test/**'],
exclude: [
// the following code and tests are not compatible with CJS/node environment
'angular2/test/core/zone/**',