adapt-cli 2.1.13 → 3.0.0

package/lib/commands/create.js

@@ -1,90 +1,85 @@
-var bower = require('bower'),
-    chalk = require('chalk'),
-    inquirer = require('inquirer'),
-    path = require('path'),
-    Q = require('q'),
-    Constants = require('../Constants'),
-    Plugin = require('../Plugin'),
-    create = require('./create/index'),
-    highest = require('../promise/highest'),
-    _ = require('lodash');
+import inquirer from 'inquirer'
+import component from './create/component.js'
+import question from './create/question.js'
+import course from './create/course.js'
+import { ADAPT_FRAMEWORK } from '../util/constants.js'
+import { getLatestVersion as getAdaptLatestVersion } from '../integration/AdaptFramework.js'
 
-module.exports = {
-    create: function (renderer) {
-        var type = arguments.length >= 3 ? arguments[1] : Constants.DefaultCreateType,
-            localDir = arguments.length >= 4 ? arguments[2] : undefined,
-            branch = arguments.length >= 5 ? arguments[3] : undefined,
-            done = arguments[arguments.length-1];
-        highest()
-            .then(function (tag) {
-                return confirm({
-                    type: type,
-                    localDir: localDir,
-                    branch: branch || tag,
-                    renderer: renderer
-                });
-        })
-        .then(function (properties) {
-            var action = create[properties.type];
-            if(!action) throw new Error('' + properties.type + ' is not a supported type');
-            return action(properties);
-        })
-        .then(function () {
-            done();
-        })
-        .fail(function (err) {
-            renderer.log(chalk.red("Oh dear, something went wrong. I'm terribly sorry."), err.message);
-            done(err);
-        });
-    }
-};
-
-function confirm(properties) {
-    var deferred = Q.defer(),
-        renderer = properties.renderer;
-
-    var typeSchema = [
-        {
-            name: 'type',
-            choices: [ 'course', 'component' ],
-            type: 'list',
-            default: properties.type
-        }
-    ];
+const subTasks = {
+  component,
+  question,
+  course
+}
 
-    inquirer.prompt(typeSchema).then(typeSchemaResults => {
-        var propertySchema = [
-            {
-                name: 'localDir',
-                message: 'name',
-                type: 'input',
-                default: properties.localDir || Constants.DefaultTypeNames[typeSchemaResults.type]
-            },
-            {
-                name: 'branch',
-                message: 'branch/tag',
-                type: 'input',
-                default: properties.branch || 'not specified'
-            },
-            {
-                name: 'ready',
-                message: 'create now?',
-                type: 'confirm',
-                default: true
-            }
-        ];
+/**
+ * TODO: Change component name to camel case
+ */
+export const DEFAULT_TYPE_NAME = {
+  course: 'my-adapt-course',
+  component: 'myAdaptComponent',
+  question: 'myAdaptQuestion'
+}
 
-        inquirer.prompt(propertySchema).then(propertySchemaResults => {
-            if(!propertySchemaResults.ready) deferred.reject(new Error('Aborted. Nothing has been created.'));
+export default async function create (logger, type = 'course', name, branch) {
+  const options = await confirmOptions({
+    type,
+    name,
+    branch,
+    logger
+  })
+  const action = subTasks[options.type]
+  if (!action) throw new Error('' + options.type + ' is not a supported type')
+  try {
+    await action({
+      name: options.name,
+      branch: options.branch,
+      cwd: process.cwd(),
+      logger
+    })
+  } catch (err) {
+    logger?.error("Oh dear, something went wrong. I'm terribly sorry.", err.message)
+    throw err
+  }
+}
 
-            var properties = _.extend({},
-                typeSchemaResults,
-                propertySchemaResults,
-                {
-                    renderer: renderer
-                });
-            deferred.resolve(properties);
-        }).catch(err => deferred.reject(err));
-    }).catch(err => deferred.reject(err));
-    return deferred.promise;
+async function confirmOptions ({ logger, type, name, branch }) {
+  const typeSchema = [
+    {
+      name: 'type',
+      choices: ['course', 'component', 'question'],
+      type: 'list',
+      default: type
+    }
+  ]
+  const typeSchemaResults = await inquirer.prompt(typeSchema)
+  branch = branch || (typeSchemaResults.type === 'course')
+    ? await getAdaptLatestVersion({ repository: ADAPT_FRAMEWORK })
+    : 'master'
+  const propertySchema = [
+    {
+      name: 'name',
+      message: 'name',
+      type: 'input',
+      default: name || DEFAULT_TYPE_NAME[typeSchemaResults.type]
+    },
+    {
+      name: 'branch',
+      message: 'branch/tag',
+      type: 'input',
+      default: branch || 'not specified'
+    },
+    {
+      name: 'ready',
+      message: 'create now?',
+      type: 'confirm',
+      default: true
+    }
+  ]
+  const propertySchemaResults = await inquirer.prompt(propertySchema)
+  if (!propertySchemaResults.ready) throw new Error('Aborted. Nothing has been created.')
+  const finalProperties = {
+    ...typeSchemaResults,
+    ...propertySchemaResults
+  }
+  return finalProperties
 }

package/lib/commands/devinstall.js

@@ -1,97 +1,35 @@
-var promise = require('../promise/util');
-
-module.exports = function (dependencies) {
-
-    var chalk = dependencies.chalk || require('chalk'),
-        path = dependencies.path || require('path'),
-        Q = dependencies.Q || require('q'),
-        Constants = dependencies.Constants || require('../Constants'),
-        PluginTypeResolver = dependencies.PluginTypeResolver || require('../PluginTypeResolver'),
-        PackageMeta = dependencies.PackageMeta || require('../PackageMeta'),
-        Project = dependencies.Project || require('../Project'),
-        Plugin = dependencies.Plugin || require('../Plugin'),
-        RendererHelpers = dependencies.RendererHelpers || require('../RendererHelpers'),
-        VersionChecker = dependencies.VersionChecker || require('../VersionChecker'),
-        install = dependencies.install || require('../promise/install'),
-        cloneInstall = dependencies.cloneInstall || require('../promise/cloneInstall'),
-        mkdirp = require('mkdirp'),
-        exec = require('child_process').exec;
-
-    function clonePlugins(localPath, renderer) {
-        renderer.log("Cloning Plugins");
-
-        var project = new Project(
-                path.resolve(localPath, Constants.DefaultProjectManifestPath),
-                path.resolve(localPath, Constants.DefaultProjectFrameworkPath)
-            ),
-            plugins = project.plugins;
-
-
-
-        plugins.forEach(function(plugin, index, array) {
-            createInstallationTask(plugin, localPath, renderer);
-        });
-    }
-
-
-    function createInstallationTask(plugin, localPath, renderer) {
-        return PackageMeta.getKeywords(plugin, { registry: Constants.getRegistry() })
-            .then(function (keywords) {
-                var resolver = new PluginTypeResolver(),
-                    pluginType = resolver.resolve(keywords);
-
-                renderer.log(chalk.cyan(plugin.packageName), 'found.', 'Installing', pluginType.typename, '...');
-                return cloneInstall(plugin, {
-                    localPath: localPath,
-                    directory: path.join('src', pluginType.belongsTo),
-                    registry: Constants.getRegistry()
-                });
-            })
-            .then(function (installed) {
-                if (!installed) throw new Error('The plugin was found but failed to download and install.');
-                renderer.log(chalk.green(plugin.packageName), 'has been installed successfully.');
-            })
-            .done();
-    }
-
-    return {
-        devinstall: function (renderer) {
-
-            var repository = arguments.length >= 3 ? arguments[1] : Constants.FrameworkRepository,
-                localPath = path.resolve(Constants.FrameworkRepositoryName),
-                done = arguments[arguments.length-1] || function () {};
-
-            try {
-                // Are we inside an existing adapt_framework project.
-                var packageJson = require(process.cwd() + '/package.json');
-                if (packageJson.name === 'adapt_framework') {
-                    localPath = process.cwd();
-                }
-            } catch (err) {
-                // Don't worry, we're not inside a framework directory.
-            }
-
-            // we're trying to install a single plugin.
-            if (repository !== Constants.FrameworkRepository) {
-                return createInstallationTask(Plugin.parse(repository), localPath, renderer)
-            }
-
-            function promiseFromChildProcess(child) {
-                return new Promise(function (resolve, reject) {
-                    child.addListener("error", reject);
-                    child.addListener("exit", resolve);
-                });
-            }
-            var child = exec(`git clone ${repository} "${localPath}"`);
-
-            // clone the framework and all the bundled plugins.
-            renderer.log("Cloning adapt_framework");
-            promiseFromChildProcess(child)
-            .then(function(repo){
-                renderer.log("Framework cloned.");
-                process.chdir(localPath);
-                clonePlugins(localPath, renderer, done);
-            });
-        }
-    };
-};
+import { clone as adaptClone } from '../integration/AdaptFramework.js'
+import { install as pluginsInstall } from '../integration/PluginManagement.js'
+import { ADAPT_FRAMEWORK } from '../util/constants.js'
+import path from 'path'
+import Project from '../integration/Project.js'
+import gh from 'parse-github-url'
+
+export default async function devinstall (logger, ...args) {
+  const NAME = gh(ADAPT_FRAMEWORK).repo
+  const isInAdapt = new Project().isAdaptDirectory
+  // In adapt folder or download adapt into adapt_framework folder
+  const cwd = isInAdapt
+    ? process.cwd()
+    : path.resolve(NAME)
+  // strip flags
+  const isClean = args.includes('--clean')
+  const isDryRun = args.includes('--dry-run') || args.includes('--check')
+  const isCompatibleEnabled = args.includes('--compatible')
+  args = args.filter(arg => !String(arg).startsWith('--'))
+  // always perform a clone on the adapt directory
+  if (!isInAdapt || args.includes(NAME)) {
+    await adaptClone({ logger, cwd })
+    args = args.filter(arg => arg !== NAME)
+  }
+  const plugins = args
+  return await pluginsInstall({
+    logger,
+    cwd,
+    isClean,
+    isDryRun,
+    isCompatibleEnabled,
+    dev: true,
+    plugins
+  })
+}

package/lib/commands/help.js

@@ -1,52 +1,31 @@
-var fs = require('fs'),
-    path = require('path'),
-    chalk = require('chalk'),
-    _ = require('lodash');
-
-module.exports = {
-    help: function (renderer) {
-
-        var name = arguments.length >= 3
-                   ? arguments.length > 3
-                     ? Array.prototype.slice.apply(arguments, [1, arguments.length -1]).join(' ')
-                     : arguments[1]
-                   : '';
-        var json;
-
-        if (name) {
-            json = path.resolve(__dirname, '../../json/help-' + name.replace(/\s+/g, '/') + '.json');
-        } else {
-            json = path.resolve(__dirname, '../../json/help.json');
-        }
-
-        fs.exists(json, function(exists) {
-            if (!exists) {
-                renderer.log('adapt ' + chalk.red(name) + '   Unknown command: ' + name);
-            } else {
-
-                var jsonData = require(json);
-
-                renderer.log('\nUsage: \n');
-                _.each(jsonData.usage, function(usage) {
-                    renderer.log('    ' + chalk.cyan('adapt') + ' ' + usage);
-                });
-
-                if(!_.isEmpty(jsonData.commands)) {
-                    renderer.log('\n\nwhere <command> is one of:\n');
-                    _.each(jsonData.commands, function(description, command) {
-                        renderer.log('    ' + command + new Array(23 - command.length).join(' ') + description);
-                    });
-                }
-
-                if(jsonData.description) {
-                    renderer.log('\nDescription:\n\n    ' + jsonData.description);
-                }
-
-                if(!name) {
-                    renderer.log('\nSee \'adapt help <command>\' for more information on a specific command.\n');
-                }
-            }
-        });
-
-    }
-};
+import fs from 'fs-extra'
+import path from 'path'
+import chalk from 'chalk'
+import getDirNameFromImportMeta from '../util/getDirNameFromImportMeta.js'
+const __dirname = getDirNameFromImportMeta(import.meta)
+
+export default function help (logger, ...args) {
+  const name = args.join(' ')
+  const json = name
+    ? path.resolve(__dirname, `../../json/help-${name.replace(/\s+/g, '/')}.json`)
+    : path.resolve(__dirname, '../../json/help.json')
+  if (!fs.existsSync(json)) {
+    logger?.log(`adapt ${chalk.red(name)}   Unknown command: ${name}`)
+    return
+  }
+  const jsonData = fs.readJSONSync(json)
+  logger?.log('\nUsage: \n')
+  jsonData.usage.forEach(usage => logger?.log(`    ${chalk.cyan('adapt')} ${usage}`))
+  if (jsonData.commands && Object.entries(jsonData.commands).length) {
+    logger?.log('\n\nwhere <command> is one of:\n')
+    Object.entries(jsonData.commands).forEach(([command, description]) => {
+      logger?.log(`    ${command}${new Array(23 - command.length).join(' ')}${description}`)
+    })
+  }
+  if (jsonData.description) {
+    logger?.log(`\nDescription:\n\n    ${jsonData.description}`)
+  }
+  if (!name) {
+    logger?.log('\nSee \'adapt help <command>\' for more information on a specific command.\n')
+  }
+}