Uninstall via re-setting alias of Bower
351663
public static function unsetAlias()
    {
        $file = file_get_contents(self::$aliasFilePath);

        $aliasString = str_replace(
            "'".self::$bowerVendor."'",  
            "'".self::$sourceBower."'",
            self::$aliasBowerString
            );

        $file = str_replace(
            $aliasString, 
            self::$aliasBowerString, 
            $file
            );

        $result = file_put_contents(self::$aliasFilePath, $file);

        if ($result) {
            
            echo "Uninstall alias @bower done\n";
        }
    }
69456
def do_uninstall(ctx, verbose, fake):
    """"""
    aliases = cli.list_commands(ctx)
    # Add deprecated aliases
    aliases.extend(['graft', 'harvest', 'sprout', 'resync', 'settings', 'install', 'uninstall'])
    for alias in aliases:
        system_command = 'git config --global --unset-all alias.{0}'.format(alias)
        verbose_echo(system_command, verbose, fake)
        if not fake:
            os.system(system_command)
    if not fake:
        click.echo('\nThe following git aliases are uninstalled:\n')
        output_aliases(aliases)
1061898
def uninstall_plugin(pkgpath, force):
    
    pkgname = os.path.basename(pkgpath)
    if os.path.exists(pkgpath):
        if not force:
            click.confirm("[?] Are you sure you want to delete `{}` from honeycomb?".format(pkgname),
                          abort=True)
        try:
            shutil.rmtree(pkgpath)
            logger.debug("successfully uninstalled {}".format(pkgname))
            click.secho("[*] Uninstalled {}".format(pkgname))
        except OSError as exc:
            logger.exception(str(exc))
    else:
        click.secho("[-] doh! I cannot seem to find `{}`, are you sure it's installed?".format(pkgname))
1024462
def make_uninstall(parser):
    
    parser.add_argument(
        'host',
        metavar='HOST',
        nargs='+',
        help='hosts to uninstall Ceph from',
        )
    parser.set_defaults(
        func=uninstall,
        )
116506
def uninstall(self):
        """"""
        if self.is_installed():
            installed = self.installed_dir()
            if installed.is_symlink():
                installed.unlink()
            else:
                shutil.rmtree(str(installed))
657824
def uninstall(python=PYTHON):
    """"""
    site_packages = local(
        "{python} -c 'from distutils.sysconfig import "
        "get_python_lib; print(get_python_lib())'".format(python=python),
        capture=True,
    )
    with lcd(site_packages):
        local("sudo rm mpfr.so")
        local("sudo rm -fr bigfloat")
        local("sudo rm bigfloat*.egg-info")
443804
def _CleanupInstall(self):
    """"""
    if os.path.exists(self.install_path):
      shutil.rmtree(self.install_path)
      if os.path.exists(self.install_path):
        raise RuntimeError("Install path still exists: %s" % self.install_path)

    # Deliberately don't check return code, since service may not be installed.
    subprocess.call(["sc", "stop", self.service_name])
749861
function restoreAlias(cmd){
  var cmds;
  if(aliases[cmd]){
    cmds = aliases[cmd].trim().split(/\s+/);
  }
  return cmds;
}
628036
def uninstall(**kwargs):
    """"""
    force = kwargs.get('force')
    restore_legacy = kwargs.get('restore_legacy')

    colorama.init(strip=kwargs.get('no_color'))

    git_dir = current_git_dir()

    if git_dir is None:
        output(NOT_GIT_REPO_MSG)
        exit(1)

    hook_path = os.path.join(git_dir, 'hooks', 'pre-commit')

    if not os.path.isfile(hook_path):
        output(NO_HOOK_INSTALLED_MSG)
        exit(0)

    hook_hash = identify_hook(hook_path)

    if hook_hash:
        if not force:
            if not click.confirm(CONFIRM_UNINSTALL_HOOK_MSG, default=False):
                output(UNINSTALL_ABORTED_MSG)
                exit(1)
    else:
        output(CURRENT_HOOK_NOT_THERAPIST_MSG)
        exit(1)

    legacy_hook_path = os.path.join(git_dir, 'hooks', 'pre-commit.legacy')

    if os.path.isfile(legacy_hook_path):
        if not force and not restore_legacy:
            output(LEGACY_HOOK_EXISTS_MSG)
            restore_legacy = click.confirm(CONFIRM_RESTORE_LEGACY_HOOK_MSG, default=True)
        if restore_legacy:
            output(COPYING_LEGACY_HOOK_MSG, end='')
            shutil.copy2(legacy_hook_path, hook_path)
            os.remove(legacy_hook_path)
            output(DONE_COPYING_LEGACY_HOOK_MSG)
            exit(0)
        else:
            if force or click.confirm('Would you like to remove the legacy hook?', default=False):
                output(REMOVING_LEGACY_HOOK_MSG, end='')
                os.remove(legacy_hook_path)
                output(DONE_REMOVING_LEGACY_HOOK_MSG)

    output(UNINSTALLING_HOOK_MSG, end='')
    os.remove(hook_path)
    output(DONE_UNINSTALLING_HOOK_MSG)
801189
def uninstall(hook_type='pre-commit'):
    """"""
    hook_path, legacy_path = _hook_paths(hook_type)

    # If our file doesn't exist or it isn't ours, gtfo.
    if not os.path.exists(hook_path) or not is_our_script(hook_path):
        return 0

    os.remove(hook_path)
    output.write_line('{} uninstalled'.format(hook_type))

    if os.path.exists(legacy_path):
        os.rename(legacy_path, hook_path)
        output.write_line('Restored previous hooks to {}'.format(hook_path))

    return 0
1112737
def uninstall
      plugin = Heroku::Plugin.new(shift_argument)
      validate_arguments!
      if Heroku::Plugin.list.include? plugin.name
        action("Uninstalling #{plugin.name}") do
          plugin.uninstall
        end
      else
        Heroku::JSPlugin.uninstall(plugin.name)
      end
    end
162890
protected function uninstall()
    {
        $uninstallScripts = array();
        if (!empty($this->installedBundles)) {
            foreach ($this->installedBundles as $autoloader) {
                $bundleName = $autoloader->getBundleName();
                $uninstallScripts[$bundleName] = $autoloader->getActionManagerClass();
                $this->filesystem->remove($this->autoloadersPath . '/' . $bundleName . '.json');
                $this->filesystem->remove($this->configPath);
                $this->filesystem->remove($this->routingPath);
            }
        }

        $this->requireCachedClasses();
        $uninstallerScript = $this->scriptFactory->createScript('PreBootUninstaller');
        $uninstallerScript->executeActions($uninstallScripts);
    }
125164
def remove(self, name=None, prefix=None, pkgs=None, all_=False):
        
        logger.debug(str((prefix, pkgs)))

        cmd_list = ['remove', '--json', '--yes']

        if not pkgs and not all_:
            raise TypeError("Must specify at least one package to remove, or "
                            "all=True.")

        if name:
            cmd_list.extend(['--name', name])
        elif prefix:
            cmd_list.extend(['--prefix', prefix])
        else:
            raise TypeError('must specify either an environment name or a '
                            'path for package removal')

        if all_:
            cmd_list.extend(['--all'])
        else:
            cmd_list.extend(pkgs)

        return self._call_and_parse(cmd_list)
84857
function uninstalledVer(name, ver, dir) {
        var _child$spawnSync4 = _child_process2['default'].spawnSync(npmCommand, ['uninstall', ver.length === 0 ? name : name + '@' + ver], { cwd: dir });

        var error = _child$spawnSync4.error;

        if (error) throw error;
    }
329001
def delete_alias(self, addressid, data):
        """"""
        return self.api_call(
            ENDPOINTS['aliases']['delete'],
            dict(addressid=addressid),
            body=data)
543062
public static void uninstall() {
        synchronized (log()) {
            if (cInstalled) {
                cInstalled = false;
                System.setOut(cOriginalOut);
                System.setErr(cOriginalErr);
                cOriginalOut = null;
                cOriginalErr = null;
                cSystemOut = null;
                cSystemErr = null;
            }
        }
    }
1053263
public function uninstall()
    {
        // "Disable" (delete) events, regardless the confirmation answer.
        $this->uninstallEvents();
        $this->registry->response->redirect($this->registry->getLink($this->getLocation() . '/confirmUninstall'));
    }