some refactors and added update and source package options

Author: wesleytodd

bin/create-package-json

@@ -13,7 +13,10 @@ program
   .arguments('<directory>')
   .action((dir) => directory = dir)
   .option('--ignore-existing', 'Ignore existing package.json')
+  .option('--existing-package [path]', 'Provide a path to an existing package.json to start with')
+  .option('--update-deps', 'Update deps which to their latest versions')
   .option('--no-prompt', 'Skip prompts and just use input options')
+  .option('--extended', 'Show extended option prompts (ex. browser, engines, etc)')
   .option('--spacer [json spacer]', 'Format character for package json', 2)
   .option('--name [name]', 'The package name')
   .option('--scope [scope]', 'The package scope')
@@ -27,19 +30,31 @@ program
   .option('--private', 'This is a private package')
   .option('--dependencies [dependencies]', 'Package dependencies')
   .option('--dev-dependencies [dependencies]', 'Package dev dependencies')
+  // .option('--peer-dependencies [dependencies]', 'Package peer dependencies')
   .option('--scripts [scripts]', 'Package scripts')
   .parse(process.argv)
 
 // Process scripts as json
 if (program.scripts) {
   program.scripts = JSON.parse(program.scripts)
 }
+if (program.dependencies) {
+  program.dependencies = arrayFromList(program.dependencies)
+}
+if (program.devDependencies) {
+  program.devDependencies = arrayFromList(program.devDependencies)
+}
+// if (program.peerDependencies) {
+//   program.peerDependencies = arrayFromList(program.peerDependencies)
+// }
 
 // Run the process
 createPackageJson({
   directory: directory,
   ignoreExisting: program.ignoreExisting,
+  existingPackage: program.existingPackage,
   noPrompt: program.noPrompt,
+  extended: program.extended,
   spacer: program.spacer,
   // check if string because there is a .name getter function, same with description
   name: typeof program.name === 'string' ? program.name : undefined,
@@ -53,6 +68,8 @@ createPackageJson({
   main: program.main,
   private: program.private,
   scripts: program.scripts,
-  dependencies: arrayFromList(program.dependencies),
-  devDependencies: arrayFromList(program.devDependencies)
+  dependencies: program.dependencies,
+  devDependencies: program.devDependencies,
+  updateDeps: program.updateDeps
+  // peerDependencies: program.peerDependencies
 })

index.js

@@ -12,7 +12,6 @@ const scopeAndName = require('./lib/scope-and-name')
 const gitRemote = require('./lib/git-remote')
 
 // @TODO https://docs.npmjs.com/files/package.json
-// man
 // bin
 // files
 // browser
@@ -40,27 +39,34 @@ module.exports = async function createPackageJson (input = {}) {
     spacer: 2,
     directory: cwd,
     pkgPath: path.join(input.directory || cwd, 'package.json'),
+    updateDeps: true,
     ignoreExisting: false,
     noPrompt: false,
-    silent: false
+    silent: false,
+    extended: false
   })
 
   // Read existing package.json
   const pkg = await readPackageJson(options)
 
   // Build up the package field options and merge it all together
-  const opts = await buildPackageOptions(options, pkg)
+  let opts = await buildPackageOptions(options, pkg)
+
+  opts = await prompt(opts, options)
+
+  // Merge peer deps into dev deps
+  // opts.devDependencies = opts.devDependencies.concat(opts.peerDependencies || [])
 
   // Format the json and write it out
-  return write(await prompt(opts, options), format(opts, pkg))
+  return write(opts, format(opts, pkg))
 }
 
 module.exports.readPackageJson = readPackageJson
 async function readPackageJson (opts = {}) {
   let pkg = {}
   if (opts.ignoreExisting !== true) {
     try {
-      pkg = await fs.readJSON(opts.pkgPath)
+      pkg = await fs.readJSON(opts.existingPackage || opts.pkgPath)
     } catch (e) {
       // ignore if missing or unreadable
     }
@@ -82,8 +88,12 @@ async function buildPackageOptions (options = {}, pkg = {}) {
   opts.license = options.license || pkg.license || 'ISC'
   opts.main = options.main || pkg.main || 'index.js'
   opts.private = defined(options.private, pkg.private)
-  opts.dependencies = mapDepToVersionString(arrayOrUndefined(options.dependencies) || pkg.dependencies || [])
-  opts.devDependencies = mapDepToVersionString(arrayOrUndefined(options.devDependencies) || pkg.devDependencies || [])
+  opts.dependencies = mapDepToVersionString(arrayOrUndefined(options.dependencies) || pkg.dependencies || [], !opts.updateDeps)
+  opts.devDependencies = mapDepToVersionString(arrayOrUndefined(options.devDependencies) || pkg.devDependencies || [], !opts.updateDeps)
+  // opts.peerDependencies = mapDepToVersionString(arrayOrUndefined(options.peerDependencies) || pkg.peerDependencies || [])
+
+  // Extended options
+  opts.man = options.man || pkg.man
 
   // Merge together scripts from opts and package.json
   opts.scripts = Object.assign({}, options.scripts || {}, pkg.scripts || {})
@@ -115,6 +125,13 @@ function format (opts, pkg = {}) {
   if (opts.private === true) {
     pkg.private = true
   }
+  if (opts.man && opts.man.length) {
+    pkg.man = Array.isArray(opts.man) && !opts.man[1] ? opts.man[0] : opts.man
+  }
+  // @TODO ensure they are formatted correctly?
+  // if (opts.peerDependencies) {
+  //   pkg.peerDependencies = opts.peerDependencies
+  // }
   return pkg
 }
 

lib/array-from-list.js

@@ -1,5 +1,5 @@
 'use strict'
-// vim: set ft=javascript:ts=2:sw=2
+// vim: set ft=javascript:ts=2:sw=2:
 
 module.exports = function arrayFromList (list) {
   let arr = list || []

lib/map-dep-to-version-string.js

@@ -1,6 +1,6 @@
 'use strict'
 // vim: set ft=javascript ts=2 sw=2:
 
-module.exports = function mapDepToVersionString (deps) {
-  return Array.isArray(deps) ? deps : Object.keys(deps).map((name) => `${name}@${deps[name]}`)
+module.exports = function mapDepToVersionString (deps, withVersion) {
+  return Array.isArray(deps) ? deps : Object.keys(deps).map((name) => withVersion ? `${name}@${deps[name]}` : name)
 }

lib/prompts.js

@@ -1,7 +1,9 @@
 'use strict'
 // vim: set ft=javascript ts=2 sw=2:
+const path = require('path')
 const inquirer = require('inquirer')
 const validatePackageName = require('validate-npm-package-name')
+const realizePackageSpecifier = require('realize-package-specifier')
 const arrayFromList = require('./array-from-list')
 const arrayOrUndefined = require('./array-or-undefined')
 
@@ -28,7 +30,8 @@ module.exports = async function prompt (opts = {}, options = {}) {
   }, {
     name: 'description',
     message: 'Description:',
-    default: opts.description,
+    // This is because inquirer treats an empty string as truthy and shows ()
+    default: opts.description ? opts.description : undefined,
     when: !options.description
   }, {
     name: 'author',
@@ -42,34 +45,46 @@ module.exports = async function prompt (opts = {}, options = {}) {
     when: !options.repository
   }, {
     name: 'keywords',
-    message: 'Keywords (ex: blockchain, ninja):',
+    message: 'Keywords [ex: blockchain, ninja]:',
     default: arrayOrUndefined(opts.keywords),
     when: !options.keywords,
     filter: arrayFromList
   }, {
     name: 'license',
-    message: 'License (ex: MIT, unlicensed):',
+    message: 'License [ex: MIT, unlicensed]:',
     default: opts.license,
     when: !options.license
   }, {
     name: 'main',
-    message: 'Entry point (main):',
+    message: 'Entry point:',
     default: opts.main,
     when: !options.main
   }, {
     name: 'dependencies',
-    message: 'Dependencies (ex: express, react):',
+    message: 'Dependencies [ex: express, react]:',
     default: arrayOrUndefined(opts.dependencies),
     when: !options.dependencies,
     filter: arrayFromList,
     validate: validatePackageNames
   }, {
     name: 'devDependencies',
-    message: 'Dev Dependencies (ex: mocha, webpack):',
+    message: 'Dev Dependencies [ex: mocha, webpack]:',
     default: arrayOrUndefined(opts.devDependencies),
     when: !options.devDependencies,
     filter: arrayFromList,
     validate: validatePackageNames
+  }, {
+    name: 'private',
+    type: 'confirm',
+    message: 'Is this package private?',
+    default: !!opts.private,
+    when: opts.extended && typeof options.private === 'undefined'
+  }, {
+    name: 'man',
+    message: 'Man Pages:',
+    default: opts.man,
+    when: opts.extended && !options.man,
+    filter: arrayFromList
   }])
 
   // Get custom scripts
@@ -89,28 +104,28 @@ async function promptForScripts (opts = {}, options = {}) {
     when: !options.scripts || !options.scripts.test
   }, {
     name: 'prepare',
-    message: 'Prepare script (run before publish and on local install):',
+    message: 'Prepare script [run before publish and on local install]:',
     default: s.prepare,
-    when: !options.scripts || !options.scripts.prepare
+    when: opts.extended && (!options.scripts || !options.scripts.prepare)
   }, {
     name: 'prepublushOnly',
-    message: 'Pre publush script (run only before publish):',
+    message: 'Pre publush script [run only before publish]:',
     default: s.prepublushOnly || 'npm t',
     when: !options.scripts || !options.scripts.prepublushOnly
   }, {
     name: 'postpublish',
     message: 'Post publish script:',
     default: s.postpublish,
-    when: !options.scripts || !options.scripts.postpublish
+    when: opts.extended && (!options.scripts || !options.scripts.postpublish)
   }, {
     name: 'preversion',
     message: 'Pre version script:',
-    default: s.postpublish,
-    when: !options.scripts || !options.scripts.postpublish
+    default: s.preversion,
+    when: opts.extended && (!options.scripts || !options.scripts.preversion)
   }])
 
   // Merge scripts and add any customs
-  const scripts = await promptForCustomScript(Object.assign(s, commonScripts))
+  const scripts = await promptForCustomScript(opts, Object.assign(s, commonScripts))
 
   // Remove empty scripts
   return Object.keys(scripts).reduce((s, key) => {
@@ -121,7 +136,11 @@ async function promptForScripts (opts = {}, options = {}) {
   }, {})
 }
 
-async function promptForCustomScript (scripts = {}) {
+async function promptForCustomScript (opts = {}, scripts = {}) {
+  if (!opts.extended) {
+    return scripts
+  }
+
   const {another} = await inquirer.prompt([{
     name: 'another',
     message: 'Add another script?',
@@ -143,13 +162,55 @@ async function promptForCustomScript (scripts = {}) {
 
   scripts[script.name] = script.content
 
-  return promptForCustomScript(scripts)
+  return promptForCustomScript(opts, scripts)
+}
+
+async function validatePackageNames (input) {
+  if (!input) {
+    return true
+  }
+
+  let valid = true
+  for (let i = 0; i < input.length && valid === true; i++) {
+    let pkg
+    try {
+      pkg = await realizePkgSpec(input[i])
+    } catch (e) {
+      return e
+    }
+
+    switch (pkg.type) {
+      // Directory checkes for package.json and
+      // hosted means it looks like a remote repo or tarball
+      case 'directory':
+      case 'hosted':
+        return true
+      case 'local':
+        // check for something that looks like a path
+        // because any random string is marked as local
+        if (pkg.raw.includes('.') || pkg.raw.includes(path.sep)) {
+          continue
+        }
+    }
+
+    // Manual check because the validate package just says "name cannot be null"
+    if (!pkg.name) {
+      return new Error('Invalid package name: ' + pkg.raw)
+    }
+
+    let v = validatePackageName(pkg.name)
+    valid = v.validForNewPackages || v.validForOldPackages ? true : ((v.errors && v.errors[0]) || `Invalid package name: ${input[i]}`)
+  }
+  return valid
 }
 
-function validatePackageNames (input) {
-  const error = input.reduce((err, name) => {
-    let v = validatePackageName(name)
-    return err || (v.validForNewPackages || v.validForOldPackages ? true : ((v.errors && v.errors[0]) || `Invalid package name: ${name}`))
-  }, null)
-  return error || true
+function realizePkgSpec (name) {
+  return new Promise((resolve, reject) => {
+    realizePackageSpecifier(name, (err, pkg) => {
+      if (err) {
+        return reject(err)
+      }
+      resolve(pkg)
+    })
+  })
 }