class RuboCop::Cop::Performance::DoubleStartEndWith


str.ends_with?(var1, var2)
str.starts_with?(“a”, “b”, “c”)
# good
str.ends_with?(var1) || str.ends_with?(var2)
str.starts_with?(“a”, “b”) || str.starts_with?(“c”)
# bad
@example IncludeActiveSupportAliases: true
str.ends_with?(var1, var2)
str.starts_with?(“a”, “b”, “c”)
str.ends_with?(var1) || str.ends_with?(var2)
str.starts_with?(“a”, “b”) || str.starts_with?(“c”)
# good
@example IncludeActiveSupportAliases: false (default)
str.end_with?(var1, var2)
!str.start_with?(foo, bar)
str.start_with?(“a”, “b”, “c”)
str.start_with?(“a”, Some::CONST)
# good
str.end_with?(var1) || str.end_with?(var2)
!str.start_with?(foo) && !str.start_with?(bar)
str.start_with?(“a”, “b”) || str.start_with?(“c”)
str.start_with?(“a”) || str.start_with?(Some::CONST)
# bad
@example
`starts_with?‘ and `ends_with?`. These methods are defined by Active Support.
`IncludeActiveSupportAliases` configuration option is used to check for
they are separated by `||`, they can be combined into a single method call.
These methods accept multiple arguments, so in some cases like when
Checks for consecutive `#start_with?` or `#end_with?` calls.

def autocorrect(corrector, first_call_args, second_call_args, combined_args) 

def autocorrect(corrector, first_call_args, second_call_args, combined_args)
  first_argument = first_call_args.first.source_range
  last_argument = second_call_args.last.source_range
  range = first_argument.join(last_argument)
  corrector.replace(range, combined_args)
end

def check(node, receiver, method, first_call_args, second_call_args) 

def check(node, receiver, method, first_call_args, second_call_args)
  return unless receiver && second_call_args.all?(&:pure?)
  combined_args = combine_args(first_call_args, second_call_args)
  add_offense(node, message: message(node, receiver, method, combined_args)) do |corrector|
    autocorrect(corrector, first_call_args, second_call_args, combined_args)
  end
end

def check_for_active_support_aliases? 

def check_for_active_support_aliases?
  cop_config['IncludeActiveSupportAliases']
end

def combine_args(first_call_args, second_call_args) 

def combine_args(first_call_args, second_call_args)
  (first_call_args + second_call_args).map(&:source).join(', ')
end

def message(node, receiver, method, combined_args) 

def message(node, receiver, method, combined_args)
  parent = receiver.parent
  grandparent = parent.parent
  dot = parent.send_type? ? '.' : '&.'
  bang = grandparent.send_type? && grandparent.prefix_bang? ? '!' : ''
  replacement = "#{bang}#{receiver.source}#{dot}#{method}(#{combined_args})"
  format(MSG, replacement: replacement, original_code: node.source)
end

def methods 

def methods
  if check_for_active_support_aliases?
    METHODS_WITH_ACTIVE_SUPPORT
  else
    METHODS
  end
end

def on_and(node) 

def on_and(node)
  two_start_end_with_calls_negated(node, methods_to_check: methods) do |*matched|
    check(node, *matched)
  end
end

def on_or(node) 

def on_or(node)
  two_start_end_with_calls(node, methods_to_check: methods) do |*matched|
    check(node, *matched)
  end
end