class RuboCop::Cop::Naming::PredicateName

end
def value?
# good
end
def has_value?
end
def has_value
# bad
end
def even?(value)
# good
end
def is_even?(value)
end
def is_even(value)
# bad
@example
This cop makes sure that predicates are named properly.

def allowed_method_name?(method_name, prefix) 

def allowed_method_name?(method_name, prefix)
  !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
      method_name.match?(/^#{prefix}[^0-9]/)) ||
    method_name == expected_name(method_name, prefix) ||
    method_name.end_with?('=') ||
    allowed_method?(method_name)
end

def expected_name(method_name, prefix) 

def expected_name(method_name, prefix)
  new_name = if forbidden_prefixes.include?(prefix)
               method_name.sub(prefix, '')
             else
               method_name.dup
             end
  new_name << '?' unless method_name.end_with?('?')
  new_name
end

def forbidden_prefixes 

def forbidden_prefixes
  cop_config['ForbiddenPrefixes']
end

def message(method_name, new_name) 

def message(method_name, new_name)
  "Rename `#{method_name}` to `#{new_name}`."
end

def method_definition_macros(macro_name) 

def method_definition_macros(macro_name)
  cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
end

def on_def(node) 

def on_def(node)
  predicate_prefixes.each do |prefix|
    method_name = node.method_name.to_s
    next if allowed_method_name?(method_name, prefix)
    add_offense(
      node.loc.name,
      message: message(method_name, expected_name(method_name, prefix))
    )
  end
end

def on_send(node) 

def on_send(node)
  dynamic_method_define(node) do |method_name|
    predicate_prefixes.each do |prefix|
      next if allowed_method_name?(method_name.to_s, prefix)
      add_offense(
        node.first_argument.loc.expression,
        message: message(method_name,
                         expected_name(method_name.to_s, prefix))
      )
    end
  end
end

def predicate_prefixes 

def predicate_prefixes
  cop_config['NamePrefix']
end