class RuboCop::Cop::Style::Lambda

end
x
f = ->(x) do
f = ->(x) { x }
# good
end
x
f = lambda do |x|
f = lambda { |x| x }
# bad
@example EnforcedStyle: literal
end
x
f = lambda do |x|
f = lambda { |x| x }
# good
end
x
f = ->(x) do
f = ->(x) { x }
# bad
@example EnforcedStyle: lambda
end
x
f = lambda do |x|
f = ->(x) { x }
# good
end
x
f = ->(x) do
f = lambda { |x| x }
# bad
@example EnforcedStyle: line_count_dependent (default)
and multiline lambdas as well.
It is configurable to enforce one of the styles for both single line
single line lambdas, and the method call syntax for multiline lambdas.
This cop (by default) checks for uses of the lambda literal syntax for

def arguments_with_whitespace(node) 

def arguments_with_whitespace(node)
  node.loc.begin.end.join(node.arguments.loc.end)
end

def autocorrect_method_to_literal(corrector, node) 

def autocorrect_method_to_literal(corrector, node)
  corrector.replace(node.send_node, '->')
  return unless node.arguments?
  arg_str = "(#{lambda_arg_string(node.arguments)})"
  corrector.insert_after(node.send_node, arg_str)
  corrector.remove(arguments_with_whitespace(node))
end

def lambda_arg_string(args) 

def lambda_arg_string(args)
  args.children.map(&:source).join(', ')
end

def message(node, selector) 

def message(node, selector)
  message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
  format(message, modifier: message_line_modifier(node))
end

def message_line_modifier(node) 

def message_line_modifier(node)
  case style
  when :line_count_dependent
    node.multiline? ? 'multiline' : 'single line'
  else
    'all'
  end
end

def offending_selector?(node, selector) 

def offending_selector?(node, selector)
  lines = node.multiline? ? :multiline : :single_line
  selector == OFFENDING_SELECTORS[:style][style][lines]
end

def on_block(node) 

def on_block(node)
  return unless node.lambda?
  selector = node.send_node.source
  return unless offending_selector?(node, selector)
  add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
    if node.send_node.source == 'lambda'
      autocorrect_method_to_literal(corrector, node)
    else
      LambdaLiteralToMethodCorrector.new(node).call(corrector)
    end
  end
end