unset tags for an app
438972
function unset(appName, tagNames, callback) {
    if (!util.isArray(tagNames)) {
      return callback(new Error('To unset a tag pass an array of names'));
    }

    var keyValues = {};
    tagNames.forEach(function eachTag(tagName) {
      keyValues[tagName] = null;
    });

    set(appName, keyValues, callback);
  }
1032379
public function untag($tags)
    {
        $tags = $this->makeTagsArray($tags);

        foreach ($tags as $tag)
            $this->removeOneTag($tag);

        return $this;
    }
329071
public void setTags(String... tags) {
        removeAllViews();
        for (final String tag : tags) {
            appendTag(tag);
        }

        if (isAppendMode) {
            appendInputTag();
        }
    }
1249229
def delete_tags(sender, **kwargs):
    
    try:
        obj = kwargs.get('instance')
        tags = Tag.get_tags(obj)
        tags.delete()
    except AttributeError:
        pass
151428
def _removeTags(tags, objects):
    
    for t in tags:
        for o in objects:
            o.tags.remove(t)

    return True
367987
public void untag(Class<?> tagClass) {
    Iterator<Tag<?>> tagIter = _tags.iterator();
    while (tagIter.hasNext()) {
      Tag<?> tag = tagIter.next();
      if (tagClass.isInstance(tag)) {
        tagIter.remove();
      }
    }
  }
822412
function clean($tag) {
		if (isset($this->_tags[$tag])) {
			foreach ($this->_tags[$tag] as $k) { /** @var string $k */
				unset($this->_data[$k]);
			}
			unset($this->_tags[$tag]);
		}
	}
1021863
def _unparse_a_tags(cls, attrs_dict):
        
        prop_tags = []

        for k, v in attrs_dict.items():
            node = {cls.ATTRNAME_PROPERTY: k, '_content': utils.auto_type(v)}
            prop_tags.append(node)

        return prop_tags
702884
def ensure_no_tags(str)
      return str unless str.html_safe?
      
      str = str.to_str # get it out of HTMLSafeBuffer, which messes things up
      str = strip_tags(str) 

      str = HTMLEntities.new.decode(str)

      return str
    end
192685
def remove_tag(self, tag):
        """"""

        if isinstance(tag, Tag):
            tag = tag.get_name()

        params = self._get_params()
        params["tag"] = tag

        self._request(self.ws_prefix + ".removeTag", False, params)
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)
116865
function deleteTags(cb) {
  async.series([
    async.apply(git.fetch, {tags: true, remote: remote}),
    function(cb) {
      async.waterfall([
        async.apply(git.getTags),
        function(tags, cb) {
          git.removeTags({tags: tags, remote: remote}, cb);
        }
      ], cb);
    }
  ], cb);
}
216563
def tag_del(self, item, tag):
        
        tags = list(self.item(item, "tags"))
        if tag in tags:
            tags.remove(tag)
            self.item(item, tags=tuple(tags))
1148859
def set_tags_context
      return unless tag_list_changed? || status_changed? || !persisted?

      # Give all tags current context
      set_tag_list_on(tag_context, tag_list)

      # Clear previous contexts
      self.tag_list = []
      inactive_tag_contexts.each do |context|
        set_tag_list_on(context, [])
      end
    end
931899
def remove_tag(self, resource_type, resource_id, tag, **_params):
        """"""
        return self.delete(self.tag_path % (resource_type, resource_id, tag))
1219173
private function removeUnprocessableTags()
    {
        foreach ($this->unprocessableHtmlTags as $tagName) {
            // Deleting nodes from a 'live' NodeList invalidates iteration on it, so a copy must be made to iterate.
            $nodes = [];
            foreach ($this->domDocument->getElementsByTagName($tagName) as $node) {
                $nodes[] = $node;
            }
            /** @var \DOMNode $node */
            foreach ($nodes as $node) {
                $hasContent = $node->hasChildNodes() || $node->hasChildNodes();
                if (!$hasContent) {
                    $node->parentNode->removeChild($node);
                }
            }
        }
    }
428101
function unset(appName, variableNames, callback) {
    if (!util.isArray(variableNames)) {
      return callback(new Error('To unset a variable pass an array of names'));
    }

    var keyValues = {};
    variableNames.forEach(function onUnsetResponse(variableName) {
      keyValues[variableName] = null;
    });

    set(appName, keyValues, callback);
  }