adapt-cli 2.1.13 → 3.0.0

package/lib/api.js

@@ -0,0 +1,260 @@
+import http from 'http' // api http import, to hold open process for testing
+import { ADAPT_FRAMEWORK } from './util/constants.js'
+import {
+  build,
+  download,
+  erase,
+  getLatestVersion,
+  npmInstall,
+  deleteSrcCourse,
+  deleteSrcCore
+} from './integration/AdaptFramework.js'
+import {
+  install,
+  uninstall,
+  update,
+  schemas
+} from './integration/PluginManagement.js'
+import Plugin from './integration/Plugin.js'
+import Project from './integration/Project.js'
+import fs from 'fs-extra'
+import async from 'async'
+
+// TODO: api, check no interactivity, should be sorted, will fail silently if it absolutely cannot do what you've asked
+// TODO: api, console and error output, error on fail when isInteractive: false? or something else? return Targets?
+// TODO: api, figure out error translations, should probably error with codes?
+
+class API {
+  /**
+   * Installs a clean copy of the framework
+   * @param {Object} options
+   * @param {string} [options.version=null] Specific version of the framework to install
+   * @param {string} [options.repository] URL to github repo
+   * @param {string} [options.cwd=process.cwd()] Directory to install into
+   * @return {Promise}
+   */
+  async installFramework ({
+    version = null,
+    repository = ADAPT_FRAMEWORK,
+    cwd = process.cwd()
+  } = {}) {
+    if (!version) version = await getLatestVersion({ repository })
+    await erase({
+      isInteractive: false,
+      cwd
+    })
+    await download({
+      repository,
+      branch: version,
+      cwd
+    })
+    await deleteSrcCourse({
+      cwd
+    })
+    await deleteSrcCore({
+      cwd
+    })
+    await npmInstall({
+      cwd
+    })
+  }
+
+  /**
+   * @param {Object} options
+   * @param {Object} [options.repository=ADAPT_FRAMEWORK] The github repository url
+   * @returns {string}
+   */
+  async getLatestFrameworkVersion ({
+    repository = ADAPT_FRAMEWORK
+  } = {}) {
+    return getLatestVersion({ repository })
+  }
+
+  /**
+   * Runs build for a current course
+   * @param {Object} options
+   * @param {boolean} [options.sourceMaps=false] Whether to run the build with sourcemaps
+   * @param {boolean} [options.checkJSON=false] Whether to run without checking the json
+   * @param {boolean} [options.cache=true] Whether to clear build caches
+   * @param {string} [options.outputDir="build/"] Root path of the framework installation
+   * @param {string} [options.cachePath="build/.cache"] Path of compilation cache file
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise}
+   */
+  async buildCourse ({
+    sourceMaps = false,
+    checkJSON = false,
+    cache = true,
+    outputDir = null,
+    cachePath = './build/.cache',
+    cwd = process.cwd()
+  } = {}) {
+    await build({
+      sourceMaps,
+      checkJSON,
+      cache,
+      cwd,
+      outputDir,
+      cachePath
+    })
+  }
+
+  /**
+   * Installs multiple plugins
+   * Can install from source folder or bower registry
+   * @param {Object} options
+   * @param {[string]} [options.plugins=null] An array with name@version or name@path strings
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise<[Target]>}
+   */
+  async installPlugins ({
+    plugins = null,
+    cwd = process.cwd()
+  } = {}) {
+    return await install({
+      plugins,
+      isInteractive: false,
+      cwd
+    })
+  }
+
+  /**
+   * Uninstalls multiple plugins
+   * @param {Object} options
+   * @param {[string]} [options.plugins=null] An array with name@version or name@path strings
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise<[Target]>}
+   */
+  async uninstallPlugins ({
+    plugins = null,
+    cwd = process.cwd()
+  } = {}) {
+    return await uninstall({
+      plugins,
+      isInteractive: false,
+      cwd
+    })
+  }
+
+  /**
+   * Updates multiple plugins
+   * Can install from source folder or bower registry
+   * @param {Object} options
+   * @param {[string]} [options.plugins=null] An array with name@version or name@path strings
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise<[Target]>}
+   */
+  async updatePlugins ({
+    plugins = null,
+    cwd = process.cwd()
+  } = {}) {
+    return await update({
+      plugins,
+      isInteractive: false,
+      cwd
+    })
+  }
+
+  /**
+   * Retrieves all schemas defined in the project
+   * Clears schema cache
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise<[string]>} Resolves with array of JSON schema filepaths
+   */
+  async getSchemaPaths ({
+    cwd = process.cwd()
+  } = {}) {
+    this._schemaPaths = await schemas({ cwd })
+    this._schemas = {}
+    return this._schemaPaths
+  }
+
+  /**
+   * Retrieves named schema
+   * Caches schemas for subsequent use
+   * Call getSchemaPaths to reset cache
+   * @param {string} options.name Schema filepath as returned from getSchemaPaths
+   * @return {Promise<Object>} Resolves with the JSON schema contents
+   */
+  async getSchema ({
+    name
+  } = {}) {
+    if (!this._schemaPaths) return new Error('Please run getSchemaPaths first')
+    if (!fs.existsSync(name) || !this._schemaPaths.includes(name)) throw new Error(`Schema does not exist: ${name}`)
+    return (this._schemas[name] = this._schemas[name] ?? await fs.readJSON(name))
+  }
+
+  /**
+   * Returns all installed plugins
+   * @return {Promise<[Plugin]>}
+   */
+  async getInstalledPlugins ({
+    cwd = process.cwd()
+  } = {}) {
+    const project = new Project({ cwd })
+    if (!project.isAdaptDirectory) throw new Error(`Not in an adapt folder at: ${cwd}`)
+    const installedPlugins = await project.getInstalledPlugins()
+    for (const plugin of installedPlugins) {
+      await plugin.fetchProjectInfo()
+    }
+    return installedPlugins
+  }
+
+  /**
+   * Gets the update information for installed and named plugins
+   * @param {Object} options
+   * @param {[string]} [options.plugins=null] An y of plugin names (if not specified, all plugins are checked)
+   * @param {string} [options.cwd=process.cwd()] Root path of the framework installation
+   * @return {Promise<[Plugin]>}
+   */
+  async getPluginUpdateInfos ({
+    plugins = null,
+    cwd = process.cwd()
+  } = {}) {
+    /** @type {Project} */
+    const project = new Project({ cwd })
+    if (!project.isAdaptDirectory) throw new Error(`Not in an adapt folder at: ${cwd}`)
+    const frameworkVersion = project.version
+    /** @type {[Plugin]} */
+    const installedPlugins = await project.getInstalledPlugins()
+    const filteredPlugins = !plugins?.length
+      ? installedPlugins
+      : plugins
+        .map(name => installedPlugins.find(plugin => plugin.packageName === name))
+        .filter(Boolean)
+    await async.eachOfLimit(filteredPlugins, 8, async plugin => {
+      await plugin.fetchProjectInfo()
+      await plugin.fetchBowerInfo()
+      await plugin.findCompatibleVersion(frameworkVersion)
+    })
+    return filteredPlugins
+  }
+
+  /**
+   * Returns an object representing the plugin at the path specified
+   * @returns {Plugin}
+   */
+  async getPluginFromPath ({
+    pluginPath,
+    cwd = null
+  } = {}) {
+    const project = cwd ? new Project({ cwd }) : null
+    return Plugin.fromPath({ pluginPath, project })
+  }
+}
+
+const api = new API()
+export default api
+
+// debugging
+if (process.argv.includes('--debug-wait')) {
+  // http server to hold open process for testing
+  const a = http.createServer((request, response) => {
+    response.writeHead(200, { 'Content-Type': 'text/plain' })
+    response.end('test', 'utf-8')
+  })
+  a.listen(999)
+  // make api global to debug more easily
+  global.api = api
+  console.log('API Ready')
+}

package/lib/cli.js

@@ -1,52 +1,69 @@
-var path = require('path'),
-    _ = require('lodash'),
-    CommandParser = require('./CommandParser'),
-    AdaptConsoleApplication = require('./AdaptConsoleApplication'),
-    stdoutRenderer = {
-        log: _.bind(console.log, console),
-        write: _.bind(process.stdout.write, process.stdout)
-    };
+import authenticate from './commands/authenticate.js'
+import create from './commands/create.js'
+import devinstall from './commands/devinstall.js'
+import help from './commands/help.js'
+import install from './commands/install.js'
+import ls from './commands/ls.js'
+import register from './commands/register.js'
+import rename from './commands/rename.js'
+import search from './commands/search.js'
+import uninstall from './commands/uninstall.js'
+import unregister from './commands/unregister.js'
+import update from './commands/update.js'
+import version from './commands/version.js'
+import logger from './logger.js'
 
-function withPackage(pack) {
-    this.pkg = pack || require(path.join(__dirname, '..', 'package.json'));
-    return this;
+const commands = {
+  authenticate,
+  create,
+  devinstall,
+  help,
+  install,
+  ls,
+  register,
+  rename,
+  search,
+  uninstall,
+  unregister,
+  update,
+  version
 }
 
-function withOptions(argv) {
-    argv = argv || process.argv;
-    this.command = new CommandParser(argv);
-    return this;
-}
-
-function execute() {
-    var commands = require('./commands'),
-        app = new AdaptConsoleApplication(commands, stdoutRenderer);
-
-    app.do(this.command, function (err) {
-        process.exit(err ? 1: 0);
-    });
-}
-
-function getApi() {
-    var commands = require('./commands');
-    var apiCommands = {};
+const translationTable = [
+  { pattern: /^-v$|^--version$/i, replacement: 'version' },
+  { pattern: /^upgrade$/i, replacement: 'update' }
+]
 
-    _.each(commands, function(command, commandName) {
-        var prefix = 'api';
-        if (commandName.startsWith(prefix)) {
-            apiCommands[commandName.split(prefix)[1]] = command;
-        }
-    });
+class CLI {
+  withOptions (argv = process.argv || ['node', 'path']) {
+    const parameters = argv.slice(2).map(param => {
+      const translation = translationTable.find(item => item.pattern.test(param))
+      return translation ? translation.replacement : param
+    })
+    const name = parameters.length
+      ? String.prototype.toLowerCase.call(parameters.shift())
+      : ''
+    this.command = {
+      name,
+      parameters
+    }
+    return this
+  }
 
-    return {
-        commands:apiCommands
+  async execute () {
+    try {
+      if (!commands[this.command.name]) {
+        const e = new Error(`Unknown command "${this.command.name}", please check the documentation.`)
+        logger?.log(e.message)
+        throw e
+      }
+      const commandArguments = [logger].concat(this.command.parameters)
+      await commands[this.command.name](...commandArguments)
+    } catch (err) {
+      console.error(err)
+      process.exit(err ? 1 : 0)
     }
+  }
 }
 
-module.exports = {
-    command: null,
-    withOptions: withOptions,
-    withPackage: withPackage,
-    execute: execute,
-    api: getApi()
-};
+export default new CLI()

package/lib/commands/authenticate.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk'
+import { authenticate as pluginAuthenticate } from '../integration/PluginManagement.js'
+
+export default async function authenticate (logger, ...args) {
+  // strip flags
+  args = args.filter(arg => !String(arg).startsWith('--'))
+  try {
+    const confirmation = await pluginAuthenticate({
+      logger,
+      cwd: process.cwd(),
+      pluginName: args[0]
+    })
+    const { username, type, pluginName } = confirmation
+    logger?.log(chalk.green(`${username} authenticated as ${type} for ${pluginName}`))
+  } catch (err) {
+    logger?.error('Authentication failed')
+  }
+}

package/lib/commands/create/component.js

@@ -1,81 +1,64 @@
-var chalk = require('chalk'),
-    Q = require('q'),
-    getRepository = require('../../promise/getRepository'),
-    removeTemporaryDownload = require('../../promise/removeTemporaryDownload'),
-    replaceTextContent = require('../../promise/replaceTextContent'),
-    slug = require('../../Slug'),
-    Constants = require('../../Constants');
+import fs from 'fs-extra'
+import globs from 'globs'
+import path from 'path'
+import chalk from 'chalk'
+import slug from 'speakingurl'
+import Project from '../../integration/Project.js'
+import downloader from '../../util/download.js'
+import { ADAPT_COMPONENT } from '../../util/constants.js'
 
-module.exports = function (properties) {
-    var fs = require('fs'),
-        path = require('path');
+export default async function component ({
+  name,
+  repository = ADAPT_COMPONENT,
+  cwd,
+  branch,
+  logger
+}) {
+  name = slug(name, { maintainCase: true })
 
-    properties.component = {
-        name: slug(properties.localDir),
-        files: []
-    };
-    properties.relative = function (file) {
-        return path.join(this.localDir, file);
-    };
+  const project = new Project({ cwd, logger })
+  let pluginDir
+  if (project.containsManifestFile) {
+    const componentsDirectory = 'src/components'
+    pluginDir = path.join(cwd, componentsDirectory, 'adapt-' + name)
+    if (!fs.existsSync(componentsDirectory)) fs.mkdirSync(componentsDirectory)
+  } else {
+    pluginDir = path.join(cwd, name)
+  }
 
-    if(addComponentToCurrentCourse()) {
-        var componentsDirectory = 'src/components';
-        properties.localDir = path.join(componentsDirectory, properties.localDir);
-        if(!fs.existsSync(componentsDirectory)) fs.mkdirSync(componentsDirectory);
-    }
-    properties.component.files.push(properties.relative('bower.json'));
+  await downloader({
+    branch,
+    repository,
+    cwd: pluginDir,
+    logger
+  })
 
-    return createComponent(properties)
-            .then(function (properties) {
-                properties.renderer.log('\n' + chalk.green(properties.localDir), 'has been created.\n');
+  const files = await new Promise((resolve, reject) => {
+    globs('**', { cwd: pluginDir }, (err, matches) => {
+      if (err) return reject(err)
+      resolve(matches.map(match => path.join(pluginDir, match)))
+    })
+  })
 
-                if(addComponentToCurrentCourse()) {
-                    properties.renderer.log(chalk.grey('To use this component in your course, use the registered name:') + chalk.yellow(properties.component.name));
-                }
-            });
-};
+  const filesRenamed = files.map(from => {
+    const to = from.replace(/((contrib-)?componentName)/g, name)
+    fs.renameSync(from, to)
+    return to
+  })
 
-function addComponentToCurrentCourse() {
-    var fs = require('fs');
-    return fs.existsSync('./adapt.json');
-}
-
-function createComponent(properties) {
-    properties.repository = Constants.ComponentRepository;
-    properties.repositoryName = Constants.ComponentRepositoryName;
-    return getRepository(properties)
-            .then(removeTemporaryDownload)
-            .then(renameFiles)
-            .then(renameVariables);
-}
+  await Promise.all(filesRenamed.map(async function (file) {
+    if (fs.statSync(file).isDirectory()) return
+    const lowerCaseName = name.toLowerCase()
+    const content = (await fs.readFile(file)).toString()
+    const modifiedContent = content
+      .replace(/((contrib-)?componentName)/g, name)
+      .replace(/((contrib-)?componentname)/g, lowerCaseName)
+    return fs.writeFile(file, modifiedContent)
+  }))
 
-function renameFiles(properties) {
-   var fs = require('fs'),
-       path = require('path');
+  logger?.log('\n' + chalk.green(pluginDir), 'has been created.\n')
 
-   var files = [
-        { match: 'js/adapt-contrib-componentName.js', replace: /contrib-componentName/ },
-        { match: 'less/componentName.less', replace: /componentName/ },
-        { match: 'templates/componentName.hbs', replace: /componentName/ }
-   ];
-   var renameFiles = files.map(function (file) {
-        return {
-            from: properties.relative(file.match),
-            to: properties.relative(file.match.replace(file.replace, properties.component.name))
-        };
-   });
-   renameFiles.forEach(function (file) {
-        fs.renameSync(file.from, file.to);
-        properties.component.files.push(file.to);
-   });
-   return properties;
+  if (fs.existsSync('./adapt.json')) {
+    logger?.log(chalk.grey('To use this component in your course, use the registered name:') + chalk.yellow(name))
+  }
 }
-
-function renameVariables(properties) {
-    var renameFileContentPromises = properties.component.files.map(function (file) {
-        return replaceTextContent(file, (/((contrib-)?componentName)/g), properties.component.name);
-    });
-    return Q.all(renameFileContentPromises).then(function () {
-        return properties;
-    });
-}

package/lib/commands/create/course.js

@@ -1,81 +1,26 @@
-var bower = require('bower'),
-    chalk = require('chalk'),
-    inquirer = require('inquirer'),
-    path = require('path'),
-    Q = require('q'),
-    fs = require('q-io/fs'),
-    Plugin = require('../../Plugin'),
-    getRepository = require('../../promise/getRepository'),
-    removeTemporaryDownload = require('../../promise/removeTemporaryDownload'),
-    installNodeDependencies = require('../../promise/installNodeDependencies'),
-    installAdaptDependencies = require('../../promise/installAdaptDependencies'),
-    _ = require('lodash');
-
-module.exports = function (properties) {
-    var progress = _.throttle(function () {
-        properties.renderer.write(chalk.grey('.'));
-    }, 300);
-
-    return deleteExistingCourse(properties)
-        .then(function (properties) {
-            properties.renderer.write(chalk.cyan('downloading framework to', properties.localDir, '\t'));
-            return properties;
-        })
-        .then(getRepository)
-        .progress(function (data) {
-            progress();
-            return data;
-        })
-        .then(function (properties) {
-            properties.renderer.log(' ', 'done!');
-            return properties;
-        })
-        .then(removeTemporaryDownload)
-        .then(installNodeDependencies)
-        .then(installAdaptDependencies)
-        .then(function (properties) {
-            properties.renderer.log('\n' + chalk.green(properties.localDir), 'has been created.\n');
-
-            properties.renderer.log(chalk.grey('To build the course, run:') +
-                '\n\tcd ' + properties.localDir +
-                '\n\tgrunt build\n');
-
-            properties.renderer.log(chalk.grey('Then to view the course, run:') +
-                '\n\tgrunt server\n');
-        });
-
-};
-
-function deleteExistingCourse(properties) {
-    return fs.exists(properties.localDir)
-        .then(function (exists) {
-            if(exists) {
-                var deferred = Q.defer();
-
-                inquirer.prompt([
-                    {
-                        name: 'overwrite existing course?',
-                        type: 'confirm',
-                        default: false
-                    }
-                ]).then(results => {
-                    if(results['overwrite existing course?']) {
-                        fs.removeTree(properties.localDir)
-                            .then(function (){
-                                deferred.resolve(properties);
-                            })
-                            .fail(function (err) {
-                                deferred.reject(err);
-                            });
-                    } else {
-                        deferred.reject(new Error('Course already exists and cannot overwrite.'));
-                    }
-                }).catch(err => deferred.reject(err));
-
-                return deferred.promise;
-            }
-        })
-        .then(function () {
-            return properties;
-        });
+import chalk from 'chalk'
+import {
+  erase,
+  download,
+  npmInstall
+} from '../../integration/AdaptFramework.js'
+import path from 'path'
+import { install as pluginsInstall } from '../../integration/PluginManagement.js'
+
+export default async function course ({ name, branch, cwd, logger }) {
+  cwd = path.join(cwd, name)
+  await erase({ logger, cwd })
+  await download({ logger, cwd, branch })
+  await npmInstall({ logger, cwd })
+  await pluginsInstall({ logger, cwd })
+  logger?.log(`
+${chalk.green(name)} has been created.
+
+${chalk.grey('To build the course, run:')}
+  cd ${name}
+  grunt build
+
+${chalk.grey('Then to view the course, run:')}
+  grunt server
+`)
 }

package/lib/commands/create/question.js

@@ -0,0 +1,18 @@
+import component from './component.js'
+import { ADAPT_QUESTION } from '../../util/constants.js'
+
+export default async function question ({
+  name,
+  repository = ADAPT_QUESTION,
+  cwd,
+  branch,
+  logger
+}) {
+  return component({
+    name,
+    repository,
+    cwd,
+    branch,
+    logger
+  })
+}