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)); };