packager

app/node_modules/electron-packager/infer.js

@@ -0,0 +1,140 @@
+'use strict'
+
+const debug = require('debug')('electron-packager')
+const getPackageInfo = require('get-package-info')
+const parseAuthor = require('parse-author')
+const path = require('path')
+const pify = require('pify')
+const resolve = require('resolve')
+
+function isMissingRequiredProperty (props) {
+  return props.some(prop => prop === 'productName' || prop === 'dependencies.electron')
+}
+
+function errorMessageForProperty (prop) {
+  let hash, propDescription
+  switch (prop) {
+    case 'productName':
+      hash = 'name'
+      propDescription = 'application name'
+      break
+    case 'dependencies.electron':
+      hash = 'electronversion'
+      propDescription = 'Electron version'
+      break
+    default:
+      hash = ''
+      propDescription = '[Unknown Property]'
+  }
+
+  return `Unable to determine ${propDescription}. Please specify an ${propDescription}\n\n` +
+    'For more information, please see\n' +
+    `https://github.com/electron-userland/electron-packager/blob/master/docs/api.md#${hash}\n`
+}
+
+function getVersion (opts, electronProp) {
+  // Destructured assignments are added in Node 6
+  const splitProp = electronProp.prop.split('.')
+  const depType = splitProp[0]
+  const packageName = splitProp[1]
+  const src = electronProp.src
+  if (packageName === 'electron-prebuilt-compile') {
+    // electron-prebuilt-compile cannot be resolved because `main` does not point
+    // to a valid JS file.
+    const electronVersion = electronProp.pkg[depType][packageName]
+    if (!/^\d+\.\d+\.\d+/.test(electronVersion)) {
+      throw new Error('Using electron-prebuilt-compile with Electron Packager requires specifying an exact Electron version')
+    }
+
+    opts.electronVersion = electronVersion
+    return Promise.resolve()
+  } else {
+    return pify(resolve, { multiArgs: true })(packageName, { basedir: path.dirname(src) })
+      .then(res => {
+        debug(`Inferring target Electron version from ${packageName} in ${src}`)
+        const pkg = res[1]
+        opts.electronVersion = pkg.version
+        return null
+      })
+  }
+}
+
+function handleMetadata (opts, result) {
+  if (result.values.productName) {
+    debug(`Inferring application name from ${result.source.productName.prop} in ${result.source.productName.src}`)
+    opts.name = result.values.productName
+  }
+
+  if (result.values.version) {
+    debug(`Inferring appVersion from version in ${result.source.version.src}`)
+    opts.appVersion = result.values.version
+  }
+
+  if (result.values.author && !opts.win32metadata) {
+    opts.win32metadata = {}
+  }
+
+  if (result.values.author) {
+    debug(`Inferring win32metadata.CompanyName from author in ${result.source.author.src}`)
+    if (typeof result.values.author === 'string') {
+      opts.win32metadata.CompanyName = parseAuthor(result.values.author).name
+    } else if (result.values.author.name) {
+      opts.win32metadata.CompanyName = result.values.author.name
+    } else {
+      debug('Cannot infer win32metadata.CompanyName from author, no name found')
+    }
+  }
+
+  if (result.values['dependencies.electron']) {
+    return getVersion(opts, result.source['dependencies.electron'])
+  } else {
+    return Promise.resolve()
+  }
+}
+
+module.exports = function getMetadataFromPackageJSON (platforms, opts, dir) {
+  let props = []
+  if (!opts.name) props.push(['productName', 'name'])
+  if (!opts.appVersion) props.push('version')
+  if (!opts.electronVersion) {
+    props.push([
+      'dependencies.electron',
+      'devDependencies.electron',
+      'dependencies.electron-prebuilt-compile',
+      'devDependencies.electron-prebuilt-compile',
+      'dependencies.electron-prebuilt',
+      'devDependencies.electron-prebuilt'
+    ])
+  }
+
+  if (platforms.indexOf('win32') !== -1 && !(opts.win32metadata && opts.win32metadata.CompanyName)) {
+    props.push('author')
+  }
+
+  // Name and version provided, no need to infer
+  if (props.length === 0) return Promise.resolve()
+
+  // Search package.json files to infer name and version from
+  return pify(getPackageInfo)(props, dir)
+    .then(result => handleMetadata(opts, result))
+    .catch(err => {
+      if (err.missingProps) {
+        const missingProps = err.missingProps.map(prop => {
+          return Array.isArray(prop) ? prop[0] : prop
+        })
+
+        if (isMissingRequiredProperty(missingProps)) {
+          const messages = missingProps.map(errorMessageForProperty)
+
+          debug(err.message)
+          err.message = messages.join('\n') + '\n'
+          throw err
+        } else {
+          // Missing props not required, can continue w/ partial result
+          return handleMetadata(opts, err.result)
+        }
+      }
+
+      throw err
+    })
+}