const path = require('path')
const webpack = require('webpack')
const HtmlWebpackPlugin = require('html-webpack-plugin')
const ExtractTextPlugin = require('extract-text-webpack-plugin')
const project = require('../project.config')
const inProject = path.resolve.bind(path, project.basePath)
const inProjectSrc = file => inProject(project.srcDir, file)
const __DEV__ = project.env === 'development'
const __TEST__ = project.env === 'test'
const __PROD__ = project.env === 'production'
const __STG__ = project.env === 'staging'
const config = {
entry: {
normalize: [
inProjectSrc('normalize'),
],
main: [
inProjectSrc(project.main),
],
},
devtool: project.sourcemaps ? 'source-map' : false,
output: {
path: inProject(project.outDir),
filename: '[name].js',
publicPath: project.publicPath,
},
resolve: {
modules: [
var PATH = require('path'),
environ = require('../environ'),
join = PATH.join,
resolve = PATH.resolve.bind(null, __dirname),
PRJ_TECHS = resolve('../techs/'),
BEMBL_TECHS = environ.getLibPath('bem-bl', 'blocks-common/i-bem/bem/techs');
exports.getTechs = function() {
return {
'deps.js' : 'deps.js',
'css' : 'css',
'ie.css' : 'ie.css',
'ie6.css' : 'ie6.css',
'ie7.css' : 'ie7.css',
'ie8.css' : 'ie8.css',
'ie9.css' : 'ie9.css',
'title.txt' : 'title.txt',
'desc.wiki' : '',
'i18n.title.txt' : join(PRJ_TECHS, 'i18n.title.txt'),
'i18n.desc.wiki' : join(PRJ_TECHS, 'i18n.desc.wiki'),
'bemhtml' : join(BEMBL_TECHS, 'bemhtml.js'),
'js' : join(BEMBL_TECHS, 'js.js')
};
};
import { fromNode as fn } from 'bluebird';
import { resolve } from 'path';
import * as kbnTestServer from '../../test_utils/kbn_server';
const destructiveMethods = ['POST', 'PUT', 'DELETE'];
const src = resolve.bind(null, __dirname, '../../../src');
const xsrfHeader = 'kbn-xsrf';
const versionHeader = 'kbn-version';
const testPath = '/xsrf/test/route';
const whitelistedTestPath = '/xsrf/test/route/whitelisted';
const actualVersion = require(src('../package.json')).version;
describe('xsrf request filter', function () {
function inject(kbnServer, opts) {
return fn(cb => {
kbnTestServer.makeRequest(kbnServer, opts, (resp) => {
cb(null, resp);
});
});
}
const makeServer = async function () {
const kbnServer = kbnTestServer.createServer({
server: {
xsrf: {
disableProtection: false,
whitelist: [whitelistedTestPath]
}
}
});
resolve : function(){return pathological.modifier(path.resolve.apply(pathological,arguments));},
// site assets
assets: src('assets'),
static: src('static'),
// site data
data: src('data'),
// site content and templates
content: src('content'),
templates: src('templates'),
partials: src('templates/partials'),
layouts: src('templates/layouts'),
pages: src('templates/pages'),
// dest path
dest: path.resolve.bind(path, __dirname, '../_gh_pages'),
src: src()
};
// create src path from `memoize-path`
function src(base) {
return function(fp) {
return fp ? cwd(base)(fp)() : cwd(base)();
};
}
/**
* Middleware
*/
app.onPermalink(/./, function(file, next) {
var requirejs = require('requirejs');
var path = require('path');
var View = requirejs('extensions/views/view');
var templater = require('../mixins/templater');
var pr = path.resolve.bind(path, __dirname);
var headTemplate = pr('../templates/page-components/head.html');
var bodyEndTemplate = pr('../templates/page-components/body-end.html');
var navigationTemplate = pr('../templates/page-components/navigation.html');
var govukTemplate = pr('../templates/page-components/govuk_template.html');
var footerTopTemplate = pr('../templates/page-components/footer_top.html');
var footerLinksTemplate = pr('../templates/page-components/footer_links.html');
var reportAProblemTemplate = pr('../templates/page-components/report_a_problem.html');
var cookieMessageTemplate = pr('../templates/page-components/cookie_message.html');
var contentTemplate = pr('../templates/page-components/content.html');
/**
* Renders a page in GOV.UK style using govuk_template.
* Does not use jsdom itself but renders template directly because jsdom
* does not seem to play nicely with <script> tags.
*/
module.exports = View.extend(templater).extend({
templatePath: govukTemplate,
templateType: 'mustache',
bodyEndTemplate: bodyEndTemplate,
reportAProblemTemplate: reportAProblemTemplate,
getContent: function () {
'use strict';
require('mocha');
var fs = require('fs');
var path = require('path');
var assert = require('assert');
var rimraf = require('rimraf');
var eachSeries = require('async-each-series');
var exists = require('fs-exists-sync');
var through = require('through2');
var Target = require('expand-target');
var App = require('base');
var target = require('..');
var app;
var fixtures = path.resolve.bind(path, __dirname, 'fixtures');
var actual = path.resolve.bind(path, __dirname, 'actual');
function base(cb) {
return through.obj(function(file, enc, next) {
var str = file.contents.toString();
cb(file, str, next);
});
}
describe('target.generate', function() {
beforeEach(function() {
app = new App({isApp: true});
app.use(target());
});
var assert = require('assert'),
fs = require('fs'),
path = require('path'),
read = fs.readFileSync,
sass = process.env.NODESASS_COV ? require('../lib-cov') : require('../lib'),
fixture = path.join.bind(null, __dirname, 'fixtures'),
resolveFixture = path.resolve.bind(null, __dirname, 'fixtures');
describe('api', function() {
describe('.render(options)', function() {
it('should compile sass to css with file', function(done) {
var expected = read(fixture('simple/expected.css'), 'utf8').trim();
sass.render({
file: fixture('simple/index.scss'),
success: function(result) {
assert.equal(result.css.trim(), expected.replace(/\r\n/g, '\n'));
done();
}
});
});
it('should compile sass to css with data', function(done) {
var src = read(fixture('simple/index.scss'), 'utf8');
var expected = read(fixture('simple/expected.css'), 'utf8').trim();
sass.render({
data: src,
success: function(result) {
assert.equal(result.css.trim(), expected.replace(/\r\n/g, '\n'));
done();
function fixtures() {
return path.resolve
.bind(path, __dirname, 'fixtures')
.apply(null, arguments)
}
import cssstats from 'cssstats';
import { exec } from 'child_process';
import fs from 'fs';
import gulp from 'gulp';
import gulpzip from 'gulp-zip';
import path from 'path';
import buildServerApi from '@salesforce-ux/build-server-api';
const { publish } = buildServerApi(process.env.BUILD_SERVER_HOST_NEW);
const packageJSON = require('../../package.json');
const CSS_PATH = 'assets/styles/salesforce-lightning-design-system.css';
const paths = {
build: path.resolve.bind(path, __PATHS__.build),
buildDist: path.resolve.bind(path, __PATHS__.build, 'dist')
};
const execute = (cmd, done) =>
exec(cmd, { cwd: __PATHS__.root, stdio: 'inherit' }, (err, out, stderr) => {
if (err) return done(err);
done(null, out.trim());
});
const getDependencies = (done) => {
const deps = _.assign({},
packageJSON.devDependencies, packageJSON.dependencies);
done(null, _.keys(deps)
.filter(k => k.match(/@salesforce/i))
.reduce((acc, k) =>
function root(args) {
args = Array.prototype.slice.call(arguments, 0);
return path.resolve.apply(path, [__dirname].concat(args));
}
function absPath() {
const args = [].slice.apply(arguments);
args.unshift(__dirname, "..");
return path.resolve.apply(path.resolve, args);
}
var _check = function(p) {
var _file = path.resolve.apply(this, new args(arguments).array);
return (fs.existsSync(_file) && fs.statSync(_file).isFile()) ? _file : false;
}
var _check = function(p) {
var _dir = path.resolve.apply(this, new args(arguments).array);
return (fs.existsSync(_dir) && fs.statSync(_dir).isDirectory()) ? _dir : false;
}
'use strict';
require('mocha');
var fs = require('fs');
var path = require('path');
var assert = require('assert');
var update = require('update');
var npm = require('npm-install-global');
var del = require('delete');
var updater = require('..');
var app;
var cwd = path.resolve.bind(path, process.cwd());
var fixtures = path.resolve.bind(path, __dirname, 'fixtures');
var actual = path.resolve.bind(path, __dirname, 'actual');
function exists(name, re, cb) {
if (typeof re === 'function') {
cb = re;
re = new RegExp(/./);
}
return function(err) {
if (err) return cb(err);
var filepath = actual(name);
fs.stat(filepath, function(err, stat) {
if (err) return cb(err);
assert(stat);
var str = fs.readFileSync(filepath, 'utf8');
assert(re.test(str));
this[c][p] = v[p];
}
else
this[c] = v;
}
}
};
// jshint evil:true
new Function(source.toString()).call(global);
delete configSystem.config;
loader.config(configSystem);
loader.pluginLoader.config(configSystem);
global.System = curSystem;
}
var resolvePath = path.resolve.bind(path, process.cwd());
Builder.prototype.loadConfig = function(configFile) {
var self = this;
return asp(fs.readFile)(resolvePath(configFile))
.then(executeConfigFile.bind(null, this.loader))
.then(function() { return self; });
};
Builder.prototype.loadConfigSync = function(configFile) {
var source = fs.readFileSync(resolvePath(configFile));
executeConfigFile(this.loader, source);
};
Builder.prototype.config = function(config) {
var loader = this.loader;
return new Promise(function(resolve, reject) {
// Check options and dump usage if we find problems.
var inputsOk = true;
var inputs = options.input;
var policyPath = options.policy;
if (!inputs || !inputs.length) {
if (options['config-file'] && options['config-field']) {
var field = options['config-field'];
try {
var contents = fs.readFileSync(options['config-file']);
contents = JSON.parse(contents);
if (contents[field] === undefined) {
inputs = [];
inputsOk = false;
} else if (Array.isArray(contents[field])) {
inputs = contents[field];
} else {
inputs = [contents[field]];
}
} catch (err) {
console.error(
"No input specified and no '" + field + "' found in '" +
options['config-file'] + "'!"
);
inputsOk = false;
}
}
}
if (options.stdin && inputs.length !== 1) {
console.error('Only one input supported in stdin mode');
inputsOk = false;
}
if (!inputsOk) {
console.log(usage);
process.exit(-1);
}
var jsconfPolicyPromise = Promise.resolve(null);
if (options.policy) {
jsconfPolicyPromise = new Promise(function (fulfill, reject) {
fs.readFile(
options.policy,
{ encoding: 'utf8' },
function (err, fileContent) {
if (err) {
reject(err);
} else {
try {
fulfill(jsconf_policy.fromRequirements(JSON.parse(fileContent)));
} catch (ex) {
reject(ex);
}
}
});
});
}
var root = options.root || process.cwd();
// Make sure resolution has a path segment to drop.
// According to URL rules,
// resolving index.html relative to /foo/ produces /foo/index.html, but
// resolving index.html relative to /foo produces /index.html
// is different from resolving index.html relative to /foo/
// This removes any ambiguity between URL resolution rules and file path
// resolution which might lead to confusion.
if (root !== '' && !/[\/\\]$/.test(root)) {
root += path.sep;
}
/**
* True iff a fatal error has been reported to the end user.
* @type {boolean}
*/
var fatalFailureOccurred = false;
function prettyPrintWarning(warning) {
if (warning.fatal) {
fatalFailureOccurred = true;
}
var warningText = colors.red(warning.filename) + ":" +
warning.location.line + ":" + warning.location.column +
"\n " + colors.gray(warning.message);
console.log(warningText);
}
process.on('uncaughtException', function(err) {
console.error('Uncaught exception: ', err);
fatalFailureOccurred = true;
});
process.on('unhandledRejection', function(reason, p) {
console.error("Unhandled Rejection at: Promise ", p, " reason: ", reason);
fatalFailureOccurred = true;
});
// Find the bower dir.
var parentDirs = [];
var foundBower = false;
while (!foundBower) {
var candidatePath = path.resolve.apply(undefined, [options.root].concat(parentDirs).concat([options.bowerdir]));
if (candidatePath == path.join('/', options.bowerdir)) {
break;
}
try {
fs.statSync(candidatePath);
foundBower = true;
} catch (err) {
var currDir = path.resolve.apply(undefined, parentDirs);
parentDirs.push('..');
var parentDir = path.resolve.apply(undefined, parentDirs);
if (currDir == parentDir) {
// we've reach the root directory
break;
}
}
}
if (!foundBower) {
options.bowerdir = undefined;
} else {
options.bowerdir = path.join(path.join.apply(undefined, parentDirs), options.bowerdir);
}
var lintPromise = Promise.resolve(true);
var content;
if (options.stdin) {
content = "";
lintPromise = lintPromise.then(function(){
return new Promise(function(resolve, reject) {
process.stdin.setEncoding('utf8');
process.stdin.on('readable', function() {
var chunk = process.stdin.read();
if (chunk !== null) {
content += chunk;
}
});
process.stdin.on('end', function() {
resolve(true);
});
});
});
} else {
content = undefined;
}
inputs.forEach(function(input) {
// If root has been set by cwd and input is an absolute path that begins with the cwd path,
// strip the root part of the input path to make the FS resolver not duplicate the root path
if (!options.root && input.indexOf(root) === 0 && pathIsAbsolute(input)) {
input = input.substring(root.length);
}
// Finally invoke the analyzer.
lintPromise = lintPromise.then(function() {
return polylint(
input,
{
root: root,
jsconfPolicy: jsconfPolicyPromise,
redirect: options.bowerdir,
content: content,
modules: options.modules
}
);
})
.then(function(lintWarnings){
lintWarnings.forEach(function(warning){
// If specified, ignore errors from our transitive dependencies.
if (options['no-recursion'] && input !== warning.filename) {
return;
}
prettyPrintWarning(warning);
});
})
.catch(function(err){
console.error(err.stack);
fatalFailureOccurred = true;
});
});
var exit = function(){
process.exit(fatalFailureOccurred ? 1 : 0);
};
resolve(lintPromise.then(exit));
});
'use strict';
var path = require('path');
var dest = path.resolve.bind(path, __dirname);
var through = require('through2');
module.exports = function(app, options) {
options = options || {};
var destBase = dest(app.cwd, options.dest || 'examples');
var srcBase = path.resolve.bind(path, options.cwd || __dirname);
return {
basic: {
options: {
cwd: srcBase('templates'),
destBase: destBase,
flatten: true
},
files: [
{src: '*'}
]
}
};
};
var pathModule = require('path');
var paths = {}
var relative = pathModule.resolve.bind(pathModule, __dirname);
paths.compiler = relative('vendor', 'SoyToJsSrcCompiler.jar');
paths.googJs = relative('vendor', 'soyutils_usegoog.js');
paths.js = relative('vendor', 'soyutils.js');
module.exports = paths;
Metalsmith.prototype.path = function(){
var paths = [].slice.call(arguments);
paths.unshift(this.directory());
return path.resolve.apply(path, paths);
};
/* Copyright (c) 2015-present, salesforce.com, inc. All rights reserved */
/* Licensed under BSD 3-Clause - see LICENSE.txt or git.io/sfdc-license */
/* eslint-disable no-console */
import fs from 'fs';
import path from 'path';
import async from 'async';
// /////////////////////////////////////////////////////////////
// Helpers
// /////////////////////////////////////////////////////////////
const distPath = path.resolve.bind(
path,
path.resolve(__dirname, '../', '.tmp')
);
// /////////////////////////////////////////////////////////////
// Tasks
// /////////////////////////////////////////////////////////////
async.series(
[
/**
* Clean up the package.json for publishing
*/
(done) => {
console.log('### Cleaning up the package.json');
const packageJSON = JSON.parse(
var getPath = function () {
// add CWD base path as first element of arguments array
Array.prototype.unshift.call(arguments, getCwdPath());
return pathUtil.resolve.apply(null, arguments);
};
// ------------------------------------
// Utilities
// ------------------------------------
function base () {
const args = [config.path_base].concat([].slice.call(arguments))
return path.resolve.apply(path, args)
}
function resolvePath() {
return path.resolve.apply(null, [].slice.call(arguments));
}
Neither the name of salesforce.com, inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import '../helpers/setup';
import _ from 'lodash';
import fs from 'fs-extra';
import path from 'path';
import request from 'superagent';
import semver from 'semver';
import globals from '../../app_modules/global';
import moment from 'moment';
import { execSync } from 'child_process';
const local = path.resolve.bind(path, __dirname, '../../');
const exec = (command, cwd = '') => {
execSync(command, {
cwd: local(cwd),
stdio: 'inherit',
env: Object.assign({}, process.env)
});
};
/**
* Send npm ready zip to npm/bower app to publish
* @param {string} url
* @param {string|path} folder
* @returns void
*/
* Константы, зависящие от окружения `ENV_ROOT`
*
* NOTE: список названий констант, которые могут быть переопределены
* на уровне проекта.
*
* @private
* @type Array
*/
__extendables = ['LIB_DIR', 'LIB_ROOT'],
/** @type Function */
join = PATH.join,
/** @type Function */
relative = PATH.relative,
/** @type Function */
resolve = PATH.resolve.bind(null, __dirname),
/** @type Function */
envresolve = PATH.resolve.bind(null, __root),
/**
* Путь до корня окружения
*
* NOTE: под окружением подразумеваем проект, сборку которого
* мы осуществляем.
*
* @type String
* @exports ENV_ROOT
*/
ENV_ROOT = exports.ENV_ROOT = envresolve('../'),
/**
var path = require('path');
var fixture = path.resolve.bind(path, __dirname, 'fixtures');
var equal = require('assert-dir-equal');
var Metalsmith = require('metalsmith');
var postcss = require('..');
describe('metalsmith-postcss', function () {
describe('sourcemaps', function () {
it('should not add sourcemaps at all', function (done) {
var metalsmith = Metalsmith(fixture('no-sourcemaps'));
metalsmith
.use(postcss({
plugins: {}
}))
.build(function (err) {
if (err) return done(err);
equal(fixture('no-sourcemaps/build'), fixture('no-sourcemaps/expected'));
done();
});
});
it('should add inline sourcemaps', function (done) {
var metalsmith = Metalsmith(fixture('inline-sourcemaps'));
metalsmith
.use(postcss({
plugins: {},
map: true
}))
.build(function (err) {
/**
* Constructor
*
* @param {string[]} pathParts
*/
function Writer() {
this.baseDir = path.resolve.apply(null, arguments);
this.preventDeletion = _.clone(preventDeletionGlobal);
this.leadingFileComments = null;
this.trailingFileComments = null;
}
// Copyright (c) 2015-present, salesforce.com, inc. All rights reserved
// Licensed under BSD 3-Clause - see LICENSE.txt or git.io/sfdc-license
/* eslint-disable camelcase */
const path = require('path');
const root = path.resolve(__dirname, '../../');
const rootPath = path.resolve.bind(path, root);
const node_modules = rootPath('node_modules');
const watchPaths = {
css: [rootPath('assets/**/*.css')],
sass: [rootPath('ui/**/*.scss'), rootPath('design-tokens/*.yml')],
js: [
rootPath('app_modules/**/*.{js,jsx}'),
rootPath('ui/**/*.{js,jsx}'),
rootPath('site/**/*.{js,jsx}')
],
tokens: [
rootPath('ui/**/tokens/*.yml'),
rootPath('design-tokens/**/*.yml'),
'!' + rootPath('design-tokens/components.yml')
]
};
module.exports = {
root,
rootPath,
node_modules,
module.exports = function(app, base) {
if (!isValid(app, 'update-builtins')) return;
var gm = path.resolve.bind(path, require('global-modules'));
var cwd = path.resolve.bind(path, app.cwd);
/**
* Select the updaters to run every time `update` is run. Use `--add` to
* add additional updaters, and `--remove` to remove them. You can run this command
* whenever you want to update your preferences, like after installing new updaters.
*
* ```sh
* $ update init
* ```
* @name init
* @api public
*/
app.task('init', { silent: true }, function() {
var list = Update.resolveTasks(app, argv);
var updaters = [];
console.log();
console.log(' Current updaters:', app.log.cyan(list.join(', ')));
console.log();
return app.src([gm('updater-*'), cwd('node_modules/updater-*')])
.pipe(through.obj(function(file, enc, next) {
file.basename = app.toAlias(file.basename);
next(null, file);
}))
.pipe(choose({message: 'Choose the updaters to run with the `update` command:'}))
.pipe(through.obj(function(file, enc, next) {
updaters.push(file.basename);
next();
}, function(next) {
save(app, updaters);
next();
}));
});
/**
* Display a list of currently installed updaters.
*
* ```sh
* $ update defaults:list
* # aliased as
* $ update list
* ```
* @name list
* @api public
*/
app.task('list', { silent: true }, function() {
return app.src([gm('updater-*'), cwd('node_modules/updater-*')])
.pipe(through.obj(function(file, enc, next) {
file.alias = app.toAlias(file.basename);
next(null, file);
}))
.pipe(list(app));
});
/**
* Display a help [menu](#help-menu) of available commands and flags.
*
* ```sh
* $ update defaults:help
* # aliased as
* $ update help
* ```
* @name help
* @api public
*/
app.task('help', { silent: true }, function(cb) {
base.cli.process({ help: true }, cb);
});
/**
* Show the list of updaters that are registered to run on the current project.
*
* ```sh
* $ update defaults:show
* # aliased as
* $ update show
* ```
* @name show
* @api public
*/
app.task('show', { silent: true }, function(cb) {
argv._ = [];
var list = Update.resolveTasks(app, argv);
console.log();
console.log(' queued updaters:', `\n · ` + list.join('\n · '));
console.log();
cb();
});
/**
* Default task for the built-in `defaults` generator.
*
* ```sh
* $ update help
* ```
* @name help
* @api public
*/
app.task('default', { silent: true }, ['help']);
};