adapt-cli 2.1.13 → 3.0.6

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');
-
-module.exports = function (properties) {
-    var fs = require('fs'),
-        path = require('path');
-
-    properties.component = {
-        name: slug(properties.localDir),
-        files: []
-    };
-    properties.relative = function (file) {
-        return path.join(this.localDir, file);
-    };
-
-    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'));
-
-    return createComponent(properties)
-            .then(function (properties) {
-                properties.renderer.log('\n' + chalk.green(properties.localDir), 'has been created.\n');
-
-                if(addComponentToCurrentCourse()) {
-                    properties.renderer.log(chalk.grey('To use this component in your course, use the registered name:') + chalk.yellow(properties.component.name));
-                }
-            });
-};
-
-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);
-}
-
-function renameFiles(properties) {
-   var fs = require('fs'),
-       path = require('path');
-
-   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;
-}
-
-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;
-    });
-}
+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'
+
+export default async function component ({
+  name,
+  repository = ADAPT_COMPONENT,
+  cwd,
+  branch,
+  logger
+}) {
+  name = slug(name, { maintainCase: true })
+
+  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)
+  }
+
+  await downloader({
+    branch,
+    repository,
+    cwd: pluginDir,
+    logger
+  })
+
+  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)))
+    })
+  })
+
+  const filesRenamed = files.map(from => {
+    const to = from.replace(/((contrib-)?componentName)/g, name)
+    fs.renameSync(from, to)
+    return to
+  })
+
+  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)
+  }))
+
+  logger?.log('\n' + chalk.green(pluginDir), 'has been created.\n')
+
+  if (fs.existsSync('./adapt.json')) {
+    logger?.log(chalk.grey('To use this component in your course, use the registered name:') + chalk.yellow(name))
+  }
+}

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
+  })
+}

package/lib/commands/create.js

@@ -1,90 +1,94 @@
-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');
-
-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
-        }
-    ];
-
-    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
-            }
-        ];
-
-        inquirer.prompt(propertySchema).then(propertySchemaResults => {
-            if(!propertySchemaResults.ready) deferred.reject(new Error('Aborted. Nothing has been created.'));
-
-            var properties = _.extend({},
-                typeSchemaResults,
-                propertySchemaResults,
-                {
-                    renderer: renderer
-                });
-            deferred.resolve(properties);
-        }).catch(err => deferred.reject(err));
-    }).catch(err => deferred.reject(err));
-    return deferred.promise;
-}
+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'
+
+const subTasks = {
+  component,
+  question,
+  course
+}
+
+/**
+ * TODO: Change component name to camel case
+ */
+export const DEFAULT_TYPE_NAME = {
+  course: 'my-adapt-course',
+  component: 'myAdaptComponent',
+  question: 'myAdaptQuestion'
+}
+
+export default async function create (logger, type = 'course', name, branch, bypassPrompts) {
+  let options = {
+    type,
+    name,
+    branch
+  }
+
+  if (!bypassPrompts) {
+    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
+  }
+}
+
+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
+  })
+}