treeForPublic: function() {
var appEnv = this.app.env;
var publicFiles = new Funnel(this.app.trees.public);
this._requireBuildPackages();
fs.stat(
path.join(this.project.root, 'public', 'robots.txt'),
function(err, stats) {
if (stats && stats.isFile()) {
console.log(chalk.yellow('There is a robots.txt in /public and ENV specific robots.txt are ignored!'));
}
}
);
publicFiles = stew.rename(
publicFiles,
'robots-' + appEnv + '.txt',
'robots.txt'
);
return new Funnel(publicFiles, {
srcDir: '/',
destDir: '/'
});
},
module.exports = function(tree) {
var emberInflector = buildEmberInflector();
var loadInitializers = buildLoadInitializers();
var emberData = merge([tree, version()]);
var javascripts = merge([
emberInflector,
loadInitializers,
debugBuild('ember-data/initializers', 'app/initializers'),
debugBuild('ember-data/instance-initializers', 'app/instance-initializers'),
debugBuild('ember-data', emberData)
]);
var strippedJavascripts = merge([
emberInflector,
makeStrippedBuild('ember-data', emberData)
]);
var debug = collapse(javascripts, 'ember-data.js');
var production = collapse(strippedJavascripts, 'ember-data.prod.js');
var minified = stew.rename(minify(production), 'ember-data.prod.js', 'ember-data.min.js');
// Hack to get around https://github.com/emberjs/data/blob/v2.1.0/lib/ember-addon/index.js#L28
var emptySourcemapFile = fileCreator('ember-data.js.map', '');
return merge([debug, production, minified, emptySourcemapFile]);
};
this.d3Modules.forEach(function(packageName) {
var d3PathToSrc, srcTree;
// Import existing builds from node d3 packages, which are UMD packaged.
var packageBuildPath = path.join('build', packageName + '.js');
d3PathToSrc = path.join(d3PackagePath, 'node_modules', packageName);
try {
fs.statSync(path.join(d3PathToSrc)).isDirectory();
} catch(err) {
d3PathToSrc = lookupPackage(packageName);
}
try {
fs.statSync(path.join(d3PathToSrc, packageBuildPath)).isFile()
} catch(err) {
console.error('[ERROR] D3 Package (' + packageName + ') is not built as expected, cannot continue. Please report this as a bug.');
return;
}
var tree = new Funnel(d3PathToSrc, {
include: [packageBuildPath],
destDir: '/' + packageName,
annotation: 'Funnel: D3 Source [' + packageName + ']'
});
srcTree = new AMDDefineFilter(tree, packageName);
trees.push(rename(srcTree, function() {
return '/' + packageName + '/' + packageName + '.js';
}));
});
treeForVendor: function() {
var primerPath = path.join(__dirname, 'node_modules', 'primer');
var expandedPrimerPath = expand(path.join(primerPath, 'css', 'primer.css'));
var primerCSS = rename(find(expandedPrimerPath), function() {
return 'primer/primer.css';
});
return mergeTrees([primerCSS]);
},
treeForBrowserVendor: function(vendorTree) {
var trees = [];
var options = this.momentOptions;
if (vendorTree) {
trees.push(vendorTree);
}
trees.push(new Funnel(options.momentPath, {
destDir: 'moment',
include: [new RegExp(/\.js$/)],
exclude: ['tests', 'ender', 'package'].map(function(key) {
return new RegExp(key + '\.js$');
})
}));
if (Array.isArray(options.includeLocales) && options.includeLocales.length) {
var localeTree = new Funnel(options.momentPath, {
srcDir: 'locale',
destDir: 'moment/locales',
include: options.includeLocales.map(function(locale) {
return new RegExp(locale + '.js$');
})
});
trees.push(localeTree);
}
if (options.includeTimezone) {
var momentTimezonePath = path.dirname(require.resolve('moment-timezone'));
var timezonePath = [momentTimezonePath, 'builds'];
switch(options.includeTimezone) {
case 'all':
timezonePath.push('moment-timezone-with-data.min.js');
break;
case '2010-2020':
timezonePath.push('moment-timezone-with-data-2010-2020.min.js');
break;
case 'none':
timezonePath.push('moment-timezone.min.js');
break;
default:
throw new Error("ember-moment: Please specify the moment-timezone dataset to include as either 'all', '2010-2020', or 'none'.");
}
trees.push(rename(new Funnel(momentTimezonePath + '/builds', {
files: [timezonePath[timezonePath.length - 1]]
}), function(/*filepath*/) {
return 'moment-timezone/tz.js';
}));
}
return mergeTrees(trees);
}
this.d3Modules.forEach(function(pkg) {
if (!(pkg && pkg.path)) {
return;
}
var tree = new Funnel(pkg.path, {
include: [pkg.buildPath],
destDir: `/${ pkg.name}`,
annotation: `Funnel: D3 Source [${ pkg.name }]`
});
var srcTree = new RecastFilter(tree, pkg.name, rewriteAMDFunction);
trees.push(rename(srcTree, function() {
return `/${ pkg.name }/${ pkg.name }.js`;
}));
});
treeForStyles: function(tree) {
tree = this._super.treeForStyles.apply(this, [tree]);
var addonThemesDir = 'app/styles/ember-reveal-js/css/theme/source';
var addonThemeFiles = fs.readdirSync(addonThemesDir);
var addonThemes = Array.prototype.map.call(addonThemeFiles, function(addonTheme) {
return addonTheme.split('.')[0];
});
addonThemes.push('ember');
var addonThemesScss = Array.prototype.map.call(addonThemes, function(addonTheme) {
return '$themeName: \'' + addonTheme + '\';\n' +
'@import \'css/theme/source/' + addonTheme + '\';\n\n';
}).join('');
addonThemesScss = '\n/* BEGIN ember-reveal-js-addon-themes */\n' + addonThemesScss;
addonThemesScss += '/* END ember-reveal-js-addon-themes */\n';
var stylesTree = replace(tree, {
files: [
'app/styles/ember-reveal-js/ember-reveal-js-themes.scss'
],
pattern: {
match: /\/\*__ember-reveal-js-addon-themes__\*\//g,
replacement: addonThemesScss
}
});
var revealCssTree = new Funnel(unwatchedTree(path.dirname(require.resolve('reveal.js/package.json'))), {
srcDir: '/css',
destDir: '/app/styles/ember-reveal-js/css',
include: [
'reveal.scss',
'theme/**/*.scss'
]
});
var replaceCssTree = replace(revealCssTree, {
files: [
'app/styles/ember-reveal-js/css/theme/template/theme.scss',
'app/styles/ember-reveal-js/css/theme/source/*.scss'
],
patterns: [
{
match: /\.reveal/g,
replacement: '.#{$themeName}.reveal'
},
{
match: /body \{/g,
replacement: '.#{$themeName}.reveal {'
},
{
match: /\.\.\/\.\.\/lib\/font/g,
replacement: 'ember-reveal-js/lib/font'
}
]
});
replaceCssTree = replace(replaceCssTree, {
files: [
'app/styles/ember-reveal-js/css/reveal.scss'
],
patterns: [
{
match: /html, body,/g,
replacement: 'html.reveal, body.reveal,'
}
]
});
var revealPrintCssTree = new Funnel(unwatchedTree(path.dirname(require.resolve('reveal.js/package.json'))), {
srcDir: '/css/print',
destDir: '/app/styles/ember-reveal-js/css/print'
});
revealPrintCssTree = stew.rename(revealPrintCssTree, '.css', '.scss');
var fontCssTree = new Funnel(unwatchedTree(path.dirname(require.resolve('reveal.js/package.json'))), {
srcDir: '/lib/font',
destDir: '/app/styles/ember-reveal-js/lib/font',
files: [
'league-gothic/league-gothic.css',
'source-sans-pro/source-sans-pro.css'
]
});
var highlightJsTree = new Funnel(unwatchedTree(path.dirname(require.resolve('highlight.js/package.json'))), {
srcDir: '/styles',
destDir: '/app/styles/ember-reveal-js/highlight.js'
});
highlightJsTree = stew.rename(highlightJsTree, '.css', '.scss');
return mergeTrees([
stylesTree,
replaceCssTree,
fontCssTree,
revealPrintCssTree,
highlightJsTree
], {
overwrite: true
}
);
},
memberVariables: true, // parse class fields
typeAssertionModule: 'rtts_assert/rtts_assert',
// Don't use type assertions since this is partly transpiled by typescript
typeAssertions: false,
modules: 'commonjs'
};
var cjsTree = new TraceurCompiler(modulesTree, '.js', '.map', traceurOpts);
// Add the LICENSE file in each module
['angular2', 'benchmarks', 'benchmarks_external', 'benchpress', 'examples', 'rtts_assert'].forEach(
function(destDir) {
cjsTree = mergeTrees([cjsTree, new Funnel('.', {files: ['LICENSE'], destDir: destDir})]);
});
extras = new Funnel(modulesTree, {include: ['**/*.md', '**/*.png'], exclude: ['**/*.dart.md']});
extras = stew.rename(extras, 'README.js.md', 'README.md');
var BASE_PACKAGE_JSON = require('./package.json');
var COMMON_PACKAGE_JSON = {
version: BASE_PACKAGE_JSON.version,
homepage: BASE_PACKAGE_JSON.homepage,
bugs: BASE_PACKAGE_JSON.bugs,
license: BASE_PACKAGE_JSON.license,
contributors: BASE_PACKAGE_JSON.contributors,
dependencies: BASE_PACKAGE_JSON.dependencies,
devDependencies: {
"yargs": BASE_PACKAGE_JSON.devDependencies['yargs'],
"gulp-sourcemaps": BASE_PACKAGE_JSON.devDependencies['gulp-sourcemaps'],
"gulp-traceur": BASE_PACKAGE_JSON.devDependencies['gulp-traceur'],
"gulp": BASE_PACKAGE_JSON.devDependencies['gulp'],
"gulp-rename": BASE_PACKAGE_JSON.devDependencies['gulp-rename'],
},
_getAllD3Modules() {
return d3DepsForPackage('d3', this.parent.nodeModulesPath, this.ui);
},
treeForVendor(tree) {
var trees = [];
if (tree) {
var versionTree = new RecastFilter(tree, null, replaceVersionString, {
version: d3Version('d3', this.parent.nodeModulesPath)
});
trees.push(rename(versionTree, function() {
return path.posix.join('ember-d3', 'register-d3-version.js');
}));
}
this.d3Modules.forEach(function(pkg) {
if (!(pkg && pkg.path)) {
return;
}
var tree = new Funnel(pkg.path, {
include: [pkg.buildPath],
destDir: `/${ pkg.name}`,
annotation: `Funnel: D3 Source [${ pkg.name }]`
});
var srcTree = new RecastFilter(tree, pkg.name, rewriteAMDFunction);
modules: 'amd',
});
const appScript = Concat(babelScript, {
inputFiles: [
'**/*.js',
],
outputFile: '/app.js',
});
const compiledSass = new Sass(stylePaths, 'app.scss', 'app.css', {});
const optimizedCSS = new CssOptimizer(compiledSass);
const styles = new Autoprefixer(optimizedCSS);
if (process.env.EMBER_ENV === 'test') {
const testTree = rename('tests', 'index.html', 'test.html');
const testJs = Concat(testTree, {
inputFiles: ['**/*.js'],
outputFile: '/tests.js',
});
const testHTML = new Funnel(testTree, {
files: ['test.html'],
});
module.exports = new Merge([pubFiles, styles, appScript, vendor, testJs, testHTML]);
} else {
module.exports = new Merge([pubFiles, styles, appScript, vendor]);
}
function lowercaseTree(tree) {
return rename(tree, function(filepath) {
return filepath.toLocaleLowerCase();
});
}
// Use Traceur to transpile original sources to ES6
var es6DevTree = new TraceurCompiler(modulesTree, '.es6', {
sourceMaps: true,
annotations: true, // parse annotations
types: true, // parse types
script: false, // parse as a module
memberVariables: true, // parse class fields
modules: 'instantiate',
typeAssertionModule: 'rtts_assert/rtts_assert',
typeAssertions: true,
outputLanguage: 'es6'
});
// Munge the filenames since we use an '.es6' extension
es6DevTree = stew.rename(es6DevTree, function(relativePath) {
return relativePath.replace(/\.(js|es6)\.map$/, '.map').replace(/\.js$/, '.es6');
});
// Call Traceur again to lower the ES6 build tree to ES5
var es5DevTree = new TraceurCompiler(es6DevTree, '.js', {modules: 'instantiate', sourceMaps: true});
es5DevTree = stew.rename(es5DevTree, '.es6.map', '.js.map');
// Now we add a few more files to the es6 tree that Traceur should not see
['angular2', 'benchmarks', 'benchmarks_external', 'benchpress', 'examples', 'rtts_assert'].forEach(
function(destDir) {
var extras = new Funnel('tools/build', {files: ['es5build.js'], destDir: destDir});
es6DevTree = mergeTrees([es6DevTree, extras]);
});
var vendorScriptsTree = flatten(new Funnel('.', {
files: [
tests: false,
trees: {
app: new EmptyTree(),
// I'm creating these empty files because badly behaved
// preprocessors explode if they aren't present, even though we
// aren't going to use them.
styles: new EmptyTree(['app.css', 'app.scss']),
templates: new EmptyTree(),
public: new EmptyTree()
}
});
var internal = stew.mv(path.join(__dirname, '..', 'lib'), 'giftwrap');
var js = concat(merge([app.appAndDependencies(), internal]), {
header: '(function(){',
headerFiles: [
app.bowerDirectory + '/loader.js/loader.js']
.concat(app.legacyFilesToAppend)
.concat(['vendor/addons.js']),
inputFiles: ['giftwrap/**/*.js'],
outputFile: 'addons.js',
footer: "window.GiftWrap = require('giftwrap-internal/container-injector');})();",
description: 'Concat: giftwrap js'
});
var styles = stew.find(app.styles(), 'assets/vendor.css');
styles = stew.rename(styles, 'assets/vendor.css', 'addons.css');
module.exports = derequire(merge([styles, js]));
tool = browserify(tool, {
entries: ['./dev/browserEntry.js'],
debug: true
});
tool = concat(tool, {
outputFile: '/where-eval.js',
inputFiles: ['*.js'],
sourceMapConfig: { enabled: true },
});
tool = pickFiles(tool, {
include: ['where-eval.js', 'where-eval.map'],
});
var toolMin = rename(tool, 'where-eval.js', 'where-eval-min.js');
toolMin = uglify(toolMin, {
mangle: true,
compress: true
});
var all = mergeTrees([
toolMin,
tool,
tests,
testsStatic
]);
module.exports = all;
var compileModules = require('broccoli-es6-module-transpiler');
var AMDFormatter = require('es6-module-transpiler-amd-formatter');
var ES6Modules = require('broccoli-es6modules');
var concat = require('broccoli-sourcemap-concat');
var path = require('path');
var mv = stew.mv;
var find = stew.find;
var log = stew.log;
var lib = find('lib');
var tests = find('tests');
var testIndex = find('tests/{index.html}');
var qunit = find(path.dirname(require.resolve('qunitjs')) + '/qunit.{js,css}');
var loader = find(path.dirname(require.resolve('loader.js')) + '/{loader.js}');
qunit = stew.rename(qunit, path.basename);
loader = stew.rename(loader, path.basename);
// folded bundle
var bundled = compileModules(lib, {
format: 'bundle',
entry: 'backburner.umd.js',
output: 'backburner.js'
});
var amd = new ES6Modules(find(mv(lib, 'lib/', '/'), '!*.umd.js'), {
esperantoOptions: {
absolutePaths: true,
strict: true
}
});