Remove ACL for the specified collection.

    If none is specified - removes ACL for all collections.
177073
def access_storage_rm(name, yes, **kwargs):
    
    if name is None:
        if not yes:
            click.confirm('Are you sure you want to remove all ACL?', abort=True)

    ctx = Context(**kwargs)
    ctx.execute_action('access:storage:rm', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
1075498
def delete(filepath):
    
    # Some files have ACLs, let's remove them recursively
    remove_acl(filepath)

    # Some files have immutable attributes, let's remove them recursively
    remove_immutable_attribute(filepath)

    # Finally remove the files and folders
    if os.path.isfile(filepath) or os.path.islink(filepath):
        os.remove(filepath)
    elif os.path.isdir(filepath):
        shutil.rmtree(filepath)
1095161
public function unscheduleCollectionDeletion(PersistentCollectionInterface $coll) : void
    {
        if ($coll->getOwner() === null) {
            return;
        }

        $oid = spl_object_hash($coll);
        if (! isset($this->collectionDeletions[$oid])) {
            return;
        }

        $topmostOwner = $this->getOwningDocument($coll->getOwner());
        unset($this->collectionDeletions[$oid]);
        unset($this->hasScheduledCollections[spl_object_hash($topmostOwner)][$oid]);
    }
1355410
public function removeAllIndexes($collection = '')
		{
			if (empty($collection)) {
				throw new Exception("No Mongo collection specified to remove all indexes from");
			}

			$this->db->{$collection}->deleteIndexes();
			$this->_clear();

			return $this;
		}
1138681
def destroy(update_collection=true)
      return if new_record?
      previous_name = name_changed? ? name_was : name
      parent.modify_engine do |nat|
        nat.remove_redirect(previous_name)
      end
      parent_collection.delete(self, true) if parent_collection && update_collection
      new_record!
      true
    end
576875
def delete_if_not_in_zsets(self, key, member, set_list, client=None):
        
        return self._delete_if_not_in_zsets(
            keys=[key]+set_list,
            args=[member],
            client=client)
1293227
public void removeCollection(String collectionName) throws SolrException {
        try {
            CollectionAdminRequest request = CollectionAdminRequest.deleteCollection(collectionName);
            request.process(solrClient);
        } catch (SolrServerException | IOException e) {
            throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, e.getMessage(), e);
        }
    }
943922
public boolean removeAll(final IntHashSet coll)
    {
        boolean acc = false;

        for (final int value : coll.values)
        {
            if (value != MISSING_VALUE)
            {
                acc |= remove(value);
            }
        }

        if (coll.containsMissingValue)
        {
            acc |= remove(MISSING_VALUE);
        }

        return acc;
    }
862359
protected void deleteCollection() throws PolicyIndexException {

        // get root collection management service
        Collection rootCol;
        try {
            rootCol = DatabaseManager.getCollection(m_databaseURI + ROOT_COLLECTION_PATH ,m_user, m_password);
            CollectionManagementService mgtService = (CollectionManagementService) rootCol.getService("CollectionManagementService", "1.0");

            // delete the collection
            mgtService.removeCollection(m_collectionName);

            log.debug("Policy collection deleted");
        } catch (XMLDBException e) {
            throw new PolicyIndexException("Error deleting collection " + e.getMessage(), e);
        }
    }
204993
def remove(self, item):
        '''

        '''
        match = self.match(item)
        if match is None:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )

        index = int(match.group('index'))
        try:
            self.indexes.remove(index)
        except KeyError:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )
272079
public function drop($collection, array $options = [])
    {
        $collectionName = $this->getCollectionName($collection);

        if ($this->isValidCollectionId($collectionName)) {
            throw new ClientException('Cannot alter a collection without a collection id');
        }

        $appendix = '';
        if (is_array($options) && isset($options['isSystem'])) {
            $appendix = '?isSystem=' . UrlHelper::getBoolString($options['isSystem']);
        }

        $this->getConnection()->delete(UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collectionName]) . $appendix);

        return true;
    }
1280996
public static base_responses unset(nitro_service client, String aclname[], String args[]) throws Exception {
		base_responses result = null;
		if (aclname != null && aclname.length > 0) {
			nsacl unsetresources[] = new nsacl[aclname.length];
			for (int i=0;i<aclname.length;i++){
				unsetresources[i] = new nsacl();
				unsetresources[i].aclname = aclname[i];
			}
			result = unset_bulk_request(client, unsetresources,args);
		}
		return result;
	}
555981
def item_acl(self, item):
        
        if self.es_based:
            from nefertari_guards.elasticsearch import get_es_item_acl
            return get_es_item_acl(item)
        return super(DatabaseACLMixin, self).item_acl(item)
348876
private static void removeDifferingIndexIfAny(final MongoCollection collection, final Index index) {
        val indexes = (ListIndexesIterable<Document>) collection.listIndexes();
        var indexExistsWithDifferentOptions = false;

        for (val existingIndex : indexes) {
            val keyMatches = existingIndex.get("key").equals(index.getIndexKeys());
            val optionsMatch = index.getIndexOptions().entrySet().stream().allMatch(entry -> entry.getValue().equals(existingIndex.get(entry.getKey())));
            val noExtraOptions = existingIndex.keySet().stream().allMatch(key -> MONGO_INDEX_KEYS.contains(key) || index.getIndexOptions().keySet().contains(key));
            indexExistsWithDifferentOptions |= keyMatches && !(optionsMatch && noExtraOptions);
        }

        if (indexExistsWithDifferentOptions) {
            LOGGER.debug("Removing MongoDb index [{}] from [{}] because it appears to already exist in a different form", index.getIndexKeys(), collection.getNamespace());
            collection.dropIndex(index.getIndexKeys());
        }
    }
146336
function unique(acls) {
    var newAcls = [];
    // Remove empty and duplicate ACLs from specified list
    acls.forEach(function(acl) {
      if (!acl.isEmpty()) {
        var found = false;
        var len = newAcls.length;
        for (var i = 0; !found && i < len; i++)
          found = newAcls[i].equals(acl);
        if (!found)
          newAcls.push(acl);
      }
    });
    return newAcls;
  }
937083
public boolean removeAll(final ObjectHashSet<T> coll)
    {
        boolean acc = false;

        for (final T value : coll.values)
        {
            if (value != MISSING_VALUE)
            {
                acc |= remove(value);
            }
        }

        return acc;
    }
406114
private function removeEmptyRowsFromCollection()
    {
        $this->collection = $this->collection->reject(function ($data) {
            if (empty($data)) {
                return true;
            } else {
                return false;
            }
        });
    }