Match all the #IgnoreList#s` in this collection. Returns one of

    - #MATCH_DEFAULT
    - #MATCH_IGNORE
    - #MATCH_INCLUDE
327170
def match(self, filename, isdir=False):
    

    for lst in self:
      result = lst.match(filename, isdir)
      if result != MATCH_DEFAULT:
        return result
    return MATCH_DEFAULT
473104
def exclude(requestContext, seriesList, pattern):
    
    regex = re.compile(pattern)
    return [s for s in seriesList if not regex.search(s.name)]
546638
def is_excluded(root, excludes):
    # type: (unicode, List[unicode]) -> bool
    
    for exclude in excludes:
        if fnmatch(root, exclude):
            return True
    return False
843140
function matches(patterns) {
  if (!Array.isArray(patterns)) {
    if (typeof patterns === 'string') {
      return patterns.indexOf('!') === 0 ? [] : glob.sync(patterns);
    } else {
      return [];
    }
  }
  let result = [];
  patterns.forEach((pattern) => {
    const exclusion = pattern.indexOf('!') === 0;
    if (exclusion) {
      pattern = pattern.slice(1);
    }
    const arr = glob.sync(pattern);
    if (exclusion) {
      result = difference(result, arr);
    } else {
      result = union(result, arr);
    }
  });
  return result;
}
1046419
def match_list(query_list, string):
    
    # Get rid of 'the' word to ease string matching
    match = False
    index = 0
    string = ' '.join(filter_stopwords(string))

    if not isinstance(query_list, list):
        query_list = [query_list]

    while index < len(query_list):
        query = query_list[index]
        words_query = filter_stopwords(query)
        match = all(word in string for word in words_query)
        if match:
            break

        index += 1

    return match
309692
def match(self, s=''):
        
        match = s.lower()
        res = {}
        for k in sorted(self):
            s = str(k) + '=\'' + str(self[k]) + '\''
            if match in s.lower():
                res[k] = self[k]
        return CMAOptions(res, unchecked=True)
34908
def ToolMatches(tools=None, version='HEAD'):
    
    matches = []
    if tools:
        for tool in tools:
            match_version = version
            if tool[1] != '':
                match_version = tool[1]
            match = ''
            if tool[0].endswith('/'):
                match = tool[0][:-1]
            elif tool[0] != '.':
                match = tool[0]
            if not match.startswith('/') and match != '':
                match = '/'+match
            matches.append((match, match_version))
    return matches
751727
def dict_match(self, match_dict):
        '''
        
        '''
        ret = {}
        cur_keys = self.list_keys()
        for status, keys in six.iteritems(match_dict):
            for key in salt.utils.data.sorted_ignorecase(keys):
                for keydir in (self.ACC, self.PEND, self.REJ, self.DEN):
                    if keydir and fnmatch.filter(cur_keys.get(keydir, []), key):
                        ret.setdefault(keydir, []).append(key)
        return ret
624669
def match(self, other):
        
        if self.sub_type != '*' and other.sub_type != '*' and other.sub_type != self.sub_type:
            return False

        if self.main_type != '*' and other.main_type != '*' and other.main_type != self.main_type:
            return False

        return True
905717
def operators(self, ignore=0):
        
        return [k for k, v in self._operatorMap.items() if not v.flags & ignore]
1100626
def ignore_patterns(*patterns):
    """"""
    import fnmatch
    def _ignore_patterns(path, names):
        ignored_names = []
        for pattern in patterns:
            ignored_names.extend(fnmatch.filter(names, pattern))
        return set(ignored_names)
    return _ignore_patterns
1155975
def match(self, objects: List[Any]) -> bool:
        

        s = self._make_string(objects)
        m = self._compiled_expression.match(s)
        return m is not None
1213609
function find(list, match) {
	  for (var i = 0; i < list.length; i++) {
	    if (match(list[i])) {
	      return list[i];
	    }
	  }
	  return undefined;
	}
863884
def ignore_pattern=(regexp)
      unless regexp.kind_of?(Regexp)
        raise TypeError, "expected Regexp, got #{regexp.inspect}:#{regexp.class}"
      end

      Celerity::IgnoringWebConnection.new(@webclient, regexp)
    end
686352
def ignored_regions(source):
    
    return [(match.start(), match.end()) for match in _str.finditer(source)]
15516
def filter_exclusions file_paths
      file_paths.reject do |path|
        exclude_file_patterns.any? { |pattern| File.fnmatch("#{pattern}", path) || File.fnmatch("**/#{pattern}", path) }
      end
    end
1079458
def matchers() -> List[SimAlgorithm]:
        
        return [
            SimAlgorithm.PHENODIGM,
            SimAlgorithm.JACCARD,
            SimAlgorithm.SIM_GIC,
            SimAlgorithm.RESNIK,
            SimAlgorithm.SYMMETRIC_RESNIK
        ]