class RuboCop::Cop::Metrics::ParameterLists


end
def foo(a = 1, b = 2, c = 3)
# bad
@example MaxOptionalParameters: 2
end
def foo(a = 1, b = 2, c = 3)
# good
@example MaxOptionalParameters: 3 (default)
This can be configured using the ‘MaxOptionalParameters` config option.
This cop also checks for the maximum number of optional parameters.
end
def foo(a, b, c, d: 1)
# good (assuming Max is 3)
# don’t count keyword args towards the maximum
@example CountKeywordArgs: false
end
def foo(a, b, c: 1)
# good (assuming Max is 3)
end
def foo(a, b, c, d: 1)
# bad (assuming Max is 3)
# counts keyword args towards the maximum
@example CountKeywordArgs: true (default)
end
def foo(a, b, c = 1)
# bad
@example Max: 2
end
def foo(a, b, c = 1)
# good
@example Max: 3
erroneous change that is avoided by making block argument implicit.
NOTE: Explicit block argument ‘&block` is not counted to prevent
does not make sense.
This is because checking the number of arguments of the `initialize` method
—-
end
end
def initialize(one:, two:, three:, four:, five:)
Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
—-
[source,ruby]

`Struct.new` and `Data.define` like this is always allowed:
Any number of arguments for `initialize` method inside a block of
as they add less complexity than positional or optional parameters.
Keyword arguments can optionally be excluded from the total count,
The maximum number of parameters is configurable.
Checks for methods with too many parameters.

def args_count(node) 

def args_count(node)
  if count_keyword_args?
    node.children.count { |a| !a.blockarg_type? }
  else
    node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
  end
end

def count_keyword_args? 

def count_keyword_args?
  cop_config['CountKeywordArgs']
end

def max_optional_parameters 

def max_optional_parameters
  cop_config['MaxOptionalParameters']
end

def max_params 

def max_params
  cop_config['Max']
end

def on_args(node) 

def on_args(node)
  parent = node.parent
  return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
  count = args_count(node)
  return unless count > max_params
  return if argument_to_lambda_or_proc?(node)
  add_offense(node, message: format(MSG, max: max_params, count: args_count(node))) do
    self.max = count
  end
end

def on_def(node) 

def on_def(node)
  optargs = node.arguments.select(&:optarg_type?)
  return if optargs.count <= max_optional_parameters
  message = format(
    OPTIONAL_PARAMETERS_MSG,
    max: max_optional_parameters,
    count: optargs.count
  )
  add_offense(node, message: message) { self.max_optional_parameters = optargs.count }
end