readJSON(packageJsonFile, function (err, json) {
if (err) {
return callback(err);
}
if (json.dependencies) {
json.dependencies = sortedObject(json.dependencies);
}
if (json.devDependencies) {
json.devDependencies = sortedObject(json.devDependencies);
}
var data = JSON.stringify(json, null, 2) + '\n';
fs.writeFile(packageJsonFile, data, callback);
});
function recursiveSorted(json) {
if (!json) {
return json;
}
var deps = json.dependencies;
if (typeof deps === 'object' && deps !== null) {
json.dependencies = Object.keys(deps)
.reduce(function (acc, key) {
acc[key] = recursiveSorted(deps[key]);
return acc;
}, {});
json.dependencies = sortedObject(json.dependencies);
}
return sortedKeys(json, [
'name',
'version',
'from',
'resolved',
'npm-shrinkwrap-version',
'node-version',
'dependencies'
]);
}
this.saveDepsToPkg = function (deps) {
var pkg = this.fs.readJSON(this.destinationPath('package.json'), {});
var currentDeps = pkg.devDependencies || {};
var mergedDeps = R.merge(currentDeps, deps);
var sortedDeps = sortedObject(mergedDeps);
pkg.devDependencies = sortedDeps;
this.fs.writeJSON(this.destinationPath('package.json'), pkg);
};
module.exports = function deepSortObject (obj, sortBy) {
if (obj == null || typeof obj !== 'object') return obj
if (obj instanceof Array) return obj.sort(sortBy)
obj = sortedObject(obj)
Object.keys(obj).forEach(function (key) {
obj[key] = deepSortObject(obj[key], sortBy)
})
return obj
}
write: function (dir, json, cb) {
json.sustain = sortObject(json.sustain)
fs.writeFile(
Path.join(dir, 'package.json'),
JSON.stringify(json, null, 2),
cb
)
},
module.exports = function (mod, buildpath, next) {
var pkg = sortedObject(mod.package)
var name = moduleName(mod)
// Add our diagnostic keys to the package.json.
// Note that there are folks relying on these, for ex, the Visual Studio
// Node.js addon.
pkg._requiredBy =
mod.requiredBy
.map(function (req) {
if (
req.package.devDependencies &&
req.package.devDependencies[name] &&
!req.package.dependencies[name]
) {
return '#DEV:' + req.location
} else {
return req.location
}
})
.concat(mod.userRequired ? ['#USER'] : [])
.sort()
pkg._location = mod.location
pkg._phantomChildren = {}
Object.keys(mod.phantomChildren).sort().forEach(function (name) {
pkg._phantomChildren[name] = mod.phantomChildren[name].package.version
})
pkg._inBundle = !!mod.fromBundle
// sort keys that are known safe to sort to produce more consistent output
sortKeys.forEach(function (key) {
if (pkg[key] != null) pkg[key] = deepSortObject(pkg[key])
})
var data = JSON.stringify(sortedObject(pkg), null, 2) + '\n'
writeFileAtomic(path.resolve(buildpath, 'package.json'), data, {
// We really don't need this guarantee, and fsyncing here is super slow. Except on
// Windows where there isn't a big performance difference and it prevents errors when
// rolling back optional packages (#17671)
fsync: isWindows
}, next)
}
module.exports = function save (pkg, installedPackages, saveType, useExactVersion) {
// Read the latest version of package.json to avoid accidental overwriting
var packageJson = requireJson(pkg.path, { ignoreCache: true })
packageJson[saveType] = packageJson[saveType] || {}
installedPackages.forEach(function (dependency) {
var semverCharacter = useExactVersion ? '' : '^'
packageJson[saveType][dependency.spec.name] = semverCharacter + dependency.version
})
packageJson[saveType] = sortedObject(packageJson[saveType])
return writeJson(pkg.path, packageJson)
}
function onnewfile(err, newShrinkwrap) {
if (err) {
return callback(err);
}
keys.forEach(function (k) {
if (!newShrinkwrap[k]) {
newShrinkwrap[k] = oldShrinkwrap[k];
}
});
newShrinkwrap = sortedObject(newShrinkwrap);
var buf = JSON.stringify(newShrinkwrap, null, 2);
fs.writeFile(fileName, buf, 'utf8', onshrinkwrap);
}
function printOptions () {
var flags = {};
write();
write((cli.color) ? format[cli.color]('Options:') : 'Options:')
write();
_.each(sortObject(cli._flagsWithCombinedAlias), function (cmd, key) {
var cliFlag = cli._flagsWithCombinedAlias[key];
if (!cliFlag._secret) flags[key] = cliFlag._description;
});
print(flags, {
leftPadding: 4,
rightPadding: 4
});
}
function printCommands () {
var cmds = {};
write();
write((cli.color) ? format[cli.color]('Commands:') : 'Commands:');
write();
_.each(sortObject(cli._commandsWithCombinedAlias), function (cmd, key) {
var cliCommand = cli._commandsWithCombinedAlias[key];
// Only show commands that aren't set to hide
if (!cliCommand._secret) cmds[key] = cliCommand._description;
});
print(cmds, {
leftPadding: 4,
rightPadding: 4
});
}
fs.readFile(saveTarget, function (er, data) {
// ignore errors here, just don't save it.
try {
data = JSON.parse(data.toString("utf8"))
} catch (ex) {
er = ex
}
if (er) {
return cb(null, installed, tree, pretty)
}
var deps = npm.config.get("save-optional") ? "optionalDependencies"
: npm.config.get("save-dev") ? "devDependencies"
: "dependencies"
if (saveBundle) {
var bundle = data.bundleDependencies || data.bundledDependencies
delete data.bundledDependencies
if (!Array.isArray(bundle)) bundle = []
data.bundleDependencies = bundle.sort()
}
log.verbose("save", "saving", things)
data[deps] = data[deps] || {}
Object.keys(things).forEach(function (t) {
data[deps][t] = things[t]
if (saveBundle) {
var i = bundle.indexOf(t)
if (i === -1) bundle.push(t)
data.bundleDependencies = bundle.sort()
}
})
data[deps] = sortedObject(data[deps])
log.silly("save", "writing", saveTarget)
data = JSON.stringify(data, null, 2) + "\n"
writeFileAtomic(saveTarget, data, function (er) {
cb(er, installed, tree, pretty)
})
})
function save (pkginfo, silent, cb) {
// copy the keys over in a well defined order
// because javascript objects serialize arbitrarily
pkginfo.dependencies = sortedObject(pkginfo.dependencies || {})
try {
var swdata = JSON.stringify(pkginfo, null, 2) + "\n"
} catch (er) {
log.error("shrinkwrap", "Error converting package info to json")
return cb(er)
}
var file = path.resolve(npm.prefix, "npm-shrinkwrap.json")
fs.writeFile(file, swdata, function (er) {
if (er) return cb(er)
if (silent) return cb(null, pkginfo)
console.log("wrote npm-shrinkwrap.json")
cb(null, pkginfo)
})
}
BespokeGenerator.prototype.setupPackageJson = function setupPackageJson() {
var packageJson = {
'name': 'presentation-' + this.shortName,
'version': '0.0.0',
'dependencies': {},
'devDependencies': {
'bespoke': '^1.0.0',
'debowerify': '^0.7.1',
'gh-pages': '^0.2.0',
'gulp': '^3.8.1',
'gulp-autoprefixer': '0.0.7',
'gulp-browserify': '^0.5.0',
'gulp-connect': '^2.0.5',
'gulp-csso': '^0.2.9',
'gulp-jade': '^0.6.0',
'gulp-plumber': '^0.6.3',
'gulp-rename': '^1.2.0',
'gulp-rimraf': '^0.1.0',
'gulp-stylus': '^1.0.2',
'gulp-uglify': '^0.3.1',
'gulp-util': '^2.2.17',
'insert-css': '^0.2.0',
'opn': '^0.1.2',
'through': '^2.3.4'
},
'engines': {
'node': '>=0.10.0'
}
};
this.selectedPlugins.forEach(function(plugin) {
packageJson.devDependencies['bespoke-' + plugin.name] = plugin.version;
}.bind(this));
if (!this.useTheme) {
packageJson.devDependencies['normalizecss'] = '^3.0.0';
}
packageJson.devDependencies = sortedObject(packageJson.devDependencies);
this.write('package.json', JSON.stringify(packageJson, null, 2));
};
function printTasks (tasks) {
if (_.keys(tasks).length < 1) return;
var taskList = {};
var sortedTasks = sortObject(tasks);
write();
write((cli.color) ? format[cli.color]('Tasks:') : 'Tasks:');
write();
var taskList = _(sortedTasks)
.keys()
.map(function (key) {
return ':' + key;
})
.zipObject(_(sortedTasks).map(function (task, key) {
return task._description
}).value()).value();
print(taskList, {
leftPadding: 4,
rightPadding: 4
});
}
configuring: function () {
this.template('README.adoc', 'README.adoc');
this.template('gulpfile.js', 'gulpfile.js');
this.copy('_gitignore', '.gitignore');
this.copy('_editorconfig', '.editorconfig');
if (this.useAsciiDoc) {
this.copy('Gemfile', 'Gemfile');
}
var packageSettings = {
name: 'presentation-' + this.shortName,
version: '1.0.0',
license: this.license
};
var gitRepoUrl = detectGitRepository();
if (gitRepoUrl) {
packageSettings['repository'] = {
type: 'git',
url: gitRepoUrl
};
}
var devDependencies = {
'bespoke': '^1.1.0',
'browserify': '^14.4.0',
'del': '^3.0.0',
'gh-pages': '^1.0.0',
'gulp': '^3.9.1',
// hold back gulp-autoprefixer as latest release requires Node 4.5
'gulp-autoprefixer': '^3.1.1',
'gulp-connect': '^5.0.0',
'gulp-csso': '^3.0.0',
'gulp-plumber': '^1.1.0',
'gulp-rename': '^1.2.2',
'gulp-stylus': '^2.6.0',
'gulp-uglify': '^3.0.0',
'gulp-util': '^3.0.8',
'normalizecss': '^3.0.0',
'through': '^2.3.8',
'vinyl-buffer': '^1.0.0',
'vinyl-source-stream': '^1.1.0',
};
if (this.usePug) {
devDependencies['gulp-pug'] = '^3.0.3';
}
if (this.useAsciiDoc) {
devDependencies['gulp-exec'] = '^2.1.2';
}
this.selectedPlugins.forEach(function (plugin) {
devDependencies['bespoke-' + plugin.name] = plugin.version;
});
packageSettings.devDependencies = sortedObject(devDependencies);
packageSettings.engines = { 'node': '>=4.2.0' }
this.fs.writeJSON(this.destinationPath('package.json'), packageSettings);
},
/**
* @license
* Copyright (c) 2016 The {life-parser} Project Authors. All rights reserved.
* This code may only be used under the MIT style license found at http://100dayproject.github.io/LICENSE.txt
* The complete set of authors may be found at http://100dayproject.github.io/AUTHORS.txt
* The complete set of contributors may be found at http://100dayproject.github.io/CONTRIBUTORS.txt
* Code distributed by 100dayproject as part of the life.
*/
"use strict";
let _ = require('lodash');
let sortedObject = require('sorted-object');
// Load configurations application and apply ignore pattern name directory
let getConfigInstance = __.getDirectories(__base + 'config', ['env', 'passport', 'express']);
// f*****g faster coding happy
module.exports = sortedObject(
_.extend(
require(getConfigInstance[0]),
require(getConfigInstance[1]),
require(getConfigInstance[2]),
require('./env/' + process.env.NODE_ENV) || {}
)
);
var _ = require('lodash');
var sorted = require('sorted-object');
var fs = require('fs');
var path = require('path');
function cleanModule(moduleRecord, name) {
// keep `resolve` properties for git dependencies, delete otherwise
delete moduleRecord.from;
if (!(moduleRecord.resolved && moduleRecord.resolved.match(/^git(\+[a-z]+)?:\/\//))) {
delete moduleRecord.resolved;
}
_.forEach(moduleRecord.dependencies, function(mod, name) {
cleanModule(mod, name);
});
}
console.log('Reading npm-shrinkwrap.json');
var shrinkwrap = require('../../npm-shrinkwrap.json');
console.log('Cleaning shrinkwrap object');
cleanModule(shrinkwrap, shrinkwrap.name);
var cleanShrinkwrapPath = path.join(__dirname, '..', '..', 'npm-shrinkwrap.clean.json');
console.log('Writing cleaned to', cleanShrinkwrapPath);
fs.writeFileSync(cleanShrinkwrapPath, JSON.stringify(sorted(shrinkwrap), null, 2) + "\n");
const renderApp = () => {
// Pull the state we need for rendering our app
const {
version = '',
config = {},
settings = {},
pagination = {},
error = null,
} = store.getState();
const newAppConf = JSON.stringify(sortedObject(config.app || {}));
const newPaginationConf = JSON.stringify(sortedObject(pagination || {}));
const newErrorConf = JSON.stringify(sortedObject(error || {}));
if (
appConfig === newAppConf
&& paginationConf === newPaginationConf
&& errorConf === newErrorConf
) {
// TODO: Now we assume that only changes on app and pagination is a reason to rerender!
// will this be true in the future?
return;
}
appConfig = newAppConf;
paginationConf = newPaginationConf;
errorConf = newErrorConf;
// Resolve config
return Promise.resolve(config) // eslint-disable-line consistent-return
.then(resolveVisibility.onClient.bind(null, settings, query))
// Resolve modules (React components) in the config
.then(resolveModules)
// Render React app
//
// NOTE: To be able to have login data and global actions for logging in
// and other actions that needs to be available to every component in the
// tree we pass them down via context (available as this.context -
// see React docs)
.then(({ app: {
type: App,
options = {},
} }) => {
// Create a new Promise of rendering the application
return new Promise((resolve) => {
ReactDOM.render(
<ContextWrapper
actions={{}}
settings={settings}
>
<App
newVersionAvailable={latestVersion !== version}
pagination={pagination}
error={error}
{...options}
/>
</ContextWrapper>,
document.querySelector('#app'),
/*
NOTE: We're using the callback available for ReactDOM.render
to be able to know when the rendering is done (async).
*/
() => resolve()
);
});
})
// Make sure errors are thrown
.catch(err => setImmediate(() => {
throw err;
}));
};
}).map(function (d) {
return makeArchy_(sortedObject(data.dependencies[d]), long, dir, depth + 1, data, d)
})
/**
* Created by kevin on 16/6/25.
*/
var sortedObject = require("sorted-object");
var fs = require('fs');
var objectToSerialize = require('./test.json');
console.log(objectToSerialize);
// Before:
fs.writeFileSync("dest.json", JSON.stringify(objectToSerialize));
// After:
var sortedVersion = sortedObject(objectToSerialize);
fs.writeFileSync("dest1.json", JSON.stringify(sortedVersion));
module.exports = function objectAssignSorted() {
return sortedObject(Object.assign.apply(null, arguments));
};