Unregisters the given plugin from the system based on its name.
        
        :param      plugin | <Plugin>
168759
def unregister(cls, plugin):
        
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})
        try:
            plugs.pop(plugin.name())
        except AttributeError:
            pass
        except ValueError:
            pass
1237022
protected function unregisterPlugin($name)
    {
        $plugins = $this->loadPlugins();

        if (!isset($plugins[$name])) {
            return null;
        }

        $plugin = $plugins[$name];
        unset($plugins[$name]);
        $this->savePlugins($plugins);
        return $plugin;
    }
615037
function(plugin) {
            var ns = plugin, 
                plugins = this._plugins;
    
            if (L.isFunction(plugin)) {
                ns = plugin.NS;
                if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                    ns = null;
                }
            }
    
            if (ns) {
                if (this[ns]) {
                    this[ns].destroy();
                    delete this[ns];
                }
                if (plugins[ns]) {
                    delete plugins[ns];
                }
            }
        }
695800
def unregister_class(alias):
    
    try:
        x = CLASS_CACHE[alias]
    except KeyError:
        raise UnknownClassAlias('Unknown alias %r' % (alias,))

    if not x.anonymous:
        del CLASS_CACHE[x.alias]

    del CLASS_CACHE[x.klass]

    return x
693733
def unregister_module(self, module):
        
        if module not in self._namespaces.values():
            raise NoRegisteredError("Module '{0}' is not registered on loader.".format(module))

        for ns, mod in list(self._namespaces.items()):
            if mod == module:
                self.unregister_namespace(ns)
1126225
def unregister(self, event):
        
        if self.running:
            raise RuntimeError("Can't unregister while running")
        self._handlers.pop(event, None)
1366689
def _unregister_lookup(cls, lookup, lookup_name=None):
        
        if lookup_name is None:
            lookup_name = lookup.lookup_name
        del cls.class_lookups[lookup_name]
165630
def disable_plugin(self, name):
        
        url = self._url('/plugins/{0}/disable', name)
        res = self._post(url)
        self._raise_for_status(res)
        return True
219260
def unregister_listener(self, listener):
        
        listener_id = hashable_identity(listener)
        self._listeners.pop(listener_id, None)
142051
def uninstall(plugin_package, plugins_directory):
    '''
    
    '''
    # Check existing version (if any).
    plugin_path = plugins_directory.joinpath(plugin_package)

    if not plugin_path.isdir():
        raise IOError('Plugin `%s` is not installed in `%s`' %
                      (plugin_package, plugins_directory))
    else:
        try:
            plugin_metadata = yaml.load(plugin_path.joinpath('properties.yml').bytes())
            existing_version = plugin_metadata['version']
        except:
            existing_version = None

    if existing_version is not None:
        # Uninstall existing package.
        print 'Uninstalling `{}=={}`.'.format(plugin_package, existing_version)
    else:
        print 'Uninstalling `{}`.'.format(plugin_package)

    # Uninstall latest release
    # ======================
    plugin_path.rmtree()
    print '  \--> done'
1084346
def remove(self, name_or_klass):
        
        logger.debug('removing extension {}'.format(name_or_klass))
        extension = self.get(name_or_klass)
        extension.on_uninstall()
        self._extensions.pop(extension.name)
        return extension
645966
function uninstall(names, callback) {
  callback = utils.defineCallback(callback);
  if (_.isString(names)) {
    names = [ names ];
  }
  var errs = [ ];
  var numPlugins = 0;
  names.forEach(function(name) {
    rimraf(pluginsDir + "/" + name, cb);
  });

  function cb(err) {
    if (err) {
      errs.push(err);
    }
    if (++numPlugins === names.length) {
      return callback(errs.length === 0 ? null : errs);
    }
  }
}
215840
def unregister(self, observers):
        
        """

        if isinstance(observers, list) or isinstance(observers, tuple):
            for observer in observers:
                try:
                    index = self._observers.index(observer)
                    self._observers.remove(self._observers[index])
                except ValueError:
                    # logging
                    print('{observer} not in list...'.format(observer))

        elif isinstance(observers, base.Observer):
            try:
                index = self._observers.index(observers)
                self._observers.remove(self._observers[index])
            except ValueError:
                # logging
                print('{observer} not in list...'.format(observers))

        else:
            err_message = ('ConfigReader.register support'
                           'ListType, TupleType and {observer} Object.'
                           ''.format(base.Observer.__name__)
                           )

            raise ValueError(err_message)
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
1080097
def unregisterAddonModule(cls, module):
        
        prop = '_{0}__addon_modules'.format(cls.__name__)
        mods = getattr(cls, prop, set())
        try:
            mods.remove(module)
        except KeyError:
            pass
7652
public function disablePlugins($plugin)
    {
        $plugins = func_get_args();
        if (is_array(current($plugins))) {
            $plugins = current($plugins);
        }
        foreach ($plugins as $name) {
            unset($this->plugins[$name]);
        }
        return $this;
    }
564507
def disable_plugin(self, plugin_name):
        """"""
        plugin = self.get_plugin_info(plugin_name)
        ENABLED = os.path.join(plugin["plugin_package_abspath"], "ENABLED")
        DISABLED = os.path.join(plugin["plugin_package_abspath"], "DISABLED")
        if os.path.isfile(ENABLED):
            os.remove(ENABLED)
        self.__touch_file(DISABLED)