123456789_123456789_123456789_123456789_123456789_

Class: RuboCop::Cop::Style::ConditionalAssignment

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::RuboCop::Cop::AutoCorrector, ::RuboCop::Cop::Base, ::RuboCop::ExcludeLimit, NodePattern::Macros, RuboCop::AST::Sexp
Instance Chain:
self, ::RuboCop::Cop::ConfigurableEnforcedStyle, ConditionalAssignmentHelper, ::RuboCop::Cop::Base, ::RuboCop::Cop::AutocorrectLogic, ::RuboCop::Cop::IgnoredNode, ::RuboCop::Util, RuboCop::AST::Sexp
Inherits: RuboCop::Cop::Base
Defined in: lib/rubocop/cop/style/conditional_assignment.rb

Overview

Check for if and case statements where each branch is used for both the assignment and comparison of the same variable when using the return of the condition can be used instead.

Examples:

EnforcedStyle: assign_to_condition (default)

# bad
if foo
  bar = 1
else
  bar = 2
end

case foo
when 'a'
  bar += 1
else
  bar += 2
end

if foo
  some_method
  bar = 1
else
  some_other_method
  bar = 2
end

# good
bar = if foo
        1
      else
        2
      end

bar += case foo
       when 'a'
         1
       else
         2
       end

bar << if foo
         some_method
         1
       else
         some_other_method
         2
       end

EnforcedStyle: assign_inside_condition

# bad
bar = if foo
        1
      else
        2
      end

bar += case foo
       when 'a'
         1
       else
         2
       end

bar << if foo
         some_method
         1
       else
         some_other_method
         2
       end

# good
if foo
  bar = 1
else
  bar = 2
end

case foo
when 'a'
  bar += 1
else
  bar += 2
end

if foo
  some_method
  bar = 1
else
  some_other_method
  bar = 2
end

Constant Summary

::RuboCop::Cop::Base - Inherited

EMPTY_OFFENSES, RESTRICT_ON_SEND

ConditionalAssignmentHelper - Included

ALIGN_WITH, END_ALIGNMENT, EQUAL, KEYWORD

::RuboCop::Cop::ConfigurableEnforcedStyle - Included

SYMBOL_TO_STRING_CACHE

Class Attribute Summary

::RuboCop::Cop::AutoCorrector - Extended

support_autocorrect?

::RuboCop::Cop::Base - Inherited

.gem_requirements, .lint?,
.support_autocorrect?

Returns if class supports autocorrect.
.support_multiple_source?

Override if your cop should be called repeatedly for multiple investigations Between calls to on_new_investigation and on_investigation_end, the result of processed_source will remain constant.

Class Method Summary

::RuboCop::Cop::Base - Inherited

.autocorrect_incompatible_with

List of cops that should not try to autocorrect at the same time as this cop.
.badge

Naming.
.callbacks_needed, .cop_name, .department,
.documentation_url

Returns a url to view this cops documentation online.
.exclude_from_registry

Call for abstract Cop classes.
.inherited,
.joining_forces

Override and return the Force class(es) you need to join.
.match?

Returns true if the cop name or the cop namespace matches any of the given names.
.new,
.requires_gem

Register a version requirement for the given gem name.
.restrict_on_send

::RuboCop::ExcludeLimit - Extended

exclude_limit

Sets up a configuration option to have an exclude limit tracked.
transform

Instance Attribute Summary

::RuboCop::Cop::ConfigurableEnforcedStyle - Included

#detected_style, #detected_style=, #no_acceptable_style?, #style_configured?

::RuboCop::Cop::Base - Inherited

#active_support_extensions_enabled?, #always_autocorrect?, #config, #config_to_allow_offenses, #config_to_allow_offenses=, #contextual_autocorrect?, #processed_source, #string_literals_frozen_by_default?, #target_satisfies_all_gem_version_requirements?

::RuboCop::Cop::AutocorrectLogic - Included

#autocorrect?, #autocorrect_enabled?, #autocorrect_requested?, #autocorrect_with_disable_uncorrectable?, #correctable?, #disable_uncorrectable?, #safe_autocorrect?

Instance Method Summary

::RuboCop::Cop::ConfigurableEnforcedStyle - Included

#alternative_style, #alternative_styles, #ambiguous_style_detected,
#conflicting_styles_detected

Alias for ConfigurableEnforcedStyle#no_acceptable_style!.
#correct_style_detected, #no_acceptable_style!, #opposite_style_detected, #style, #style_detected, #style_parameter_name, #supported_styles, #unexpected_style_detected,
#unrecognized_style_detected

Alias for ConfigurableEnforcedStyle#no_acceptable_style!.

ConditionalAssignmentHelper - Included

#end_with_eq?,
#expand_elses

elsif branches show up in the node as an else.
#expand_when_branches

when nodes contain the entire branch including the condition.
#indent, #lhs, #tail, #assignment_rhs_exist?, #expand_elsif, #lhs_for_casgn, #lhs_for_send, #setter_method?

::RuboCop::Cop::Base - Inherited

#add_global_offense

Adds an offense that has no particular location.
#add_offense

Adds an offense on the specified range (or node with an expression) Unless that offense is disabled for this range, a corrector will be yielded to provide the cop the opportunity to autocorrect the offense.
#begin_investigation

Called before any investigation.
#callbacks_needed,
#cop_config

Configuration Helpers.
#cop_name, #excluded_file?,
#external_dependency_checksum

This method should be overridden when a cop’s behavior depends on state that lives outside of these locations:
#inspect,
#message

Gets called if no message is specified when calling add_offense or add_global_offense Cops are discouraged to override this; instead pass your message directly.
#name

Alias for Base#cop_name.
#offenses,
#on_investigation_end

Called after all on_…​
#on_new_investigation

Called before all on_…​
#on_other_file

Called instead of all on_…​
#parse

There should be very limited reasons for a Cop to do it’s own parsing.
#parser_engine,
#ready

Called between investigations.
#relevant_file?,
#target_gem_version

Returns a gems locked versions (i.e.
#target_rails_version, #target_ruby_version, #annotate, #apply_correction, #attempt_correction,
#callback_argument

Reserved for Cop::Cop.
#complete_investigation

Called to complete an investigation.
#correct, #current_corrector,
#current_offense_locations

Reserved for Commissioner:
#current_offenses, #currently_disabled_lines, #custom_severity, #default_severity, #disable_uncorrectable, #enabled_line?, #file_name_matches_any?, #find_message, #find_severity, #range_for_original, #range_from_node_or_range,
#reset_investigation

Actually private methods.
#use_corrector

::RuboCop::Cop::AutocorrectLogic - Included

#disable_offense, #disable_offense_at_end_of_line, #disable_offense_before_and_after, #disable_offense_with_eol_or_surround_comment, #heredoc_range, #max_line_length, #multiline_ranges, #multiline_string?,
#range_by_lines

Expand the given range to include all of any lines it covers.
#range_of_first_line, #range_overlaps_offense?, #string_continuation?, #surrounding_heredoc?, #surrounding_percent_array?

::RuboCop::Cop::IgnoredNode - Included

#ignore_node, #ignored_node?, #part_of_ignored_node?, #ignored_nodes

Constructor Details

This class inherits a constructor from RuboCop::Cop::Base

Instance Attribute Details

#include_ternary? ⇒ Boolean (readonly, private)

[ GitHub ] 

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 431



def include_ternary?
  cop_config['IncludeTernaryExpressions']
end


  








  

    #line_length_cop_enabled?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 419



def line_length_cop_enabled?
  config.for_cop(LINE_LENGTH)[ENABLED]
end


  








  

    #single_line_conditions_only?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 427



def single_line_conditions_only?
  cop_config[SINGLE_LINE_CONDITIONS_ONLY]
end


  







Instance Method Details



  

    #allowed_single_line?(branches)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 311



def allowed_single_line?(branches)
  single_line_conditions_only? && branches.any?(&:begin_type?)
end


  








  

    #allowed_statements?(branches)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 384



def allowed_statements?(branches)
  return false unless branches.all?

  statements = branches.filter_map { |branch| tail(branch) }

  lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
    assignment_types_match?(*statements)
end


  








  

    #allowed_ternary?(assignment)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 307



def allowed_ternary?(assignment)
  assignment.if_type? && assignment.ternary? && !include_ternary?
end


  








  

    #assignment_node(node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 315



def assignment_node(node)
  assignment = node.send_type? ? node.last_argument : node.expression

  # ignore pseudo-assignments without rhs in for nodes
  return if node.parent&.for_type?

  if assignment.begin_type? && assignment.children.one?
    assignment = assignment.children.first
  end

  assignment
end


  








  

    #assignment_type?(node)  
  



  

    


The shovel operator << does not have its own type. It is a send
type.



  



  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 224



def_node_matcher :assignment_type?, <<~PATTERN
  {
    #{ASSIGNMENT_TYPES.join(' ')}
    (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq? :< :>} ...)
  }
PATTERN


  








  

    #assignment_types_match?(*nodes)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 361



def assignment_types_match?(*nodes)
  return false unless assignment_type?(nodes.first)

  nodes.map(&:type).uniq.one?
end


  








  

    #autocorrect(corrector, node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 376



def autocorrect(corrector, node)
  if assignment_type?(node)
    move_assignment_inside_condition(corrector, node)
  else
    move_assignment_outside_condition(corrector, node)
  end
end


  








  

    #candidate_condition?(node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 305



def_node_matcher :candidate_condition?, '[{if case case_match} !#allowed_ternary?]'


  








  

    #candidate_node?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 300



def candidate_node?(node)
  style == :assign_inside_condition && assignment_rhs_exist?(node)
end


  








  

    #check_assignment_to_condition(node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 282



def check_assignment_to_condition(node)
  return unless candidate_node?(node)

  ignore_node(node)

  assignment = assignment_node(node)
  return unless candidate_condition?(assignment)

  _condition, *branches, else_branch = *assignment

  return unless else_branch
  return if allowed_single_line?([*branches, else_branch])

  add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
    autocorrect(corrector, node)
  end
end


  








  

    #check_node(node, branches)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 367



def check_node(node, branches)
  return if allowed_ternary?(node)
  return unless allowed_statements?(branches)
  return if allowed_single_line?(branches)
  return if correction_exceeds_line_limit?(node, branches)

  add_offense(node) { |corrector| autocorrect(corrector, node) }
end


  








  

    #correction_exceeds_line_limit?(node, branches)  ⇒ Boolean  (private)
  



  

    


If Layout/LineLength is enabled, we do not want to introduce an
offense by autocorrecting this cop. Find the max configured line
length. Find the longest line of condition. Remove the assignment
from lines that contain the offending assignment because after
correcting, this will not be on the line anymore. Check if the length
of the longest line + the length of the corrected assignment is
greater than the max configured line length



  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 400



def correction_exceeds_line_limit?(node, branches)
  return false unless line_length_cop_enabled?

  assignment = lhs(tail(branches[0]))

  longest_line_exceeds_line_limit?(node, assignment)
end


  








  

    #lhs_all_match?(branches)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 354



def lhs_all_match?(branches)
  return true if branches.empty?

  first_lhs = lhs(branches.first)
  branches.all? { |branch| lhs(branch) == first_lhs }
end


  








  

    #longest_line(node, assignment)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 412



def longest_line(node, assignment)
  assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
  lines = node.source.lines.map { |line| line.chomp.sub(assignment_regex, '') }
  longest_line = lines.max_by(&:length)
  assignment + longest_line
end


  








  

    #longest_line_exceeds_line_limit?(node, assignment)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 408



def longest_line_exceeds_line_limit?(node, assignment)
  longest_line(node, assignment).length > max_line_length
end


  








  

    #max_line_length   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 423



def max_line_length
  config.for_cop(LINE_LENGTH)[MAX]
end


  








  

    #move_assignment_inside_condition(corrector, node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 338



def move_assignment_inside_condition(corrector, node)
  condition = node.send_type? ? node.last_argument : node.expression

  if ternary_condition?(condition)
    TernaryCorrector.move_assignment_inside_condition(corrector, node)
  elsif condition.case_type? || condition.case_match_type?
    CaseCorrector.move_assignment_inside_condition(corrector, node)
  elsif condition.if_type?
    IfCorrector.move_assignment_inside_condition(corrector, node)
  end
end


  








  

    #move_assignment_outside_condition(corrector, node)   (private)
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 328



def move_assignment_outside_condition(corrector, node)
  if node.case_type? || node.case_match_type?
    CaseCorrector.correct(corrector, self, node)
  elsif node.ternary?
    TernaryCorrector.correct(corrector, node)
  elsif node.if? || node.unless?
    IfCorrector.correct(corrector, self, node)
  end
end


  








  

    #on_case(node)  
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 260



def on_case(node)
  return unless style == :assign_to_condition
  return unless node.else_branch

  when_branches = expand_when_branches(node.when_branches)
  branches = [*when_branches, node.else_branch]

  check_node(node, branches)
end


  








  

    #on_case_match(node)  
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 270



def on_case_match(node)
  return unless style == :assign_to_condition
  return unless node.else_branch

  in_pattern_branches = expand_when_branches(node.in_pattern_branches)
  branches = [*in_pattern_branches, node.else_branch]

  check_node(node, branches)
end


  








  

    #on_if(node)  
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 246



def on_if(node)
  return unless style == :assign_to_condition
  return if node.elsif?

  else_branch = node.else_branch
  elsif_branches, else_branch = expand_elses(else_branch)

  return unless else_branch

  branches = [node.if_branch, *elsif_branches, else_branch]

  check_node(node, branches)
end


  








  

    #on_send(node)  
  

  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 240



def on_send(node)
  return unless assignment_type?(node)

  check_assignment_to_condition(node)
end


  








  

    #ternary_condition?(node)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/rubocop/cop/style/conditional_assignment.rb', line 350



def ternary_condition?(node)
  [node, node.children.first].compact.any? { |n| n.if_type? && n.ternary? }
end