rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/style/case_equality.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for uses of the case equality operator(===).
       class CaseEquality < Cop
-        MSG = 'Avoid the use of the case equality operator `===`.'
+        MSG = 'Avoid the use of the case equality operator `===`.'.freeze
 
         def on_send(node)
           _receiver, method_name, *_args = *node

data/lib/rubocop/cop/style/case_indentation.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -64,7 +65,7 @@ module RuboCop
 
         def autocorrect(node)
           when_column = node.location.keyword.column
-          source_buffer = node.loc.expression.source_buffer
+          source_buffer = node.source_range.source_buffer
           begin_pos = node.loc.keyword.begin_pos
           whitespace = Parser::Source::Range.new(source_buffer,
                                                  begin_pos - when_column,

data/lib/rubocop/cop/style/character_literal.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,22 +8,25 @@ module RuboCop
       class CharacterLiteral < Cop
         include StringHelp
 
-        MSG = 'Do not use the character literal - use string literal instead.'
+        MSG = 'Do not use the character literal - ' \
+              'use string literal instead.'.freeze
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
           node.loc.begin.is?('?') &&
-            node.loc.expression.source.size.between?(2, 3)
+            node.source.size.between?(2, 3)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            string = node.loc.expression.source[1..-1]
+            string = node.source[1..-1]
 
-            if string.length == 1 # normal character
-              corrector.replace(node.loc.expression, "'#{string}'")
-            elsif string.length == 2 # special character like \n
-              corrector.replace(node.loc.expression, %("#{string}"))
+            # special character like \n
+            # or ' which needs to use "" or be escaped.
+            if string.length == 2 || string == "'"
+              corrector.replace(node.source_range, %("#{string}"))
+            elsif string.length == 1 # normal character
+              corrector.replace(node.source_range, "'#{string}'")
             end
           end
         end

data/lib/rubocop/cop/style/class_and_module_camel_case.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cops checks for class and module names with
       # an underscore in them.
       class ClassAndModuleCamelCase < Cop
-        MSG = 'Use CamelCase for classes and modules.'
+        MSG = 'Use CamelCase for classes and modules.'.freeze
 
         def on_class(node)
           check_name(node)

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -21,10 +22,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'
+                     'compact style.'.freeze
 
         COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'
+                      'nested style.'.freeze
 
         def on_class(node)
           _name, _superclass, body = *node

data/lib/rubocop/cop/style/class_check.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       class ClassCheck < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `Object#%s` over `Object#%s`.'
+        MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
 
         def on_send(node)
           _receiver, method_name, *_args = *node

data/lib/rubocop/cop/style/class_methods.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -21,7 +22,7 @@ module RuboCop
       #     end
       #   end
       class ClassMethods < Cop
-        MSG = 'Use `self.%s` instead of `%s.%s`.'
+        MSG = 'Use `self.%s` instead of `%s.%s`.'.freeze
 
         def on_class(node)
           name, _superclass, body = *node

data/lib/rubocop/cop/style/class_vars.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       # are signaled only on assignment to class variables to
       # reduced the number of offenses that would be reported.
       class ClassVars < Cop
-        MSG = 'Replace class var %s with a class instance var.'
+        MSG = 'Replace class var %s with a class instance var.'.freeze
 
         def on_cvasgn(node)
           add_offense(node, :name)

data/lib/rubocop/cop/style/closing_parenthesis_indentation.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -30,8 +31,8 @@ module RuboCop
         include OnMethodDef
 
         MSG_INDENT =
-          'Indent `)` the same as the start of the line where `(` is.'
-        MSG_ALIGN = 'Align `)` with `(`.'
+          'Indent `)` the same as the start of the line where `(` is.'.freeze
+        MSG_ALIGN = 'Align `)` with `(`.'.freeze
 
         def on_send(node)
           _receiver, _method_name, *args = *node

data/lib/rubocop/cop/style/collection_methods.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,7 +13,7 @@ module RuboCop
       class CollectionMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'
+        MSG = 'Prefer `%s` over `%s`.'.freeze
 
         def on_block(node)
           method, _args, _body = *node

data/lib/rubocop/cop/style/colon_method_call.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,10 +7,10 @@ module RuboCop
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
       class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'
+        MSG = 'Do not use `::` for method calls.'.freeze
 
         JAVA_TYPES = [:byte, :boolean, :byte, :short, :char,
-                      :int, :long, :float, :double]
+                      :int, :long, :float, :double].freeze
 
         JAVA_TYPE_NODES =
           JAVA_TYPES.map { |t| s(:send, s(:const, nil, :Java), t) }

data/lib/rubocop/cop/style/command_literal.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -29,8 +30,8 @@ module RuboCop
       class CommandLiteral < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_USE_BACKTICKS = 'Use backticks around command string.'
-        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
 
         def on_xstr(node)
           return if heredoc_literal?(node)
@@ -95,11 +96,11 @@ module RuboCop
         def autocorrect(node)
           return if contains_backtick?(node)
 
-          if backtick_literal?(node)
-            replacement = ['%x', ''].zip(preferred_delimiters).map(&:join)
-          else
-            replacement = %w(` `)
-          end
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w(` `)
+                        end
 
           lambda do |corrector|
             corrector.replace(node.loc.begin, replacement.first)

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,9 +11,9 @@ module RuboCop
 
         MSG = 'Annotation keywords like `%s` should be all upper case, ' \
               'followed by a colon, and a space, ' \
-              'then a note describing the problem.'
+              'then a note describing the problem.'.freeze
         MISSING_NOTE = 'Annotation comment, with keyword `%s`, ' \
-                       'is missing a note.'
+                       'is missing a note.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each_with_index do |comment, ix|

data/lib/rubocop/cop/style/comment_indentation.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       class CommentIndentation < Cop
         include AutocorrectAlignment
 
-        MSG = 'Incorrect indentation detected (column %d instead of %d).'
+        MSG = 'Incorrect indentation detected (column %d instead of %d).'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each { |comment| check(comment) }
@@ -51,14 +52,11 @@ module RuboCop
         end
 
         def less_indented?(line)
-          keyword = 'end\b'
-          bracket = '[}\]]'
-          line =~ /^\s*(#{keyword}|#{bracket})/
+          line =~ /^\s*(end\b|[\}\]])/
         end
 
         def two_alternatives?(line)
-          keyword = '(else|elsif|when|rescue|ensure)\b'
-          line =~ /^\s*#{keyword}/
+          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
         end
       end
     end

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -0,0 +1,362 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Helper module to provide common methods to classes needed for the
+      # ConditionalAssignment Cop.
+      module ConditionalAssignmentHelper
+        EQUAL = '='.freeze
+
+        # `elsif` branches show up in the `node` as an `else`. We need
+        # to recursively iterate over all `else` branches and consider all
+        # but the last `node` an `elsif` branch and consider the last `node`
+        # the actual `else` branch.
+        def expand_elses(branch)
+          elsif_branches = expand_elsif(branch)
+          else_branch = elsif_branches.any? ? elsif_branches.pop : branch
+          [elsif_branches, else_branch]
+        end
+
+        # `when` nodes contain the entire branch including the condition.
+        # We only need the contents of the branch, not the condition.
+        def expand_when_branches(when_branches)
+          when_branches.map { |branch| branch.children[1] }
+        end
+
+        def correct_branches(corrector, branches)
+          branches.each do |branch|
+            *_, assignment = *branch
+            corrector.replace(branch.source_range, assignment.source)
+          end
+        end
+
+        def tail(branch)
+          branch.begin_type? ? [*branch].last : branch
+        end
+
+        def lhs(node)
+          case node.type
+          when :send
+            lhs_for_send(node)
+          when :op_asgn
+            "#{node.children[0].source} #{node.children[1]}= "
+          when :and_asgn
+            "#{node.children[0].source} &&= "
+          when :or_asgn
+            "#{node.children[0].source} ||= "
+          when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
+            "#{node.children[0]} = "
+          else
+            node.source
+          end
+        end
+
+        private
+
+        def expand_elsif(node, elsif_branches = [])
+          return [] if node.nil? || !node.if_type?
+          _condition, elsif_branch, else_branch = *node
+          elsif_branches << elsif_branch
+          if else_branch && else_branch.if_type?
+            expand_elsif(else_branch, elsif_branches)
+          else
+            elsif_branches << else_branch
+          end
+          elsif_branches
+        end
+
+        def lhs_for_send(node)
+          receiver = node.receiver.nil? ? '' : node.receiver.source
+
+          if node.method_name == :[]=
+            indices = node.children[2...-1].map(&:source).join(', ')
+            "#{receiver}[#{indices}] = "
+          elsif node.method_name.to_s.end_with?(EQUAL) &&
+                ![:!=, :==].include?(node.method_name)
+            "#{receiver}.#{node.method_name[0...-1]} = "
+          else
+            "#{receiver} #{node.method_name} "
+          end
+        end
+      end
+
+      # Check for `if` and `case` statements where each branch is used for
+      # assignment to the same variable when using the return of the
+      # condition can be used instead.
+      #
+      # @example
+      #   # 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
+      class ConditionalAssignment < Cop
+        include IfNode
+        include ConditionalAssignmentHelper
+
+        MSG = 'Use the return of the conditional for variable assignment ' \
+              'and comparison.'.freeze
+        VARIABLE_ASSIGNMENT_TYPES =
+          [:casgn, :cvasgn, :gvasgn, :ivasgn, :lvasgn].freeze
+        ASSIGNMENT_TYPES =
+          VARIABLE_ASSIGNMENT_TYPES + [:and_asgn, :or_asgn, :op_asgn].freeze
+        IF = 'if'.freeze
+        UNLESS = 'unless'.freeze
+        LINE_LENGTH = 'Metrics/LineLength'.freeze
+        INDENTATION_WIDTH = 'Style/IndentationWidth'.freeze
+        ENABLED = 'Enabled'.freeze
+        MAX = 'Max'.freeze
+        SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'.freeze
+        WIDTH = 'Width'.freeze
+        METHODS = [:[]=, :<<, :=~, :!~, :<=>].freeze
+
+        def lhs_all_match?(branches)
+          first_lhs = lhs(branches.first)
+          branches.all? { |branch| lhs(branch) == first_lhs }
+        end
+
+        def on_if(node)
+          return if elsif?(node)
+
+          _condition, if_branch, else_branch = *node
+          elsif_branches, else_branch = expand_elses(else_branch)
+          return unless else_branch # empty else
+
+          branches = [if_branch, *elsif_branches, else_branch]
+
+          check_node(node, branches)
+        end
+
+        def on_case(node)
+          _condition, *when_branches, else_branch = *node
+          return unless else_branch # empty else
+
+          when_branches = expand_when_branches(when_branches)
+          branches = [*when_branches, else_branch]
+
+          check_node(node, branches)
+        end
+
+        def autocorrect(node)
+          if ternary_op?(node)
+            TernaryCorrector.correct(node)
+          else
+            case node.loc.keyword.source
+            when IF
+              IfCorrector.correct(node)
+            when UNLESS
+              UnlessCorrector.correct(node)
+            else
+              CaseCorrector.correct(node)
+            end
+          end
+        end
+
+        private
+
+        def assignment_types_match?(*nodes)
+          return unless assignment_type?(nodes.first)
+          first_type = nodes.first.type
+          nodes.all? { |node| node.type == first_type }
+        end
+
+        # The shovel operator `<<` does not have its own type. It is a `send`
+        # type.
+        def assignment_type?(branch)
+          return true if ASSIGNMENT_TYPES.include?(branch.type)
+
+          if branch.send_type?
+            _variable, method, = *branch
+            return true if METHODS.include?(method)
+            return true if method.to_s.end_with?(EQUAL)
+          end
+
+          false
+        end
+
+        def check_node(node, branches)
+          return unless branches.all?
+          last_statements = branches.map { |branch| tail(branch) }
+          return unless lhs_all_match?(last_statements)
+          return if last_statements.any?(&:masgn_type?)
+          return unless assignment_types_match?(*last_statements)
+
+          return if single_line_conditions_only? && branches.any?(&:begin_type?)
+          return if correction_exceeds_line_limit?(node, branches)
+
+          add_offense(node, :expression)
+        end
+
+        # If `Metrics/LineLength` is enabled, we do not want to introduce an
+        # offense by auto-correcting 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
+        def correction_exceeds_line_limit?(node, branches)
+          return false unless config.for_cop(LINE_LENGTH)[ENABLED]
+          assignment = lhs(tail(branches[0]))
+          assignment_regex = /#{assignment.gsub(' ', '\s*')}/
+          max_line_length = config.for_cop(LINE_LENGTH)[MAX]
+          indentation_width = config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
+          return true if longest_rhs(branches) + indentation_width +
+                         assignment.length > max_line_length
+          lines = node.source.lines.map do |line|
+            line.chomp.sub(assignment_regex, '')
+          end
+          longest_line = lines.max_by(&:length)
+          (longest_line + assignment).length > max_line_length
+        end
+
+        def longest_rhs(branches)
+          branches.map { |branch| branch.children.last.source.length }.max
+        end
+
+        def lines_with_numbers(node)
+          line_nos = node.loc.line..node.loc.last_line
+          node.source.lines.zip(line_nos)
+        end
+
+        def single_line_conditions_only?
+          cop_config[SINGLE_LINE_CONDITIONS_ONLY]
+        end
+      end
+
+      # Corrector to correct conditional assignment in ternary conditions.
+      class TernaryCorrector
+        class << self
+          include ConditionalAssignmentHelper
+
+          def correct(node)
+            condition, if_branch, else_branch = *node
+            _variable, *_operator, if_rhs = *if_branch
+            _else_variable, *_operator, else_rhs = *else_branch
+            condition = condition.source
+            if_rhs = if_rhs.source
+            else_rhs = else_rhs.source
+
+            ternary = "#{condition} ? #{if_rhs} : #{else_rhs}"
+            if if_branch.send_type? && if_branch.method_name != :[]=
+              ternary = "(#{ternary})"
+            end
+            correction = "#{lhs(if_branch)}#{ternary}"
+
+            lambda do |corrector|
+              corrector.replace(node.source_range, correction)
+            end
+          end
+        end
+      end
+
+      # Corrector to correct conditional assignment in `if` statements.
+      class IfCorrector
+        class << self
+          include ConditionalAssignmentHelper
+
+          def correct(node)
+            _condition, if_branch, else_branch = *node
+            if_branch = tail(if_branch)
+            _variable, *_operator, if_assignment = *if_branch
+            elsif_branches, else_branch = expand_elses(else_branch)
+            elsif_branches.map! { |branch| tail(branch) }
+            else_branch = tail(else_branch)
+            _else_variable, *_operator, else_assignment = *else_branch
+
+            lambda do |corrector|
+              corrector.insert_before(node.source_range, lhs(if_branch))
+              corrector.replace(if_branch.source_range, if_assignment.source)
+              correct_branches(corrector, elsif_branches)
+              corrector.replace(else_branch.source_range,
+                                else_assignment.source)
+            end
+          end
+        end
+      end
+
+      # Corrector to correct conditional assignment in `case` statements.
+      class CaseCorrector
+        class << self
+          include ConditionalAssignmentHelper
+
+          def correct(node)
+            _condition, *when_branches, else_branch = *node
+            else_branch = tail(else_branch)
+            when_branches = expand_when_branches(when_branches)
+            when_branches.map! { |when_branch| tail(when_branch) }
+            _variable, *_operator, else_assignment = *else_branch
+
+            lambda do |corrector|
+              corrector.insert_before(node.source_range, lhs(else_branch))
+              correct_branches(corrector, when_branches)
+              corrector.replace(else_branch.source_range,
+                                else_assignment.source)
+            end
+          end
+        end
+      end
+
+      # Corrector to correct conditional assignment in `unless` statements.
+      class UnlessCorrector
+        class << self
+          include ConditionalAssignmentHelper
+
+          def correct(node)
+            _condition, else_branch, if_branch = *node
+            if_branch = tail(if_branch)
+            else_branch = tail(else_branch)
+            _variable, *_operator, if_assignment = *if_branch
+            _else_variable, *_operator, else_assignment = *else_branch
+
+            lambda do |corrector|
+              corrector.insert_before(node.source_range, lhs(if_branch))
+              corrector.replace(if_branch.source_range, if_assignment.source)
+              corrector.replace(else_branch.source_range,
+                                else_assignment.source)
+            end
+          end
+        end
+      end
+    end
+  end
+end