Remove a :class:`Pattern` from the :class:`PatternSet`
964027
def remove(self, pattern):
        """"""
        assert isinstance(pattern, Pattern)
        self.patterns.remove(pattern)
        self._all_files = None
326091
def strip_line_magic_v2(cls,line):
        """"""

        matches = re.findall("magic\(([^]]+)", line)
        if matches and matches[0]: # This line contains the pattern
            match = matches[0]
            if match[-1] == ')':
                match = match[:-1] # Just because the re way is hard
            stripped = eval(match)
            magic_kind = stripped.split(' ')[0]
            if len(stripped.split(' '))>1:
                stripped = stripped.split(' ')[1:]
            else:
                stripped = ""
        else:
            stripped = line
            magic_kind = ""
        return stripped,magic_kind
272077
def _remove_files(self, directory, pattern):
        '''
        
        '''
        for root, dirnames, file_names in os.walk(directory):
            for file_name in fnmatch.filter(file_names, pattern):
                os.remove(os.path.join(root, file_name))
701176
def stop_class(self, class_):
        ""
        matches = filter(lambda svc: isinstance(svc, class_), self)
        map(self.stop, matches)
296894
def delete_all(pattern = {})
      result = true
      each(pattern) { |st| result &&= delete(st) }
      result
    end
758854
def remove(self, attr, item):
        
        return self.set(attr, operation.Remove([item]))
272418
def remove_patch(cls, patch_name):
        
        try:
            os.unlink(cls._get_patch_path(patch_name))
        except:
            raise StashException("patch '%s' does not exist" % patch_name)
1075560
function removeClass(className) {
                if (el.classList) {
                    el.classList.remove(className);
                } else {
                    el.className = el.className.replace(new RegExp('(^|\\b)' + className + '(\\b|$)', 'gi'), ' ');
                }
            }
173966
def remove_class(cls, *args):
        
        for cls2 in args:
            try:
                del cls.classes[cls2.__name__]
            except KeyError:
                pass
762748
def remove_for_target(self, target, classpath_elements):
    """"""
    self._classpaths.remove_for_target(target, self._wrap_path_elements(classpath_elements))
466376
def remove(self, matcher, obj):
        '''
        
        '''
        current = self.subtree(matcher, False)
        if current is None:
            return
        # Assume that this pair only appears once
        if current._use_dict:
            try:
                del current.matchers_dict[(obj, matcher)]
            except KeyError:
                pass
        else:
            if len(current.matchers_list) > 10:
                # Convert to dict
                current.matchers_dict = OrderedDict((v, None) for v in current.matchers_list
                                                    if v != (obj, matcher))
                current.matchers_list = None
                current._use_dict = True
            else:
                try:
                    current.matchers_list.remove((obj, matcher))
                except ValueError:
                    pass
        while ((not current.matchers_dict) if current._use_dict
               else (not current.matchers_list))\
                and not current.matchers_dict\
                and not hasattr(current,'any')\
                and not current.index and current.parent is not None:
            # remove self from parents
            ind = current.parentIndex
            if ind is None:
                del current.parent.any
            else:
                del current.parent.index[ind]
            p = current.parent
            current.parent = None
            current = p
1008776
function(node, pattern) {
		if (!!node && (node.nodeType === 3) && pattern.exec(node.nodeValue)) {
			node.nodeValue = node.nodeValue.replace(pattern, '');
		}
	}
1121623
def remove(self, *terminals):
        # type: (Iterable[Any]) -> None
        
        for term in set(terminals):
            if term not in self:
                raise KeyError('Terminal ' + str(term) + ' is not inside')
            self._grammar.rules.remove(*self._assign_map[term], _validate=False)
            del self._assign_map[term]
            super().remove(term)
1189460
def removeItem(self, regItem):
        
        check_class(regItem, ClassRegItem)
        logger.info("Removing {!r} containing {}".format(regItem.identifier, regItem.fullClassName))

        del self._index[regItem.identifier]
        idx = self._items.index(regItem)
        del self._items[idx]
46200
function removeClass(elm, name) {
        if (name) {
            var cls = className(elm),
                names;

            if (langx.isString(name)) {
                names = name.split(/\s+/g);
            } else {
                names = name;
            }

            names.forEach(function(klass) {
                var re = classRE(klass);
                if (cls.match(re)) {
                    cls = cls.replace(re, " ");
                }
            });

            className(elm, cls.trim());
        } else {
            className(elm, "");
        }

        return this;
    }
803926
@SuppressWarnings("unchecked")
  private Set<String> extractIgnorePatterns(Map<String, Object> configuration) {
    List<String> patterns = asList("glob:.*",// hidden files
        "glob:*~", "glob:#*#", "glob:.#*", // emacs
        "glob:*~", "glob:[._]*.s[a-w][a-z]", "glob:[._]s[a-w][a-z]", "glob:*.un~" // vim
    );
    Set<String> s = new HashSet<>((List<String>) configuration.getOrDefault("ignore-patterns",patterns));
    s.addAll(patterns);
    return unmodifiableSet(s);
  }
240107
def remove_class(self, className):
        
        if className in self._dom_classes:
            self._dom_classes = [c for c in self._dom_classes if c != className]
        return self