cycle through all rules and apply them all without regard to
        success or failure

        returns:
             True - since success or failure is ignored
331713
def apply_all_rules(self, *args, **kwargs):
        """"""
        for x in self.rules:
            self._quit_check()
            if self.config.chatty_rules:
                self.config.logger.debug(
                    'apply_all_rules: %s',
                    to_str(x.__class__)
                )
            predicate_result, action_result = x.act(*args, **kwargs)
            if self.config.chatty_rules:
                self.config.logger.debug(
                    '               : pred - %s; act - %s',
                    predicate_result,
                    action_result
                )
        return True
72312
def run_all
      passed, failed_examples, passed_examples = Runner.run(['spec'], options.merge({ :message => 'Run all specs'}))

      self.rerun_specs = failed_examples
      self.last_run_passed = passed

      throw :task_has_failed unless passed
    end
1205381
function applyDisallowedRule( rule, element, status ) {
		// This rule doesn't match this element - skip it.
		if ( rule.match && !rule.match( element ) )
			return;

		// No properties - it's an element only rule so it disallows entire element.
		// Early return is handled in filterElement.
		if ( rule.noProperties )
			return false;

		// Apply rule to attributes, styles and classes. Switch hadInvalid* to true if method returned true.
		status.hadInvalidAttribute = applyDisallowedRuleToHash( rule.attributes, element.attributes ) || status.hadInvalidAttribute;
		status.hadInvalidStyle = applyDisallowedRuleToHash( rule.styles, element.styles ) || status.hadInvalidStyle;
		status.hadInvalidClass = applyDisallowedRuleToArray( rule.classes, element.classes ) || status.hadInvalidClass;
	}
13522
def fail(self, text=None):
        
        return self.stop_and_persist(symbol=LogSymbols.ERROR.value, text=text)
1336585
function(rule) {
      var ans = arguments[1] !== undefined ? [arguments[1]] : [],
          state;
      while (true) {
        state = this.bt.current_state();
        try { ans.push(rule.call(this)) } 
        catch (f) {
          this.bt.catch_mismatch(f);
          this.bt.restore(state);
          break;
        }
      }
      return ans
    }
1225425
def matches_all_rules(self, target_filename):
        

        for rule in self.match_rules:
            if rule.test(target_filename) is False:
                return False

        self.logger.debug('{0}: {1} - {2}'.format(self.name,
                                                  os.path.basename(target_filename),
                                                  'Match'))
        return True
1222134
def process_rule(self,rule,pa,tuple):
        ''' 
        '''
        for i,v in enumerate(tuple):
            rule = rule.replace(pa[i],str(v))
        return eval(rule)
1312116
def ignore_errors(self):
        
        new_command = copy.deepcopy(self)
        new_command._ignore_errors = True
        return new_command
1222417
def validate(self) -> ValidationResult:
        
        result = ValidationResult()
        try:
            for rule in self.get_rules():
                try:
                    if not rule.apply():
                        result.annotate_rule_violation(rule)
                        if rule.stop_if_invalid:
                            break
                except Exception as e:
                    result.annotate_exception(e, rule)
        except Exception as e:
            result.annotate_exception(e, None)
        return result
420691
def postinit(self, test=None, fail=None):
        
        self.fail = fail
        self.test = test
160722
def match(self, rule):
        
        if len(self.filters) == 0:
            return True

        for filter in self.filters:
            if filter.match(rule):
                return True
        return False
1070698
def addnot(self, action=None, subject=None, **conditions):
        
        self.add_rule(Rule(False, action, subject, **conditions))
261746
def ignore_rule_matches_result(ignore_rule, pa11y_result):
    
    return all(
        fnmatch.fnmatch(pa11y_result.get(attr), ignore_rule.get(attr))
        for attr in ignore_rule.keys()
    )
309723
def check_result(running, recurse=False, highstate=None):
    '''
    
    '''
    if not isinstance(running, dict):
        return False

    if not running:
        return False

    ret = True
    for state_id, state_result in six.iteritems(running):
        expected_type = dict
        # The __extend__ state is a list
        if "__extend__" == state_id:
            expected_type = list
        if not recurse and not isinstance(state_result, expected_type):
            ret = False
        if ret and isinstance(state_result, dict):
            result = state_result.get('result', _empty)
            if result is False:
                ret = False
            # only override return value if we are not already failed
            elif result is _empty and isinstance(state_result, dict) and ret:
                ret = check_result(
                    state_result, recurse=True, highstate=highstate)
        # if we detect a fail, check for onfail requisites
        if not ret:
            # ret can be None in case of no onfail reqs, recast it to bool
            ret = bool(check_onfail_requisites(state_id, state_result,
                                               running, highstate))
        # return as soon as we got a failure
        if not ret:
            break
    return ret
1364227
def process_rules(rules, fixed_text, cur = 0, cur_end = 1):
    
    replaced = ''
    # iterate through rules
    for rule in rules:
        matched = False
        # iterate through matches
        for match in rule['matches']:
            matched = process_match(match, fixed_text, cur, cur_end)
            # Break out of loop if we dont' have a match. Here we are
            # trusting avrodict to have listed matches sequentially
            if not matched:
                break
        # If a match is found, stop looping through rules any further
        if matched:
            replaced = rule['replace']
            break

    # if any match has been found return replace value
    if matched:
        return replaced
    else:
        return None
654254
def check_failhard(self, low, running):
        '''
        
        '''
        tag = _gen_tag(low)
        if self.opts.get('test', False):
            return False
        if low.get('failhard', self.opts['failhard']) and tag in running:
            if running[tag]['result'] is None:
                return False
            return not running[tag]['result']
        return False
1260880
function (f, context, args, description) {
  args = args || [];
  if (Package['audit-argument-checks']) {
    return Match._failIfArgumentsAreNotAllChecked(
      f, context, args, description);
  }
  return f.apply(context, args);
}