Will return true if the Mash has had a key
 set in addition to normal respond_to? functionality.
179104
def respond_to?(method_name, include_private=false)
      camelized_name = camelize(method_name.to_s)

      if key?(method_name) ||
          key?(camelized_name) ||
            method_name.to_s.slice(/[=?!_]\Z/)
        return true
      end

      super
    end
365691
def respond_to_missing?(method, include_private = false)
      if method.to_s.starts_with? "*"
        condition_name = method.to_s.split("*")[1].to_sym
        conditions = self.class.scram_conditions
        if conditions && !conditions[condition_name].nil?
          return true
        end
      end
      super
    end
485592
def are_stringable_keys(self, m):
        
        for x in m.keys():
            if len(self.handlers[x].tag(x)) != 1:
                return False
        return True
624847
def _yes(context):
    '''
    
    '''
    if 'chocolatey._yes' in __context__:
        return context['chocolatey._yes']
    if _LooseVersion(chocolatey_version()) >= _LooseVersion('0.9.9'):
        answer = ['--yes']
    else:
        answer = []
    context['chocolatey._yes'] = answer
    return answer
38865
function isSpam(from, message) {
  if (!config.filterSpam)
    return false;

  // Skip if this is a mod
  if (users[from] && users[from].mod)
    return false;

  // Check for capital letter spam
  var uppercaseCount = message.replace(/[^A-Z]/g, '').length;
  if (uppercaseCount >= 10 && uppercaseCount >= message.length / 2) {
    timeoutUser(from, null, 'stop using capital letters');
    return true;
  }

  return false;
}
978885
def _valid(m, comment=VALID_RESPONSE, out=None):
    '''
    
    '''
    return _set_status(m, status=True, comment=comment, out=out)
1069090
function hasKeybinding (key, method) {
  if (!bindings[key]) return false;
  return method ? !!~bindings[key].methods.indexOf(method) : true;
}
971212
def is_complete(self):
        
        self._update_questions()  # Make sure questions list is current
        for question_map in self._my_map['questions']:
            if 'missingResponse' in question_map['responses'][0]:
                return False
        return True
1224061
def key?(key)
      configuration.key?(key.to_sym) || config_contexts.key?(key.to_sym)
    end
1078660
def has_key?(key, opts={})
      key = normalize_key(key) if opts.fetch(:normalize, true)
      @source.has_key?(key)
    end
797543
def check_key(key, allowed):
    

    if key in allowed:
        return True

    for pattern in allowed:
        if fnmatch(key, pattern):
            return True

    return False
223129
def any_present?(*keys)
      keys.each do |key|
        return true if self.send(key).present?
      end
      return false
    end
1280167
def is_response(self, other):
        """"""
        if other.flags & dns.flags.QR == 0 or \
           self.id != other.id or \
           dns.opcode.from_flags(self.flags) != \
           dns.opcode.from_flags(other.flags):
            return False
        if dns.rcode.from_flags(other.flags, other.ednsflags) != \
               dns.rcode.NOERROR:
            return True
        if dns.opcode.is_update(self.flags):
            return True
        for n in self.question:
            if n not in other.question:
                return False
        for n in other.question:
            if n not in self.question:
                return False
        return True
1016812
def is_set(self, key):
        """"""
        data = self.model.get_data()
        return isinstance(data[key], set)
449293
def is_ready(self, key):
        """"""
        if self.pending_callbacks is None or key not in self.pending_callbacks:
            raise UnknownKeyError("key %r is not pending" % (key,))
        return key in self.results
655370
def check_key(self, key: str) -> bool:
        
        keys = self.get_keys()
        return key in keys
387885
def _pv_respond_to(opts, key, method_name_list)
        value = _pv_opts_lookup(opts, key)
        unless value.nil?
          Array(method_name_list).each do |method_name|
            unless value.respond_to?(method_name)
              raise ValidationFailed, "Option #{key} must have a #{method_name} method!"
            end
          end
        end
      end