adapt-cli 2.1.11 → 3.0.0

package/lib/integration/PluginManagement/update.js

@@ -0,0 +1,224 @@
+import chalk from 'chalk'
+import { eachOfSeries } from 'async'
+import path from 'path'
+import Project from '../Project.js'
+import { createPromptTask } from '../../util/createPromptTask.js'
+import { errorPrinter, packageNamePrinter, versionPrinter, existingVersionPrinter } from './print.js'
+import { eachOfLimitProgress, eachOfSeriesProgress } from '../../util/promises.js'
+/** @typedef {import("../Target.js").default} Target */
+
+export default async function update ({
+  plugins,
+  // whether to summarise installed plugins without modifying anything
+  isDryRun = false,
+  isInteractive = true,
+  cwd = process.cwd(),
+  logger = null
+}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const project = new Project({ cwd, logger })
+  project.tryThrowInvalidPath()
+
+  logger?.log(chalk.cyan('update adapt dependencies...'))
+
+  const targets = await getUpdateTargets({ logger, project, plugins, isDryRun, isInteractive })
+  if (!targets?.length) return targets
+
+  await loadPluginData({ logger, project, targets })
+  await conflictResolution({ logger, targets, isInteractive })
+  if (isDryRun) {
+    await summariseDryRun({ logger, targets })
+    return targets
+  }
+  const updateTargetsToBeUpdated = targets.filter(target => target.isToBeInstalled)
+  if (updateTargetsToBeUpdated.length) {
+    await eachOfSeriesProgress(
+      updateTargetsToBeUpdated,
+      target => target.update(),
+      percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Updating plugins ${percentage}% complete`)
+    )
+    logger?.log(`${chalk.bold.cyan('<info>')} Updating plugins 100% complete`)
+  }
+  await summariseUpdates({ logger, targets })
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[string]} options.plugins
+ */
+async function getUpdateTargets ({ project, plugins, isDryRun, isInteractive }) {
+  if (typeof plugins === 'string') plugins = [plugins]
+  if (!plugins) plugins = []
+  const allowedTypes = ['all', 'components', 'extensions', 'menu', 'theme']
+  const selectedTypes = [...new Set(plugins.filter(type => allowedTypes.includes(type)))]
+  const isEmpty = (!plugins.length)
+  const isAll = (isDryRun || isEmpty || selectedTypes.includes('all'))
+  const pluginNames = plugins
+    // remove types
+    .filter(arg => !allowedTypes.includes(arg))
+    // split name/version
+    .map(arg => {
+      const [name, version = '*'] = arg.split(/[#@]/)
+      return [name, version]
+    })
+    // make sure last applies
+    .reverse()
+
+  /** @type {[Target]} */
+  let targets = await project.getUpdateTargets()
+  for (const target of targets) {
+    await target.fetchProjectInfo()
+  }
+  if (!isDryRun && isEmpty && isInteractive) {
+    const shouldContinue = await createPromptTask({
+      message: chalk.reset('This command will attempt to update all installed plugins. Do you wish to continue?'),
+      type: 'confirm'
+    })
+    if (!shouldContinue) return
+  }
+  if (!isAll) {
+    const filtered = {}
+    for (const target of targets) {
+      const typeFolder = await target.getTypeFolder()
+      if (!typeFolder) continue
+      const lastSpecifiedPluginName = pluginNames.find(([name]) => target.isNameMatch(name))
+      const isPluginNameIncluded = Boolean(lastSpecifiedPluginName)
+      const isTypeIncluded = selectedTypes.includes(typeFolder)
+      if (!isPluginNameIncluded && !isTypeIncluded) continue
+      // Resolve duplicates
+      filtered[target.packageName] = target
+      // Set requested version from name
+      target.requestedVersion = lastSpecifiedPluginName[1] || '*'
+    }
+    targets = Object.values(filtered)
+  }
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ */
+async function loadPluginData ({ logger, project, targets }) {
+  const frameworkVersion = project.version
+  await eachOfLimitProgress(
+    targets,
+    target => target.fetchSourceInfo(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Getting plugin info ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Getting plugin info 100% complete`)
+  await eachOfLimitProgress(
+    targets,
+    target => target.findCompatibleVersion(frameworkVersion),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Finding compatible source versions ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Finding compatible source versions 100% complete`)
+  await eachOfLimitProgress(
+    targets,
+    target => target.markUpdateable(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Marking updateable ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Marking updateable 100% complete`)
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+async function conflictResolution ({ logger, targets, isInteractive }) {
+  /** @param {Target} target */
+  async function checkVersion (target) {
+    const canApplyRequested = target.hasValidRequestVersion &&
+      (target.hasFrameworkCompatibleVersion
+        ? (target.latestCompatibleSourceVersion !== target.matchedVersion)
+        : (target.latestSourceVersion !== target.matchedVersion))
+    if (!isInteractive) {
+      if (target.canApplyRequested) return target.markRequestedForInstallation()
+      return target.markSkipped()
+    }
+    const choices = [
+      canApplyRequested && { name: `requested version [${target.matchedVersion}]`, value: 'r' },
+      target.hasFrameworkCompatibleVersion
+        ? { name: `latest compatible version [${target.latestCompatibleSourceVersion}]`, value: 'l' }
+        : { name: `latest version [${target.latestSourceVersion}]`, value: 'l' },
+      { name: 'skip', value: 's' }
+    ].filter(Boolean)
+    const result = await createPromptTask({ message: chalk.reset(target.packageName), choices, type: 'list', default: 's' })
+    const installRequested = (result === 'r')
+    const installLatest = result === 'l'
+    const skipped = result === 's'
+    if (installRequested) target.markRequestedForInstallation()
+    if (installLatest && target.hasFrameworkCompatibleVersion) target.markLatestCompatibleForInstallation()
+    if (installLatest && !target.hasFrameworkCompatibleVersion) target.markLatestForInstallation()
+    if (skipped) target.markSkipped()
+  }
+  function add (list, header, prompt) {
+    if (!list.length) return
+    return {
+      header: chalk.bold.cyan('<info> ') + header,
+      list,
+      prompt
+    }
+  }
+  const preFilteredPlugins = targets.filter(target => !target.isLocalSource)
+  const allQuestions = [
+    add(preFilteredPlugins.filter(target => !target.hasFrameworkCompatibleVersion), 'There is no compatible version of the following plugins:', checkVersion),
+    add(preFilteredPlugins.filter(target => target.hasFrameworkCompatibleVersion && !target.hasValidRequestVersion), 'The version requested is invalid, there are newer compatible versions of the following plugins:', checkVersion),
+    add(preFilteredPlugins.filter(target => target.hasFrameworkCompatibleVersion && target.hasValidRequestVersion && !target.isApplyLatestCompatibleVersion), 'There are newer compatible versions of the following plugins:', checkVersion)
+  ].filter(Boolean)
+  if (allQuestions.length === 0) return
+  for (const question of allQuestions) {
+    logger?.log(question.header)
+    await eachOfSeries(question.list, question.prompt)
+  }
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+function summariseDryRun ({ logger, targets }) {
+  const preFilteredPlugins = targets.filter(target => !target.isLocalSource)
+  const localSources = targets.filter(target => target.isLocalSource)
+  const toBeInstalled = preFilteredPlugins.filter(target => target.isToBeUpdated)
+  const toBeSkipped = preFilteredPlugins.filter(target => !target.isToBeUpdated || target.isSkipped)
+  const missing = preFilteredPlugins.filter(target => target.isMissing)
+  summarise(logger, localSources, packageNamePrinter, 'The following plugins were installed from a local source and cannot be updated:')
+  summarise(logger, toBeSkipped, packageNamePrinter, 'The following plugins will be skipped:')
+  summarise(logger, missing, packageNamePrinter, 'There was a problem locating the following plugins:')
+  summarise(logger, toBeInstalled, versionPrinter, 'The following plugins will be updated:')
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+function summariseUpdates ({ logger, targets }) {
+  const preFilteredPlugins = targets.filter(target => !target.isLocalSource)
+  const localSources = targets.filter(target => target.isLocalSource)
+  const installSucceeded = preFilteredPlugins.filter(target => target.isUpdateSuccessful)
+  const installSkipped = preFilteredPlugins.filter(target => target.isSkipped)
+  const noUpdateAvailable = preFilteredPlugins.filter(target => !target.isToBeUpdated && !target.isSkipped)
+  const installErrored = preFilteredPlugins.filter(target => target.isUpdateFailure)
+  const missing = preFilteredPlugins.filter(target => target.isMissing)
+  const noneInstalled = (installSucceeded.length === 0)
+  const allInstalledSuccessfully = (installErrored.length === 0 && missing.length === 0)
+  const someInstalledSuccessfully = (!noneInstalled && !allInstalledSuccessfully)
+  summarise(logger, localSources, existingVersionPrinter, 'The following plugins were installed from a local source and cannot be updated:')
+  summarise(logger, installSkipped, existingVersionPrinter, 'The following plugins were skipped:')
+  summarise(logger, noUpdateAvailable, existingVersionPrinter, 'The following plugins had no update available:')
+  summarise(logger, missing, packageNamePrinter, 'There was a problem locating the following plugins:')
+  summarise(logger, installErrored, errorPrinter, 'The following plugins could not be updated:')
+  if (noneInstalled) logger?.log(chalk.cyanBright('None of the requested plugins could be updated'))
+  else if (allInstalledSuccessfully) summarise(logger, installSucceeded, existingVersionPrinter, 'All requested plugins were successfully updated. Summary of installation:')
+  else if (someInstalledSuccessfully) summarise(logger, installSucceeded, existingVersionPrinter, 'The following plugins were successfully updated:')
+}
+
+function summarise (logger, list, iterator, header) {
+  if (!list || !iterator || list.length === 0) return
+  logger?.log(chalk.cyanBright(header))
+  list.forEach(item => iterator(item, logger))
+}

package/lib/integration/PluginManagement.js

@@ -0,0 +1,21 @@
+import authenticate from './PluginManagement/autenticate.js'
+import install from './PluginManagement/install.js'
+import register from './PluginManagement/register.js'
+import rename from './PluginManagement/rename.js'
+import schemas from './PluginManagement/schemas.js'
+import search from './PluginManagement/search.js'
+import uninstall from './PluginManagement/uninstall.js'
+import unregister from './PluginManagement/unregister.js'
+import update from './PluginManagement/update.js'
+
+export {
+  authenticate,
+  install,
+  register,
+  rename,
+  schemas,
+  search,
+  uninstall,
+  unregister,
+  update
+}

package/lib/integration/Project.js

@@ -0,0 +1,146 @@
+import fs from 'fs-extra'
+import path from 'path'
+import globs from 'globs'
+import { readValidateJSON, readValidateJSONSync } from '../util/JSONReadValidate.js'
+import Plugin from './Plugin.js'
+import Target from './Target.js'
+export const MANIFEST_FILENAME = 'adapt.json'
+export const FRAMEWORK_FILENAME = 'package.json'
+
+/**
+ * A representation of the target Adapt Framework project
+ */
+export default class Project {
+  constructor ({
+    cwd = process.cwd(),
+    logger
+  } = {}) {
+    this.logger = logger
+    this.cwd = cwd
+    this.manifestFilePath = path.resolve(this.cwd, MANIFEST_FILENAME)
+    this.frameworkPackagePath = path.resolve(this.cwd, FRAMEWORK_FILENAME)
+  }
+
+  /** @returns {boolean} */
+  get isAdaptDirectory () {
+    try {
+      // are we inside an existing adapt_framework project.
+      const packageJSON = fs.readJSONSync(this.cwd + '/package.json')
+      return (packageJSON.name === 'adapt_framework')
+    } catch (err) {
+      // don't worry, we're not inside a framework directory.
+    }
+    return false
+  }
+
+  /** @returns {boolean} */
+  get containsManifestFile () {
+    if (!this.isAdaptDirectory) return false
+    return fs.existsSync(this.manifestFilePath)
+  }
+
+  /** @returns {string} */
+  get version () {
+    try {
+      return readValidateJSONSync(this.frameworkPackagePath).version
+    } catch (ex) {
+      return null
+    }
+  }
+
+  tryThrowInvalidPath () {
+    if (this.containsManifestFile) return
+    this.logger?.error('Fatal error: please run above commands in adapt course directory.')
+    throw new Error('Fatal error: please run above commands in adapt course directory.')
+  }
+
+  /** @returns {[Target]} */
+  async getInstallTargets () {
+    return Object.entries(await this.getManifestDependencies()).map(([name, requestedVersion]) => new Target({ name, requestedVersion, project: this, logger: this.logger }))
+  }
+
+  /** @returns {[string]} */
+  async getManifestDependencies () {
+    const manifest = await readValidateJSON(this.manifestFilePath)
+    return manifest.dependencies
+  }
+
+  /** @returns {[Plugin]} */
+  async getInstalledPlugins () {
+    return Object.entries(await this.getInstalledDependencies()).map(([name]) => new Plugin({ name, project: this, logger: this.logger }))
+  }
+
+  /** @returns {[Target]} */
+  async getUninstallTargets () {
+    return Object.entries(await this.getInstalledDependencies()).map(([name]) => new Target({ name, project: this, logger: this.logger }))
+  }
+
+  /** @returns {[Target]} */
+  async getUpdateTargets () {
+    return Object.entries(await this.getInstalledDependencies()).map(([name]) => new Target({ name, project: this, logger: this.logger }))
+  }
+
+  async getInstalledDependencies () {
+    const getDependencyBowerJSONs = async () => {
+      const glob = `${this.cwd.replace(/\\/g, '/')}/src/**/bower.json`
+      const bowerJSONPaths = await new Promise((resolve, reject) => {
+        globs(glob, (err, matches) => {
+          if (err) return reject(err)
+          resolve(matches)
+        })
+      })
+      const bowerJSONs = []
+      for (const bowerJSONPath of bowerJSONPaths) {
+        try {
+          bowerJSONs.push(await fs.readJSON(bowerJSONPath))
+        } catch (err) {}
+      }
+      return bowerJSONs
+    }
+    const dependencies = (await getDependencyBowerJSONs())
+      .filter(bowerJSON => bowerJSON?.name && bowerJSON?.version)
+      .reduce((dependencies, bowerJSON) => {
+        dependencies[bowerJSON.name] = bowerJSON.version
+        return dependencies
+      }, {})
+    return dependencies
+  }
+
+  async getSchemaPaths () {
+    const glob = `${this.cwd.replace(/\\/g, '/')}/src/**/*.schema.json`
+    const bowerJSONPaths = await new Promise((resolve, reject) => {
+      globs(glob, (err, matches) => {
+        if (err) return reject(err)
+        resolve(matches)
+      })
+    })
+    return bowerJSONPaths
+  }
+
+  /**
+   * @param {Plugin} plugin
+   */
+  add (plugin) {
+    if (typeof Plugin !== 'object' && !(plugin instanceof Plugin)) {
+      plugin = new Plugin({ name: plugin })
+    }
+    let manifest = { version: '0.0.0', dependencies: {} }
+    if (this.containsManifestFile) {
+      manifest = readValidateJSONSync(this.manifestFilePath)
+    }
+    manifest.dependencies[plugin.packageName] = plugin.sourcePath || plugin.requestedVersion || plugin.version
+    fs.writeJSONSync(this.manifestFilePath, manifest, { spaces: 2, replacer: null })
+  }
+
+  /**
+   * @param {Plugin} plugin
+   */
+  remove (plugin) {
+    if (typeof Plugin !== 'object' && !(plugin instanceof Plugin)) {
+      plugin = new Plugin({ name: plugin })
+    }
+    const manifest = readValidateJSONSync(this.manifestFilePath)
+    delete manifest.dependencies[plugin.packageName]
+    fs.writeJSONSync(this.manifestFilePath, manifest, { spaces: 2, replacer: null })
+  }
+}

package/lib/integration/Target.js

@@ -0,0 +1,296 @@
+import chalk from 'chalk'
+import bower from 'bower'
+import { exec } from 'child_process'
+import semver from 'semver'
+import fs from 'fs-extra'
+import path from 'path'
+import { ADAPT_ALLOW_PRERELEASE } from '../util/constants.js'
+import Plugin from './Plugin.js'
+/** @typedef {import("./Project.js").default} Project */
+const semverOptions = { includePrerelease: ADAPT_ALLOW_PRERELEASE }
+
+export default class Target extends Plugin {
+  /**
+   * @param {Object} options
+   * @param {string} options.name
+   * @param {string} options.requestedVersion
+   * @param {boolean} options.isContrib
+   * @param {boolean} options.isCompatibleEnabled whether to target the latest compatible version for all plugin installations (overrides requestedVersion)
+   * @param {Project} options.project
+   * @param {string} options.cwd
+   * @param {Object} options.logger
+   */
+  constructor ({
+    name,
+    requestedVersion = '*',
+    isContrib = false,
+    isCompatibleEnabled = false,
+    project,
+    cwd = (project?.cwd ?? process.cwd()),
+    logger
+  } = {}) {
+    super({
+      name,
+      requestedVersion,
+      isContrib,
+      isCompatibleEnabled,
+      project,
+      cwd,
+      logger
+    })
+    // The version to be installed
+    this.versionToApply = null
+    // Keep the project version preupdate
+    this.preUpdateProjectVersion = null
+    // Was explicitly skipped by the user
+    this._isSkipped = null
+    // Marks that this target was uninstalled, true, false and null
+    this._wasUninstalled = null
+  }
+
+  /**
+   * Was explicitly skipped by the user
+   * @returns {boolean}
+   */
+  get isSkipped () {
+    return Boolean(this._isSkipped)
+  }
+
+  get isNoApply () {
+    return (this.isPresent && this.versionToApply === null)
+  }
+
+  /** @returns {boolean} */
+  get hasProposedVersion () {
+    return (this.matchedVersion !== null)
+  }
+
+  /** @returns {boolean} */
+  get isToBeInstalled () {
+    return (this.versionToApply !== null && !this._isSkipped)
+  }
+
+  /** @returns {boolean} */
+  get isInstallSuccessful () {
+    return (this.isToBeInstalled && this.isUpToDate)
+  }
+
+  /** @returns {boolean} */
+  get isInstallFailure () {
+    return (this.isToBeInstalled && !this.isUpToDate)
+  }
+
+  /** @returns {boolean} */
+  get isToBeUninstalled () {
+    return (this.versionToApply !== null && !this._isSkipped)
+  }
+
+  /** @returns {boolean} */
+  get isUninstallSuccessful () {
+    return (this.isToBeUninstalled && this._wasUninstalled)
+  }
+
+  /** @returns {boolean} */
+  get isUninstallFailure () {
+    return (this.isToBeUninstalled && !this._wasUninstalled)
+  }
+
+  /** @returns {boolean} */
+  get isToBeUpdated () {
+    return (this.versionToApply !== null && !this._isSkipped)
+  }
+
+  /** @returns {boolean} */
+  get isUpdateSuccessful () {
+    return (this.isToBeUpdated && this.isUpToDate)
+  }
+
+  /** @returns {boolean} */
+  get isUpdateFailure () {
+    return (this.isToBeUpdated && !this.isUpToDate)
+  }
+
+  /** @returns {boolean} */
+  get isApplyLatestCompatibleVersion () {
+    return (this.hasFrameworkCompatibleVersion &&
+      semver.satisfies(this.latestCompatibleSourceVersion, this.matchedVersion, semverOptions))
+  }
+
+  markSkipped () {
+    this._isSkipped = true
+  }
+
+  markInstallable () {
+    if (!this.isApplyLatestCompatibleVersion && !(this.isLocalSource && this.latestSourceVersion)) return
+    this.versionToApply = this.matchedVersion
+  }
+
+  markUpdateable () {
+    if (!this.isPresent || this.isSkipped || !this.canBeUpdated) return
+    if (this.projectVersion === this.matchedVersion) return
+    this.versionToApply = this.matchedVersion
+  }
+
+  markMasterForInstallation () {
+    this.versionToApply = '*'
+  }
+
+  markRequestedForInstallation () {
+    this.matchedVersion = this.matchedVersion ?? semver.maxSatisfying(this.sourceVersions, this.requestedVersion, semverOptions)
+    if (this.projectVersion === this.matchedVersion) return
+    this.versionToApply = this.matchedVersion
+  }
+
+  markLatestCompatibleForInstallation () {
+    if (this.projectVersion === this.latestCompatibleSourceVersion) return
+    this.versionToApply = this.latestCompatibleSourceVersion
+  }
+
+  markLatestForInstallation () {
+    if (this.projectVersion === this.latestSourceVersion) return
+    this.versionToApply = this.latestSourceVersion
+  }
+
+  markUninstallable () {
+    if (!this.isPresent) return
+    this.versionToApply = this.projectVersion
+  }
+
+  async install ({ clone = false } = {}) {
+    const logger = this.logger
+    const pluginTypeFolder = await this.getTypeFolder()
+    if (this.isLocalSource) {
+      await fs.ensureDir(path.resolve(this.cwd, 'src', pluginTypeFolder))
+      const pluginPath = path.resolve(this.cwd, 'src', pluginTypeFolder, this.name)
+      await fs.rm(pluginPath, { recursive: true, force: true })
+      await fs.copy(this.sourcePath, pluginPath, { recursive: true })
+      const bowerJSON = await fs.readJSON(path.join(pluginPath, 'bower.json'))
+      bowerJSON._source = this.sourcePath
+      bowerJSON._wasInstalledFromPath = true
+      await fs.writeJSON(path.join(pluginPath, '.bower.json'), bowerJSON, { spaces: 2, replacer: null })
+      this._projectInfo = null
+      await this.fetchProjectInfo()
+      return
+    }
+    if (clone) {
+      // clone install
+      const repoDetails = await this.getRepositoryUrl()
+      if (!repoDetails) throw new Error('Error: Plugin repository url could not be found.')
+      await fs.ensureDir(path.resolve(this.cwd, 'src', pluginTypeFolder))
+      const pluginPath = path.resolve(this.cwd, 'src', pluginTypeFolder, this.name)
+      await fs.rm(pluginPath, { recursive: true, force: true })
+      const url = repoDetails.url.replace(/^git:\/\//, 'https://')
+      try {
+        const exitCode = await new Promise((resolve, reject) => {
+          try {
+            exec(`git clone ${url} "${pluginPath}"`, resolve)
+          } catch (err) {
+            reject(err)
+          }
+        })
+        if (exitCode) throw new Error(`The plugin was found but failed to download and install. Exit code ${exitCode}`)
+      } catch (error) {
+        throw new Error(`The plugin was found but failed to download and install. Error ${error}`)
+      }
+      if (this.versionToApply !== '*') {
+        try {
+          await new Promise(resolve => exec(`git -C "${pluginPath}" checkout v${this.versionToApply}`, resolve))
+          logger?.log(chalk.green(this.packageName), `is on branch "${this.versionToApply}".`)
+        } catch (err) {
+          throw new Error(chalk.yellow(this.packageName), `could not checkout branch "${this.versionToApply}".`)
+        }
+      }
+      this._projectInfo = null
+      await this.fetchProjectInfo()
+      return
+    }
+    // bower install
+    const outputPath = path.join(this.cwd, 'src', pluginTypeFolder)
+    const pluginPath = path.join(outputPath, this.name)
+    try {
+      await fs.rm(pluginPath, { recursive: true, force: true })
+    } catch (err) {
+      throw new Error(`There was a problem writing to the target directory ${pluginPath}`)
+    }
+    await new Promise((resolve, reject) => {
+      const pluginNameVersion = `${this.packageName}@${this.versionToApply}`
+      bower.commands.install([pluginNameVersion], null, {
+        directory: outputPath,
+        cwd: this.cwd,
+        registry: this.BOWER_REGISTRY_CONFIG
+      })
+        .on('end', resolve)
+        .on('error', err => {
+          err = new Error(`Bower reported ${err}`)
+          this._error = err
+          reject(err)
+        })
+    })
+    this._projectInfo = null
+    await this.fetchProjectInfo()
+  }
+
+  async update () {
+    if (!this.isToBeUpdated) throw new Error()
+    const typeFolder = await this.getTypeFolder()
+    const outputPath = path.join(this.cwd, 'src', typeFolder)
+    const pluginPath = path.join(outputPath, this.name)
+    try {
+      await fs.rm(pluginPath, { recursive: true, force: true })
+    } catch (err) {
+      throw new Error(`There was a problem writing to the target directory ${pluginPath}`)
+    }
+    await new Promise((resolve, reject) => {
+      const pluginNameVersion = `${this.packageName}@${this.matchedVersion}`
+      bower.commands.install([pluginNameVersion], null, {
+        directory: outputPath,
+        cwd: this.cwd,
+        registry: this.BOWER_REGISTRY_CONFIG
+      })
+        .on('end', resolve)
+        .on('error', err => {
+          err = new Error(`Bower reported ${err}`)
+          this._error = err
+          reject(err)
+        })
+    })
+    this.preUpdateProjectVersion = this.projectVersion
+    this._projectInfo = null
+    await this.fetchProjectInfo()
+  }
+
+  async uninstall () {
+    try {
+      if (!this.isToBeUninstalled) throw new Error()
+      await fs.rm(this.projectPath, { recursive: true, force: true })
+      this._wasUninstalled = true
+    } catch (err) {
+      this._wasUninstalled = false
+      throw new Error(`There was a problem writing to the target directory ${this.projectPath}`)
+    }
+  }
+
+  isNameMatch (name) {
+    const tester = new RegExp(`${name}$`, 'i')
+    return tester.test(this.packageName)
+  }
+
+  /**
+   * Read plugin data from pluginPath
+   * @param {Object} options
+   * @param {string} options.pluginPath Path to source directory
+   * @param {string} [options.projectPath=process.cwd()] Optional path to potential installation project
+   * @returns {Target}
+   */
+  static async fromPath ({
+    pluginPath,
+    projectPath = process.cwd()
+  }) {
+    const target = new Target({
+      name: pluginPath,
+      cwd: projectPath
+    })
+    await target.fetchLocalSourceInfo()
+    return target
+  }
+}