123456789_123456789_123456789_123456789_123456789_

Module: RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
::RuboCop::Cop::Style::MethodCallWithArgsParentheses
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, ::RuboCop::Cop::ReparsedEquivalence, ::RuboCop::Cop::RangeHelp
Defined in: lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

Overview

Style omit_parentheses Metrics/CyclomaticComplexity

Constant Summary

::RuboCop::Cop::RangeHelp - Included

BYTE_ORDER_MARK, NOT_GIVEN

::RuboCop::Cop::ReparsedEquivalence - Included

MAX_VERIFICATION_FRAGMENT_SIZE

Instance Method Summary

::RuboCop::Cop::ReparsedEquivalence - Included

#corrected_scope_fragment

The corrections' edits are all contained within the scope, so the corrected fragment can be cut out of the corrected source by adjusting for the edits' length delta.
#correction_parses?

Whether the exact correction for item produces source that still parses, without requiring an equivalent AST.
#corrections_verify?, #item_range,
#normalize_reparsed_ast

Hook: loosen strict tree equality for corrections that are equivalence-preserving beyond parse identity.
#normalized_original,
#parses_equivalently?

Both sides are parsed with the original path so that FILE resolves identically.
#preprocess_reparsed_source

Hook: rewrite both sides before parsing.
#reparse_scope

The innermost scope that both contains range and parses standalone.
#scope_groups, #verification_too_large?,
#verified_by_reparse

Returns the items whose corrections are verified.

::RuboCop::Cop::RangeHelp - Included

#add_range,
#arguments_range

A range containing the first to the last argument of a method call or method definition.
#column_offset_between,
#contents_range

A range containing only the contents of a literal with delimiters (e.g.
#directions,
#effective_column

Returns the column attribute of the range, except if the range is on the first line and there’s a byte order mark at the beginning of that line, in which case 1 is subtracted from the column value.
#final_pos, #move_pos, #move_pos_str, #range_between, #range_by_whole_lines, #range_with_comments, #range_with_comments_and_lines, #range_with_surrounding_comma, #range_with_surrounding_space, #source_range

Instance Method Details

#allowed_camel_case_method_call?(node) ⇒ Boolean (private)

[ GitHub ] 

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 97



def allowed_camel_case_method_call?(node)
  node.camel_case_method? &&
    (node.arguments.none? || cop_config['AllowParenthesesInCamelCaseMethod'])
end


  








  

    #allowed_chained_call_with_parentheses?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 208



def allowed_chained_call_with_parentheses?(node)
  return false unless cop_config['AllowParenthesesInChaining']

  previous = node.descendants.first
  return false unless previous&.send_type?

  previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
end


  








  

    #allowed_multiline_call_with_parentheses?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 204



def allowed_multiline_call_with_parentheses?(node)
  cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
end


  








  

    #allowed_string_interpolation_method_call?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 102



def allowed_string_interpolation_method_call?(node)
  cop_config['AllowParenthesesInStringInterpolation'] &&
    inside_string_interpolation?(node)
end


  








  

    #ambiguous_literal?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 217



def ambiguous_literal?(node)
  splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
end


  








  

    #ambiguous_range_argument?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 197



def ambiguous_range_argument?(node)
  return true if (first_arg = node.first_argument)&.range_type? && first_arg.begin.nil?
  return true if (last_arg = node.last_argument)&.range_type? && last_arg.end.nil?

  false
end


  








  

    #apply_reparse_correction(corrector, node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 47



def apply_reparse_correction(corrector, node)
  autocorrect(corrector, node)
end


  








  

    #assigned_before?(node, target)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 247



def assigned_before?(node, target)
  node.assignment? && node.loc.operator.begin < target.loc.begin
end


  








  

    #assignment_in_condition?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 255



def assignment_in_condition?(node)
  parent = node.parent
  return false unless parent

  grandparent = parent.parent
  return false unless grandparent

  parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
end


  








  

    #autocorrect(corrector, node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 51



def autocorrect(corrector, node)
  range = args_begin(node)
  if parentheses_at_the_end_of_multiline_call?(node)
    # Whitespace after line continuation (`\ `) is a syntax error
    with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
    corrector.replace(with_whitespace, ' \\')
  else
    corrector.replace(range, ' ')
  end
  corrector.remove(node.loc.end)
end


  








  

    #call_as_argument_or_chain?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 179



def call_as_argument_or_chain?(node)
  node.parent&.type?(:call, :super, :yield) &&
    !assigned_before?(node.parent, node)
end


  








  

    #call_in_argument_with_block?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 172



def call_in_argument_with_block?(node)
  parent = node.parent&.any_block_type? && node.parent.parent
  return false unless parent

  parent.type?(:call, :super, :yield)
end


  








  

    #call_in_literals?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 127



def call_in_literals?(node)
  parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
  return false unless parent

  parent.type?(:pair, :array, :range) ||
    splat?(parent) ||
    ternary_if?(parent)
end


  








  

    #call_in_logical_operators?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 136



def call_in_logical_operators?(node)
  parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
  return false unless parent

  logical_operator?(parent) ||
    (parent.send_type? &&
    parent.arguments.any? { |argument| logical_operator?(argument) })
end


  








  

    #call_in_match_pattern?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 184



def call_in_match_pattern?(node)
  return false unless (parent = node.parent)

  parent.any_match_pattern_type?
end


  








  

    #call_in_optional_arguments?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 145



def call_in_optional_arguments?(node)
  node.parent&.type?(:optarg, :kwoptarg)
end


  








  

    #call_in_single_line_inheritance?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 149



def call_in_single_line_inheritance?(node)
  node.parent&.class_type? && node.parent.single_line?
end


  








  

    #call_with_ambiguous_arguments?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 154



def call_with_ambiguous_arguments?(node)
  call_with_braced_block?(node) ||
    call_in_argument_with_block?(node) ||
    call_as_argument_or_chain?(node) ||
    call_in_match_pattern?(node) ||
    hash_literal_in_arguments?(node) ||
    ambiguous_range_argument?(node) ||
    node.descendants.any? do |n|
      n.type?(:forwarded_args, :any_block) ||
        ambiguous_literal?(n) || logical_operator?(n)
    end
end


  








  

    #call_with_braced_block?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 168



def call_with_braced_block?(node)
  node.type?(:call, :super) && node.block_node&.braces?
end


  








  

    #forwards_anonymous_rest_arguments?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 265



def forwards_anonymous_rest_arguments?(node)
  return false unless (last_argument = node.last_argument)
  return true if last_argument.forwarded_restarg_type?

  last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
end


  








  

    #hash_literal?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 233



def hash_literal?(node)
  node.hash_type? && node.braces?
end


  








  

    #hash_literal_in_arguments?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 190



def hash_literal_in_arguments?(node)
  node.arguments.any? do |n|
    hash_literal?(n) ||
      (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
  end
end


  








  

    #inside_endless_method_def?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 67



def inside_endless_method_def?(node)
  # parens are required around arguments inside an endless method
  node.each_ancestor(:any_def).any?(&:endless?) && node.arguments.any?
end


  








  

    #inside_string_interpolation?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 251



def inside_string_interpolation?(node)
  node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
end


  








  

    #last_expression?(node)  ⇒ Boolean  (private)
  



  

    


Require hash value omission be enclosed in parentheses to prevent the following issue:
https://bugs.ruby-lang.org/issues/18396.



  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 81



def last_expression?(node)
  !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
end


  








  

    #legitimate_call_with_parentheses?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 114



def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
  call_in_literals?(node) ||
    node.parent&.when_type? ||
    call_with_ambiguous_arguments?(node) ||
    call_in_logical_operators?(node) ||
    call_in_optional_arguments?(node) ||
    call_in_single_line_inheritance?(node) ||
    allowed_multiline_call_with_parentheses?(node) ||
    allowed_chained_call_with_parentheses?(node) ||
    assignment_in_condition?(node) ||
    forwards_anonymous_rest_arguments?(node)
end


  








  

    #logical_operator?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 229



def logical_operator?(node)
  node.operator_keyword? && node.logical_operator?
end


  








  

    #method_call_before_constant_resolution?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 89



def method_call_before_constant_resolution?(node)
  node.parent&.const_type?
end


  








  

    #offense_range(node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 63



def offense_range(node)
  node.loc.begin.join(node.loc.end)
end


  








  

    #omit_parentheses(node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 33



def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
  return unless node.parenthesized?
  return if inside_endless_method_def?(node)
  return if require_parentheses_for_hash_value_omission?(node)
  return if syntax_like_method_call?(node)
  return if method_call_before_constant_resolution?(node)
  return if super_call_without_arguments?(node)
  return if legitimate_call_with_parentheses?(node)
  return if allowed_camel_case_method_call?(node)
  return if allowed_string_interpolation_method_call?(node)

  (@pending_omit_offenses ||= []) << node
end


  








  

    #on_investigation_end  
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 17



def on_investigation_end
  # Each candidate's exact correction is verified by reparsing before
  # the offense is registered, so an omission that would change how
  # the code parses is never reported or offered.
  verified_by_reparse(@pending_omit_offenses || []).each do |node|
    add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
      autocorrect(corrector, node)
    end
  end
  @pending_omit_offenses = []

  super
end


  








  

    #parentheses_at_the_end_of_multiline_call?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 107



def parentheses_at_the_end_of_multiline_call?(node)
  node.multiline? &&
    node.loc.begin.source_line
        .gsub(TRAILING_WHITESPACE_REGEX, '')
        .end_with?('(')
end


  








  

    #regexp_slash_literal?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 237



def regexp_slash_literal?(node)
  node.regexp_type? && node.loc.begin.source == '/'
end


  








  

    #require_parentheses_for_hash_value_omission?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 72



def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
  return false unless (last_argument = node.last_argument)
  return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?

  node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
end


  








  

    #splat?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 221



def splat?(node)
  node.type?(:splat, :kwsplat, :block_pass)
end


  








  

    #super_call_without_arguments?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 93



def super_call_without_arguments?(node)
  node.super_type? && node.arguments.none?
end


  








  

    #syntax_like_method_call?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 85



def syntax_like_method_call?(node)
  node.implicit_call? || node.operator_method?
end


  








  

    #ternary_if?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 225



def ternary_if?(node)
  node.if_type? && node.ternary?
end


  








  

    #unary_literal?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb', line 241



def unary_literal?(node)
  return true if node.numeric_type? && node.sign?

  node.parent&.send_type? && node.parent.unary_operation?
end