FileStorage.prototype.saveResourceFile = function (res) {
var fn = this.getResourceFilename(res.id);
fs.outputFile(fn, JSON.stringify(res), function (error) {
if (error) {
Winston.error('filestore: error writing file : ' + fn);
}
else {
Winston.info('filestore: file saved : ' + fn);
}
});
};
export function post(
options: DiskProviderOptions,
unsafeFilePath: string,
content: mixed
) {
const filePath = path.join(
options.local.baseDirectory,
sanitizeFilePath(unsafeFilePath)
);
return fs.outputFile(filePath, JSON.stringify(content));
}
FileStorage.prototype.saveKeyFile = function (key) {
var fn = this.getKeyFilename(key.id);
fs.outputFile(fn, JSON.stringify(key), function (error) {
if (error) {
Winston.error('filestore: error writing file : ' + fn + error.message);
}
else {
Winston.info('filestore: file saved : ' + fn);
}
});
};
app.post('/chart/:name', function(req, res) {
var name = req.params.name;
var body = req.body;
var fName = './charts/' + name + '/chart.json';
fs.outputFile(fName, JSON.stringify(body), function(err) {
if (err) {
res.status(500).send(err)
} else {
res.status(200).send()
}
})
});
setTimeout( function() {
var systemController = self.commandRouter.pluginManager.getPlugin('system_controller', 'system');
var nameraw = systemController.getConf('playerName');
var name = nameraw.charAt(0).toUpperCase() + nameraw.slice(1);
var upmpdcliconf = "/tmp/upmpdcli.conf";
var upmpdcliconftmpl = __dirname + "/upmpdcli.conf.tmpl";
var namestring = 'friendlyname = ' + name.replace(/-/g,' ') + os.EOL + 'ohproductroom = ' + name.replace(/-/g,' ') + os.EOL;
var ipaddress = self.getCurrentIP()
ipaddress.then(function (ipaddresspromise) {
fs.readFile(__dirname + "/presentation.html.tmpl", 'utf8', function (err, data) {
if (err) {
return self.logger.log('Error writing Upnp presentation file: '+err);
}
var conf1 = data.replace('{IP-ADDRESS}', ipaddresspromise);
fs.writeFile("/tmp/presentation.html", conf1, 'utf8', function (err) {
if (err) {
self.logger.log('Error writing Upnp presentation file: '+err);
}
});
});
});
fs.outputFile(upmpdcliconf, namestring , function (err) {
if (err) {
self.logger.error('Cannot write upnp conf file: '+err);
} else {
fs.appendFile(upmpdcliconf, fs.readFileSync(upmpdcliconftmpl), function (err) {
if (err){
self.logger.error('Cannot write upnp conf file: '+err);
}
upmpdcliexec();
});
}
})
function upmpdcliexec() {
exec('/usr/bin/sudo /bin/systemctl start upmpdcli.service', function (error, stdout, stderr) {
if (error) {
self.logger.error('Cannot start Upmpdcli: '+error);
} else {
self.logger.info('Upmpdcli Daemon Started');
}
});
}
}, 10000)
beforeEach(async function() {
this.tmpDir = await promisify(tmp.dir)()
this.relativeFeaturePath = path.join('features', 'a.feature')
const featurePath = path.join(this.tmpDir, 'features', 'a.feature')
await fs.outputFile(featurePath, '')
this.result = await getTestCases({
cwd: this.tmpDir,
eventBroadcaster: this.eventBroadcaster,
featurePaths: [featurePath],
pickleFilterOptions: {}
})
})
var _complete = function() {
if (!total) {
fs.outputFile(output, dataArray.join("\n"), function(err) {
if (err) return callback(new Error('Unable to write output file ' + err.message));
callback(null, input);
});
}
};
runtime: function (callback) {
let script = fs.readFileSync(path.join(__dirname, 'build',
ManifestProcessorOptions.scriptFileName), 'utf8')
script = ['let ' + ManifestProcessorOptions.globalVarName +
' = this;', 'var Sketch = require("sketch");', script
].join('')
fse.outputFile(path.join(bundlePath, 'Contents', 'Sketch',
ManifestProcessorOptions.scriptFileName), script,
callback)
}
}, function (err) {
if (err) {
// TODO: Make sure error is formatted correctly.
console.error("ERR", err);
return callback(err);
}
var path = PATH.join(targetScriptsPath, ".pio.filelist");
if (state["pio.cli.local"].verbose) {
console.log("Writing filelist to: ", path);
}
return FS.outputFile(path, JSON.stringify(fileinfo, null, 4), callback);
});
fs.exists(complete_path, function(exists) {
if (exists) {
// must reconstruct the manga.json so we delete old one
fs.unlinkSync(complete_path);
}
// let's generate TOC based on supplied json (properly formatted)
var string = JSON.stringify(json, null, '\t');
fs.outputFile(complete_path, string, function(err) {
resultCallback(err);
});
});
/**
* Render the document file, through a template if necessary, producing
* an output file.
*/
async renderToFile(basedir, fpath, renderTo, renderToPlus, metadata, config) {
const renderStart = new Date();
// console.log(`renderToFile ${basedir} ${fpath} ${renderTo} ${renderToPlus} ${util.inspect(metadata)}`);
// var doctext;
var doccontent;
var docdata = metadata;
var docrendered;
var fm = await this.frontmatter(basedir, fpath);
doccontent = fm.content;
// const renderFrontmatter = new Date();
// console.log(`renderToFile FRONTMATTER ${basedir} ${fpath} ${renderTo} ${(renderFrontmatter - renderStart) / 1000} seconds`);
// console.log(`renderToFile ${basedir} ${fpath} ${renderTo} ${renderToPlus} ${doccontent}`);
data.report(basedir, fpath, renderTo, "FRONTMATTER", renderStart);
var metadata = await this.initMetadata(config, basedir, fpath, renderToPlus, docdata, fm.data);
docdata = metadata;
// console.log('about to render '+ fpath);
// console.log(`metadata before render ${util.inspect(docdata)}`);
try {
docrendered = await this.render(doccontent, docdata);
} catch (err) {
console.error("Error rendering "+ fpath +" "+ (err.stack ? err.stack : err));
throw new Error("Error rendering "+ fpath +" "+ (err.stack ? err.stack : err));
}
// const renderFirstRender = new Date();
// console.log(`renderToFile FIRST RENDER ${basedir} ${fpath} ${renderTo} ${(renderFirstRender - renderStart) / 1000} seconds`);
data.report(basedir, fpath, renderTo, "FIRST RENDER", renderStart);
// console.log('rendered to maharun '+ fpath);
if (this.doMahabhuta(fpath)) {
try {
docrendered = await this.maharun(docrendered, docdata, config.mahafuncs);
} catch (err2) {
console.error("Error in Mahabhuta for "+ fpath +" "+ (err2.stack ? err2.stack : err2));
throw new Error("Error in Mahabhuta for "+ fpath +" "+ (err2.stack ? err2.stack : err2));
}
}
const renderFirstMahabhuta = new Date();
// console.log(`renderToFile FIRST MAHABHUTA ${basedir} ${fpath} ${renderTo} ${(renderFirstMahabhuta - renderStart) / 1000} seconds`);
data.report(basedir, fpath, renderTo, "FIRST MAHABHUTA", renderStart);
// console.log('maharun to renderForLayout '+ fpath);
docrendered = await this.renderForLayout(docrendered, docdata, config);
const renderSecondRender = new Date();
// console.log(`renderToFile SECOND RENDER ${basedir} ${fpath} ${renderTo} ${(renderSecondRender - renderStart) / 1000} seconds`);
data.report(basedir, fpath, renderTo, "SECOND RENDER", renderStart);
// console.log(`renderToFile ${basedir} ${fpath} ==> ${renderTo} ${this.filePath(fpath)}`);
// console.log(docrendered);
await fs.outputFile(path.join(renderTo, this.filePath(fpath)), docrendered, 'utf8');
// remove circular dependency
// await filez.writeFile(renderTo, this.filePath(fpath), docrendered);
}
fs.copy(`${ process.cwd() }/package.json`, `${ paths.starter.backups }package.json`, (err) => {
if (err) {
log('warn', err, verbose);
}
log('verbose', `Package File Backed Up`, verbose);
fs.outputFile(`${ process.cwd() }/package.json`, JSON.stringify(pkg, null, 2), function (err) {
if (err) {
log('warn', err, verbose);
}
log('verbose', `Package file updated.`, verbose);
});
});
Dot.prototype.generateJSON = function (deps) {
var _this = this;
var d = q.defer();
fs.outputFile(this.paths.json, JSON.stringify(deps, null, 2), function (error) {
if (error) {
d.reject(error);
}
logger_1.logger.info('creating JSON', 'done');
d.resolve(_this.paths.json);
});
return d.promise;
};
SymbolService.prototype._writeSymbolTable = function(symbolQueryResult) {
var deferred = Q.defer();
var self = this;
fs.outputFile(path.join(self.project.path, 'config', '.symbols', symbolQueryResult.Name+'.json'), JSON.stringify(symbolQueryResult.SymbolTable, null, 4), function(err) {
if (err) {
deferred.reject(err);
} else {
deferred.resolve();
}
});
return deferred.promise;
};
function(callback){
var output_path = path.join(build.output_directory, get_output_path(site, build, content.uri));
var relative_output_path = path.relative(build.output_directory, output_path);
log.verbose(colors.gray(sprintf('\t\tWriting file %s\n', relative_output_path)));
written_files.push(output_path);
fs.outputFile(output_path, rendered, function(err){
if (err){
log(colors.yellow(sprintf('\t\tError writing %s: %s\n', relative_output_path, err.message)));
}
callback(null);
});
}
var saveFontClass = function(opts){
var deferred = Q.defer();
if(!opts.font.classSrc){
return deferred.reject(new Error('saveClass: "opts.header" not found'));
}
var fileName = path.join(opts.tempDir,CONFIG.IOS_FONT_NAME+'.m');
fs.outputFile(fileName, opts.font.classSrc, function(err){
return deferred.resolve(opts);
});
return deferred.promise;
};
test('Prepare from a detached head repository', async t => {
const branch = 'master';
let {cwd, repositoryUrl} = await gitRepo(true);
await outputFile(path.resolve(cwd, 'package.json'), "{name: 'test-package', version: '1.0.0'}");
await outputFile(path.resolve(cwd, 'dist/file.js'), 'Initial content');
await outputFile(path.resolve(cwd, 'dist/file.css'), 'Initial content');
await add('.', {cwd});
const [{hash}] = await gitCommits(['First'], {cwd});
await gitTagVersion('v1.0.0', undefined, {cwd});
await push(repositoryUrl, branch, {cwd});
cwd = await gitDetachedHead(repositoryUrl, hash);
await outputFile(path.resolve(cwd, 'package.json'), "{name: 'test-package', version: '2.0.0'}");
await outputFile(path.resolve(cwd, 'dist/file.js'), 'Updated content');
await outputFile(path.resolve(cwd, 'dist/file.css'), 'Updated content');
const nextRelease = {version: '2.0.0', gitTag: 'v2.0.0', notes: 'Version 2.0.0 changelog'};
const pluginConfig = {
message: `Release version \${nextRelease.version} from branch \${branch}\n\n\${nextRelease.notes}`,
assets: '**/*.{js,json}',
};
await t.context.m.prepare(pluginConfig, {
cwd,
options: {repositoryUrl, branch},
nextRelease,
logger: t.context.logger,
});
t.deepEqual((await gitCommitedFiles('HEAD', {cwd})).sort(), ['dist/file.js', 'package.json'].sort());
const [commit] = await gitGetCommits(undefined, {cwd});
t.is(commit.subject, `Release version ${nextRelease.version} from branch ${branch}`);
t.is(commit.body, `${nextRelease.notes}\n`);
t.is(commit.gitTags, `(HEAD)`);
});
async processScreenshot(context, base64Screenshot) {
const screenshotPath = this.getScreenshotFile(context);
const referencePath = this.getReferencefile(context);
await fs.outputFile(screenshotPath, base64Screenshot, 'base64');
const referenceExists = await fs.exists(referencePath);
if (referenceExists) {
log('reference exists, compare it with the taken now');
const captured = new Buffer(base64Screenshot, 'base64');
const ignoreComparison = _.get(context, 'options.ignoreComparison', this.ignoreComparison);
const compareData = await this.compareImages(referencePath, captured, ignoreComparison);
const { isSameDimensions } = compareData;
const misMatchPercentage = Number(compareData.misMatchPercentage);
const misMatchTolerance = _.get(context, 'options.misMatchTolerance', this.misMatchTolerance);
const diffPath = this.getDiffFile(context);
if (misMatchPercentage > misMatchTolerance) {
log(`Image is different! ${misMatchPercentage}%`);
const png = compareData.getDiffImage().pack();
await this.writeDiff(png, diffPath);
return this.createResultReport(misMatchPercentage, false, isSameDimensions);
} else {
log(`Image is within tolerance or the same`);
await fs.remove(diffPath);
return this.createResultReport(misMatchPercentage, true, isSameDimensions);
}
} else {
log('first run - create reference file');
await fs.outputFile(referencePath, base64Screenshot, 'base64');
return this.createResultReport(0, true, true);
}
}
proto$0.compileCSS = function(css, output, input) {var this$0 = this;
var opts = { };
for ( var name in this.processOptions ) {
opts[name] = this.processOptions[name];
}
if ( input ) opts.from = input;
if ( output != '-' ) opts.to = output;
var result;
try {
result = this.compiler().process(css, opts);
} catch (error) {
if ( error.autoprefixer ) {
this.error('autoprefixer: ' + error.message);
} else if ( error instanceof CssSyntaxError ) {
this.error('autoprefixer:' + error.toString());
} else {
this.error('autoprefixer: Internal error');
if ( error.stack ) {
this.error('');
this.error(error.stack);
}
}
}
if ( !result ) return this.endWork();
if ( output == '-' ) {
this.print(result.css);
this.endWork();
} else {
fs.outputFile(output, result.css, function(error) {
if (error) this$0.error('autoprefixer: ' + error);
if ( result.map ) {
var map;
if ( opts.map && opts.map.annotation ) {
map = path.resolve(path.dirname(output),
opts.map.annotation);
} else {
map = output + '.map';
}
fs.writeFile(map, result.map, function(error) {
if (error) this$0.error('autoprefixer: ' + error);
this$0.endWork();
});
} else {
this$0.endWork();
}
});
}
};
fs.readFile(input, function(err, content) {
if (err) {
reject(err);
}
fs.outputFile(output, _.template(content)(data), function(err) {
if (err) {
reject(err);
}
resolve(output);
});
});
/**
* @function build
* @param {Object} inputOptions
* @param {Object} outputOptions
*/
async function build(inputOptions, outputOptions) {
await fs.remove(outputOptions.file);
const bundle = await rollup.rollup(inputOptions);
const result = await bundle.generate(outputOptions);
const file = outputOptions.file;
const minify = terser.minify(result.code, { ie8: true });
await fs.outputFile(file, banner + minify.code);
console.log(`Build ${file} success!`);
}
urlProcessFn: ({url, body, handlerId}) => {
idx++
this._gauge.show(handlerId, idx / totalCount)
this._gauge.pulse(url)
let pathToWrite = path.join(this._project.outPath(), url)
if (url.endsWith('/')) {
pathToWrite = path.join(pathToWrite, 'index.html')
}
return fs.outputFile(pathToWrite, body)
}
export function getSystemRules(name) {
console.log('Get system rules with name: ' + name);
var filter = name ? { filter: "Name eq '" + name + "'" } : null;
var rules = qrs.get('/qrs/SystemRule/full', filter);
var file = path.join(Meteor.settings.broker.automationBaseFolder, 'securityrules', 'export', 'ExtractedSystemRules.json');
// SAVE FILE TO DISK
fs.outputFile(file, JSON.stringify(rules, null, 2), 'utf-8');
return rules;
}
task('rss', done => {
const feed = new RSS(underhood.site);
const authorsToPost = authors.filter(author => author.post !== false);
authorsToPost.forEach(author => {
feed.item({
title: author.username,
description: render(firstTweet(author)),
url: `https://jsunderhood.ru/${author.authorId}/`,
date: firstTweet(author).created_at,
});
});
output('dist/rss.xml', feed.xml({ indent: true }), done);
});
robot.brain.on('save', function(data) {
data = JSON.stringify(data, null, 2);
if (data !== previousData) {
previousData = data;
fs.outputFile(brainFile, data, function(err) {
if (err) {
robot.logger.error(err);
}
});
}
});
})(function (err) {
if (err) { return sb(err); }
// console.log('about to generate a file @ `'+rootPath+'`:',options.contents);
fsx.outputFile(rootPath, options.contents, function (err){
if (err) { return sb(err); }
return sb();
});//</fsx.outputFile()>
});//</self-calling function :: _deleteExistingFileMaybe()>
setTag: function(tag, cb) {
var fs = require('fs-extra');
var configFile = 'config.json';
var config = conf.get('config');
if (!config) {
conf.set('config', {env: {}});
config = conf.get('config');
}
config.env.tag = tag;
fs.removeSync(configFile);
fs.outputFile(configFile, JSON.stringify(config, null, '\t'), function(err) {
cb(null, 'Updated');
})
},
fs.readJson(path.join(self.project.path, 'config', '.org_connections'), function(err, connections) {
if (err) {
reject(err);
} else {
connections.push(newConnection);
fs.outputFile(path.join(self.project.path, 'config', '.org_connections'), JSON.stringify(connections, null, 4), function(err) {
if (err) {
reject(err);
} else {
resolve();
}
});
}
});
ejs.renderFile(item, ejsVars, {}, function(err, str) {
if (err) {
log('warn', err);
}
fs.outputFile(item.replace(replaceSrc, replaceDist), str, (err) => {
if(!err) {
log('verbose', `Compiled ${ item } → ${ item.replace(replaceSrc, replaceDist) }`, verbose);
count--;
if (count === 0) {
resolve();
}
}
});
});
method._saveMeta = function (callback) {
var dataFile = this.getMetaFilePath();
var outputString = JSON.stringify(this.meta);
var _this = this;
fs.outputFile(dataFile, outputString, function (err) {
if (err) {
_this.logger.error('Could not write out meta file'.red, dataFile);
callback(false);
} else {
callback(true);
}
});
};