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::ReparsedEquivalence, ::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

Checks 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

::RuboCop::Cop::ReparsedEquivalence - Included

MAX_VERIFICATION_FRAGMENT_SIZE

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

Reserved for Commissioner.

::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, #project_index, #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?,
#skipped_unsafe_correction_with_disable_uncorrectable?

Whether a correction exists but is skipped because it is unsafe in a safe autocorrect run, while --disable-uncorrectable asks for a todo comment on everything this run cannot correct.

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::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

rubocop:disable-next Metrics.
#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

::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, #covering_disabled_range, #current_corrector,
#current_offense_locations

Reserved for Commissioner:
#current_offenses, #currently_disabled_lines, #custom_severity, #default_severity, #disable_uncorrectable, #enabled_line?,
#enabled_lines?

A multi-line offense is suppressed by a directive on any line of its range, not only its first line, matching the intuition that the directive is attached to the offending code.
#file_name_matches_any?, #find_message, #find_severity, #matches_absolute_include_pattern?, #range_for_original, #range_from_node_or_range,
#reset_investigation

Actually private methods.
#suppression_reason

The -- reason on the directive that suppresses offenses on this range, or nil when the directive carries none.
#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, #eol_comment, #eol_comment_would_be_inside_literal?, #heredoc_range, #line_with_eol_comment_too_long?, #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, #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 443



def include_ternary?
  cop_config['IncludeTernaryExpressions']
end


  








  

    #single_line_conditions_only?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


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



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 310



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


  








  

    #allowed_statements?(branches)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


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



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 306



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


  








  

    #apply_reparse_correction(corrector, node)   (private)
  



  

    


ReparsedEquivalence#correction_parses? contract: apply the exact
correction this cop would perform.



  



  [ GitHub ]


  

  


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



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


  








  

    #assignment_node(node)   (private)
  

  [ GitHub ]


  

  


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



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

  # 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 219



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 377



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 304



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 299



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 277



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

  # Use the node accessor rather than the raw destructured branch: for
  # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
  # else slot, but `else_branch` correctly reports there is no `else` clause.
  return unless assignment.else_branch
  return if allowed_single_line?([*branches, else_branch])
  return unless safe_to_correct?(node)

  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)
  return unless safe_to_correct?(node)

  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 420



def correction_exceeds_line_limit?(node, branches)
  return false unless config.cop_enabled?('Layout/LineLength')

  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 432



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 428



def longest_line_exceeds_line_limit?(node, assignment)
  longest_line(node, assignment).length > max_line_length
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.type?(:case, :case_match)
    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.type?(:case, :case_match)
    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 255



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 265



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 241



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 235



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

  check_assignment_to_condition(node)
end


  








  

    #safe_to_correct?(node)  ⇒ Boolean  (private)
  



  

    


The correction rewrites the conditional structurally, so full AST
equivalence cannot be asserted, but the result must at least reparse
to valid Ruby. Applying the correction to a throwaway buffer here
also exercises the branch-shape handling before an offense is even
reported, so unusual branches that the corrector cannot handle are
left alone instead of crashing or emitting invalid code - the bug
class behind most of this cop’s history.



  





  


  [ GitHub ]


  

  


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



def safe_to_correct?(node)
  correction_parses?(node)
rescue StandardError
  false
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