includable / cli

'use strict'

const util = require('../util')

const output = require('../output')

const helpers = require('../run-helpers')

const pkg = require('../../package.json')

const fs = require('fs')

const os = require('os')

const path = require('path')

const https = require('https')

const name = require('git-user-name')

const email = require('git-user-email')

const child = require('child_process')

const unzip = require('unzip-stream')

const rimraf = require('rimraf')

const jsonfile = require('jsonfile')

const mkdirp = require('mkdirp')

var Kit = {}

function extractZip (response, zipName, containerPath, callback, namespace, url) {

  // Create cache directory

  var tmpdir = path.join(os.tmpdir(), 'inc-v' + pkg.version, namespace)

  try {

    mkdirp.sync(tmpdir)

  } catch (e) {

    return callback(e)

  }

  return response

    .pipe(unzip.Extract({

      path: tmpdir

    }))

    .on('error', function (err) {

      callback(err)

    })

    .on('close', function () {

      setTimeout(function () {

        try {

          // At this point, there is a good possibility that all files got

          // extracted to a subdirectory, which we should correct

          var zipPath = path.join(tmpdir, zipName)

          if (!fs.existsSync(zipPath)) {

            return callback(new Error('Error extracting zip file'))

          }

          // Check requirements

          var json = jsonfile.readFileSync(path.join(zipPath, 'module.json'))

          var res = Kit.checkRequirements(json, namespace, url, zipPath)

          if (res !== true) {

            callback(res)

            rimraf.sync(zipPath)

            process.exit()

          }

          fs.renameSync(zipPath, path.resolve(containerPath))

          // Calling back home

        } catch (e) {

          return callback(e)

        }

      }, 500)

    })

}

function downloadZip (zipUrl, zipName, containerPath, callback, namespace, origUrl) {

  https.get(zipUrl, function (response) {

    if (response.statusCode >= 200 && response.statusCode < 300) {

      return extractZip(response, zipName, containerPath, callback, namespace, origUrl || zipUrl)

    }

    if (response.headers.location) {

      return downloadZip(response.headers.location, zipName, containerPath, callback, namespace, zipUrl)

    }

  }).on('error', function (err) {

    callback(err)

  })

}

function postProcess (slug) {

  // Remove stock files

  try { fs.unlinkSync(path.join(slug, 'LICENSE.md')) } catch (e) {}

  try { fs.unlinkSync(path.join(slug, 'LICENSE')) } catch (e) {}

  try { fs.unlinkSync(path.join(slug, 'README')) } catch (e) {}

  try { rimraf.sync(path.join(slug, '.git')) } catch (e) {}

  // Write readme.md

  fs.writeFileSync(path.join(slug, 'README.md'), '# ' +

    util.boxNameDisplay(slug) + '\n\nA Incluable app for ' + util.boxNameDisplay(slug) + '.', 'utf8')

  // Download IDE helper

  var ideSpinner = output.wait('Downloading code completion helper')

  util.downloadHelper(function () {

    ideSpinner(true)

    // Git init

    var gitSpinner = output.wait('Initializing local Git repository')

    child.exec('cd "' + slug + '" && git init', function (err) {

      gitSpinner(err ? err : true)

    })

  }, slug)

}

Kit.download = function (kitName, targetPath, callback) {

  var containerPath = path.resolve(targetPath)

  var kitNameResolved = this.resolveName(kitName)

  var namespace = kitNameResolved.split('/')[0]

  var kitNameSimplified = kitNameResolved.split('/')[1]

  var zipUrl = 'https://github.com/' + kitNameResolved + '/archive/master.zip'

  downloadZip(zipUrl, kitNameSimplified + '-master', containerPath, callback, namespace)

}

Kit.resolveName = function (kitName) {

  kitName = kitName.replace(/\s/ig, '')

  if (kitName.indexOf('/') > 0) {

    // Repo name already includes user/org, so skip any other processing

    return kitName

  }

  // Prepend 'starter-'

  if (kitName.indexOf('starter-') !== 0) {

    kitName = 'starter-' + kitName

  }

  // Prepend org name

  return 'includable-modules/' + kitName

}

Kit.checkRequirements = function (json, namespace, url, zipPath) {

  // If not exists, no need to check anything

  if (!('_starter' in json) || typeof json._starter !== 'object') {

    return true

  }

  // Check minimal CLI version to run this starter kit

  // if ('minVersion' in json._starter && compareVersions(json._starter.minVersion, pkg.version) === 1) {

  //   return 'Starter kit requires version ' + json._starter.minVersion + ' of ' +

  //     'Includable CLI, but you have ' + pkg.version + '. Please update!'

  // }

  // Save starter.json meta data

  mkdirp.sync(path.join(zipPath, '.inc', 'meta'))

  json._starter.sourceUrl = url

  json._starter.namespace = namespace

  jsonfile.writeFileSync(path.join(zipPath, '.inc', 'meta', 'starter.json'), json._starter)

  // Remove starter meta data

  delete json['_starter']

  return true

}

Kit.create = function (kitName, slug) {

  // Get slug

  var userName = (util.getSystemUsername() || 'user').toLowerCase()

  if (slug.match(/^[a-z0-9-]+\/[a-z0-9-]+$/)) {

    userName = slug.split('/')[0]

    slug = slug.split('/')[1]

  }

  if (!slug.match(/^[a-z0-9-]+$/)) {

    output.err('Module name should only contain lowercase letters, numbers and dashes.')

    return

  }

  // Check if directory doesn't already exist

  var stopSpinner = output.wait('Downloading template \'' + kitName + '\'')

  if (fs.existsSync(slug)) {

    stopSpinner('Directory \'' + slug + '\' already exists!')

    return

  }

  try {

    Kit.download(kitName, slug, function (err) {

      if (err) {

        stopSpinner(err)

        return

      }

      stopSpinner(true)

      // Write module.json

      var json = jsonfile.readFileSync(path.join(slug, 'module.json'))

      json = util.moduleJSON(slug, userName, name({

        type: 'global'

      }), email({

        type: 'global'

      }), json)

      fs.writeFileSync(path.join(slug, 'module.json'), JSON.stringify(json, null, 3), 'utf8')

      // Write composer.json

      if (!fs.existsSync(path.join(slug, 'composer.json'))) {

        fs.writeFileSync(path.join(slug, 'composer.json'), JSON.stringify({

          'require': {}

        }, null, 3), 'utf8')

      }

      // Write version file

      mkdirp.sync(path.join(slug, '.inc'))

      fs.writeFileSync(path.join(slug, '.inc', 'version'), '11', 'utf8')

      // Scripts

      helpers.startChildProcess('post-create', function () {

        postProcess(slug)

      }, slug)

    })

  } catch (e) {

    stopSpinner(e)

  }

}

module.exports = Kit