class RuboCop::Cop::Naming::MethodName


def api_gen1; end
def release_v1; end
# bad
@example ForbiddenPatterns: [‘_v1z’, ‘_gen1z’]
def super; end
def def; end
# bad
@example ForbiddenIdentifiers: [‘def’, ‘super’]
def fooBar; end
# good
def foo_bar; end
# bad
@example EnforcedStyle: camelCase
def foo_bar; end
# good
def fooBar; end
# bad
@example EnforcedStyle: snake_case (default)
—-
- ‘_gen1z’
- ‘_v1z’
ForbiddenPatterns:
- ‘super’
- ‘def’
ForbiddenIdentifiers:
Naming/MethodName:
—-
[source,yaml]

using ‘ForbiddenIdentifiers` or `ForbiddenPatterns`:
As well, you can also forbid specific method names or regexp patterns
—-
- ’AonSelectionClearedz‘
- ’AonSelectionBulkChangez‘
AllowedPatterns:
Naming/MethodName:
—-
[source,yaml]

The cop can be configured with `AllowedPatterns` to allow certain regexp patterns:
Method names matching patterns are always allowed.
snake_case or camelCase, for their names.
Makes sure that all methods use the configured style,

def attr_name(name_item) 

def attr_name(name_item)
  sym_name(name_item) || str_name(name_item)
end

def forbidden_name?(name) 

def forbidden_name?(name)
  forbidden_identifier?(name) || forbidden_pattern?(name)
end

def message(style) 

def message(style)
  format(MSG, style: style)
end

def on_def(node) 

def on_def(node)
  return if node.operator_method? || matches_allowed_pattern?(node.method_name)
  if forbidden_name?(node.method_name.to_s)
    register_forbidden_name(node)
  else
    check_name(node, node.method_name, node.loc.name)
  end
end

def on_send(node) 

def on_send(node)
  return unless (attrs = node.attribute_accessor?)
  attrs.last.each do |name_item|
    name = attr_name(name_item)
    next if !name || matches_allowed_pattern?(name)
    if forbidden_name?(name.to_s)
      register_forbidden_name(node)
    else
      check_name(node, name, range_position(node))
    end
  end
end

def range_position(node) 

def range_position(node)
  selector_end_pos = node.loc.selector.end_pos + 1
  expr_end_pos = node.source_range.end_pos
  range_between(selector_end_pos, expr_end_pos)
end

def register_forbidden_name(node) 

def register_forbidden_name(node)
  if node.any_def_type?
    name_node = node.loc.name
    method_name = node.method_name
  else
    attrs = node.attribute_accessor?
    name_node = attrs.last.last
    method_name = attr_name(name_node)
  end
  message = format(MSG_FORBIDDEN, identifier: method_name)
  add_offense(name_node, message: message)
end