Delete an existing tag

 @param [String] tag Tag to delete
 @return [nil]
493799
def tags_delete(tag)
      params = { tag: tag }

      options = create_params(params)
      self.class.get('/tags/delete', options)
      nil
    end
15875
def tags(name = nil)
      list = stable_sort_by(@tags + convert_ref_tags, &:tag_name)
      return list unless name
      list.select {|tag| tag.tag_name.to_s == name.to_s }
    end
1159058
def destroy
      @tag = Tag.find(params[:id])
      @tag.destroy

      respond_to do |format|
        format.html { redirect_to tags_url }
        format.json { head :no_content }
      end
    end
317944
def matches_tags?(tag_expr)
      Cucumber::Core::Gherkin::TagExpression.new(tag_expr).evaluate(
        tags.map { |tag| Cucumber::Core::Ast::Tag.new(nil, tag) }
      )
    end
1115823
function deleteTag( $tag, $blog_id, $tag_group, $for_real = false ) {

		/** @var $wpdb \wpdb */
		global $wpdb;

		// Get ID

		$sql = "SELECT id FROM {$this->dbTagsTable} WHERE tag = %s ";
		$tag_id = $wpdb->get_var( $wpdb->prepare( $sql, $tag ) ); // @codingStandardsIgnoreLine

		if ( ! $tag_id ) {
			return false;
		}

		if ( $for_real && is_super_admin() ) {
			$wpdb->delete(
				$this->dbLinkTable, [
					'tags_id' => $tag_id,
				], [ '%d' ]
			);
			$wpdb->delete(
				$this->dbTagsTable, [
					'id' => $tag_id,
				], [ '%d' ]
			);
			$result = 1;
		} else {
			$result = $wpdb->delete(
				$this->dbLinkTable,
				[
					'users_id' => $this->userId,
					'blogs_id' => $blog_id,
					'tags_id' => $tag_id,
					'tags_group' => $tag_group,
				],
				[ '%d', '%d', '%d', '%d' ]
			);
		}

		// TODO:
		// Optimize the links table: $wpdb->query( "OPTIMIZE TABLE {$this->dbLinkTable} " );
		// Optimize the tags table: $wpdb->query( "OPTIMIZE TABLE {$this->dbTagsTable} " );

		return $result;
	}
1095332
public ItemRequest<Tag> delete(String tag) {
    
        String path = String.format("/tags/%s", tag);
        return new ItemRequest<Tag>(this, Tag.class, path, "DELETE");
    }
1279681
async def delete_entry_tag(self, entry, tag):
        
        params = {'access_token': self.token}
        url = '/api/entries/{entry}/tags/{tag}.{ext}'.format(
            entry=entry, tag=tag, ext=self.format)
        return await self.query(url, "delete", **params)
824587
def untag(name, tag_name):
    

    with LOCK:
        by_tag = TAGS.get(tag_name, None)
        if not by_tag:
            return False
        try:
            by_tag.remove(name)

            # remove the tag if no associations left
            if not by_tag:
                TAGS.pop(tag_name)

            return True
        except KeyError:
            return False
447049
def delete_tags(self, arg):
        

        if len(arg) > 0:
            raw = html.fromstring(arg)
            return raw.text_content().strip()

        return arg
140125
def delete_tags(self, archive_name, tags):
        '''
        

        '''
        updated_tag_list = list(self._get_tags(archive_name))
        for tag in tags:
            if tag in updated_tag_list:
                updated_tag_list.remove(tag)

        self._set_tags(archive_name, updated_tag_list)
156813
public function removeByTag($tag)
    {
        $tags = (array) $tag;

        if (0 == count($tags)) {
            return false;
        }

        try {
            $this->_repository
                    ->createQueryBuilder('c')
                    ->delete()
                    ->where('c._tag IN (:tags)')
                    ->setParameters(array('tags' => $this->getContextualTags($tags)))
                    ->getQuery()
                    ->execute();
            $this->resetCacheEntity();
        } catch (\Exception $e) {
            $this->log('warning', sprintf('Enable to remove cache for tags (%s) : %s', implode(',', $tags), $e->getMessage()));

            return false;
        }

        return true;
    }
1312067
void deleteTag(long bucketIndex, int posInBucket) {
		long tagStartIdx = getTagOffset(bucketIndex, posInBucket);
		memBlock.clear(tagStartIdx, tagStartIdx + bitsPerTag);
	}
1102359
def DeleteInstanceTags(r, instance, tags, dry_run=False):
    

    query = {
        "tag": tags,
        "dry-run": dry_run,
    }

    return r.request("delete", "/2/instances/%s/tags" % instance, query=query)
793127
public void removeTag(Tag tag) {
    Iterable<Tag> tags = getTags();
    removeAll(tags, singletonList(tag));
    set(PackageMetadata.TAGS, tag);
  }
78603
def remove_tags(alert_ids, tag_names)
      query = generate_query_params(alertIds: alert_ids, tagNames: tag_names)
      http_delete('/tags' + query)
    end
206474
function deleteTags() {
  return git.fetch({tags: true, remote: remote})
      .then(function() {
        return git.removeTags({
          remote: remote,
          tags: git.getTags //using resolvables
        });  
      });
}
834147
def delete_indicator_tag(self, indicator_value, tag_id):
        

        params = {
            'value': indicator_value
        }

        self._client.delete("indicators/tags/%s" % tag_id, params=params)