rubocop 1.6.1 → 1.7.0

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -76,6 +76,14 @@ module RuboCop
       #
       #   def b
       #   end
+      #
+      # @example AllowAdjacentOneLineDefs: true
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector
@@ -113,8 +121,8 @@ module RuboCop
 
         def autocorrect(corrector, prev_def, node)
           # finds position of first newline
-          end_pos = prev_def.loc.end.end_pos
-          source_buffer = prev_def.loc.end.source_buffer
+          end_pos = end_loc(prev_def).end_pos
+          source_buffer = end_loc(prev_def).source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
 
           # Handle the case when multiple one-liners are on the same line.
@@ -198,7 +206,15 @@ module RuboCop
         end
 
         def def_end(node)
-          node.loc.end.line
+          end_loc(node).line
+        end
+
+        def end_loc(node)
+          if node.def_type? && node.endless?
+            node.loc.expression.end
+          else
+            node.loc.end
+          end
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -70,6 +70,7 @@ module RuboCop
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
           return if subsequent_closing_parentheses_in_same_line?(outermost_send)
+          return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
           add_offense(outermost_send.loc.end) do |corrector|
             autocorrect(corrector, outermost_send)
@@ -215,6 +216,19 @@ module RuboCop
           end
         end
 
+        def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
+
+          heredoc_end < node.loc.end.begin_pos &&
+            range_between(heredoc_end, node.loc.end.begin_pos).source.strip != ''
+        end
+
+        def find_most_bottom_of_heredoc_end(arguments)
+          arguments.map do |argument|
+            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+          end.compact.max
+        end
+
         # Internal trailing comma helpers.
 
         def remove_internal_trailing_comma(node, corrector)

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -191,16 +191,9 @@ module RuboCop
         end
 
         def begin_end_alignment_style
-          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
-          #        When RuboCop 1.0 is released, please replace it with the following condition.
-          #
-          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          if config.for_all_cops['NewCops'] == 'enable' ||
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
-            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          end
+          begin_end_alignment_conf = config.for_cop('Layout/BeginEndAlignment')
+
+          begin_end_alignment_conf['Enabled'] && begin_end_alignment_conf['EnforcedStyleAlignWith']
         end
       end
     end

data/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -60,6 +60,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
+            opposite_style_detected
           end
         end
 

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -106,6 +106,7 @@ module RuboCop
         def space_missing(left_brace)
           add_offense(left_brace, message: MISSING_MSG) do |corrector|
             autocorrect(corrector, left_brace)
+            opposite_style_detected
           end
         end
 
@@ -114,6 +115,7 @@ module RuboCop
 
           add_offense(space, message: DETECTED_MSG) do |corrector|
             autocorrect(corrector, space)
+            opposite_style_detected
           end
         end
 

data/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for space between the name of a receiver and a left
+      # brackets.
+      #
+      # This cop is marked as unsafe because it can occur false positives
+      # for `do_something [this_is_an_array_literal_argument]` that take
+      # an array without parentheses as an argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection [index_or_key]
+      #
+      #   # good
+      #   collection[index_or_key]
+      #
+      class SpaceBeforeBrackets < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the space before the opening brackets.'
+
+        def on_send(node)
+          return if node.parenthesized? || node.parent&.send_type?
+          return unless (first_argument = node.first_argument)
+
+          begin_pos = first_argument.source_range.begin_pos
+
+          return unless (range = offense_range(node, first_argument, begin_pos))
+
+          register_offense(range)
+        end
+
+        private
+
+        def offense_range(node, first_argument, begin_pos)
+          if space_before_brackets?(node, first_argument)
+            range_between(node.loc.selector.end_pos, begin_pos)
+          elsif node.method?(:[]=)
+            end_pos = node.receiver.source_range.end_pos
+
+            return if begin_pos - end_pos == 1
+
+            range_between(end_pos, begin_pos - 1)
+          end
+        end
+
+        def register_offense(range)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def space_before_brackets?(node, first_argument)
+          node.receiver.nil? && first_argument.array_type? && node.arguments.size == 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -111,7 +111,8 @@ module RuboCop
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
-                      'Space inside empty braces detected.')
+                      'Space inside empty braces detected.',
+                      'EnforcedStyleForEmptyBraces')
             end
           end
         end
@@ -120,7 +121,8 @@ module RuboCop
           return if style_for_empty_braces != :space
 
           offense(left_brace.begin_pos, right_brace.end_pos,
-                  'Space missing inside empty braces.')
+                  'Space missing inside empty braces.',
+                  'EnforcedStyleForEmptyBraces')
         end
 
         def braces_with_contents_inside(node, inner)
@@ -164,9 +166,9 @@ module RuboCop
             if left_brace.end_pos == args_delimiter.begin_pos &&
                cop_config['SpaceBeforeBlockParameters']
               offense(left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.') do
-                opposite_style_detected
-              end
+                      'Space between { and | missing.')
+            else
+              correct_style_detected
             end
           else
             # We indicate the position after the left brace. Otherwise it's
@@ -179,11 +181,11 @@ module RuboCop
 
         def space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
-            unless cop_config['SpaceBeforeBlockParameters']
+            if cop_config['SpaceBeforeBlockParameters']
+              correct_style_detected
+            else
               offense(left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.') do
-                opposite_style_detected
-              end
+                      'Space between { and | detected.')
             end
           else
             brace_with_space = range_with_surrounding_space(range: left_brace,
@@ -220,7 +222,7 @@ module RuboCop
           end
         end
 
-        def offense(begin_pos, end_pos, msg)
+        def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|
             case range.source
@@ -229,6 +231,7 @@ module RuboCop
             when '{|' then corrector.replace(range, '{ |')
             else           corrector.insert_before(range, ' ')
             end
+            opposite_style_detected if style_param == 'EnforcedStyle'
           end
         end
 

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -112,13 +112,13 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          return unless ambiguous_or_unexpected_style_detected(style, token1.text == token2.text)
-
           brace = (token1.text == '{' ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
+          detected_style = expect_space ? 'no_space' : 'space'
 
           add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
             autocorrect(corrector, range)
+            ambiguous_or_unexpected_style_detected(detected_style, token1.text == token2.text)
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_assignment.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for mistyped shorthand assignments.
+      #
+      # @example
+      #   # bad
+      #   x =- y
+      #   x =+ y
+      #   x =* y
+      #   x =! y
+      #
+      #   # good
+      #   x -= y # or x = -y
+      #   x += y # or x = +y
+      #   x *= y # or x = *y
+      #   x != y # or x = !y
+      #
+      class AmbiguousAssignment < Base
+        include RangeHelp
+
+        MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
+
+        MISTAKES = {
+          '=-' => '-=',
+          '=+' => '+=',
+          '=*' => '*=',
+          '=!' => '!='
+        }.freeze
+
+        def on_asgn(node)
+          return unless (rhs = rhs(node))
+
+          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+          source = range.source
+          return unless MISTAKES.key?(source)
+
+          add_offense(range, message: format(MSG, op: MISTAKES[source]))
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def rhs(node)
+          if node.casgn_type?
+            node.children[2]
+          else
+            node.children[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -17,6 +17,7 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   x / x
       #   x.top >= x.top
       #
       #   if a.x != 0 && a.x != 0
@@ -27,15 +28,19 @@ module RuboCop
       #     left_child || left_child
       #   end
       #
+      #   # good
+      #   x + x
+      #   1 << 1
+      #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        MATH_OPERATORS = %i[+ - * / % ** << >> | ^].to_set.freeze
+        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
 
         def on_send(node)
           return unless node.binary_operation?
 
           lhs, operation, rhs = *node
-          return if MATH_OPERATORS.include?(node.method_name) && lhs.basic_literal?
+          return if ALLOWED_MATH_OPERATORS.include?(node.method_name)
 
           add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
         end

data/lib/rubocop/cop/lint/duplicate_branch.rb

@@ -6,6 +6,15 @@ module RuboCop
       # This cop checks that there are no repeated bodies
       # within `if/unless`, `case-when` and `rescue` constructs.
       #
+      # With `IgnoreLiteralBranches: true`, branches are not registered
+      # as offenses if they return a basic literal value (string, symbol,
+      # integer, float, rational, complex, `true`, `false`, or `nil`), or
+      # return an array, hash, regexp or range that only contains one of
+      # the above basic literal values.
+      #
+      # With `IgnoreConstantBranches: true`, branches are not registered
+      # as offenses if they return a constant value.
+      #
       # @example
       #   # bad
       #   if foo
@@ -56,14 +65,33 @@ module RuboCop
       #     handle_error
       #   end
       #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then 100
+      #   when "medium" then 250
+      #   when "large" then 1000
+      #   else 250
+      #   end
+      #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then SMALL_SIZE
+      #   when "medium" then MEDIUM_SIZE
+      #   when "large" then LARGE_SIZE
+      #   else MEDIUM_SIZE
+      #   end
+      #
       class DuplicateBranch < Base
         include RescueNode
 
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)
-          branches = node.branches.compact
-          branches.each_with_object(Set.new) do |branch, previous|
+          branches(node).each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branch)
+
             add_offense(offense_range(branch)) unless previous.add?(branch)
           end
         end
@@ -87,6 +115,40 @@ module RuboCop
             parent.source_range
           end
         end
+
+        def branches(node)
+          node.branches.compact
+        end
+
+        def consider_branch?(branch)
+          return false if ignore_literal_branches? && literal_branch?(branch)
+          return false if ignore_constant_branches? && const_branch?(branch)
+
+          true
+        end
+
+        def ignore_literal_branches?
+          cop_config.fetch('IgnoreLiteralBranches', false)
+        end
+
+        def ignore_constant_branches?
+          cop_config.fetch('IgnoreConstantBranches', false)
+        end
+
+        def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if !branch.literal? || branch.xstr_type?
+          return true if branch.basic_literal?
+
+          branch.each_descendant.all? do |node|
+            node.basic_literal? ||
+              node.pair_type? || # hash keys and values are contained within a `pair` node
+              (node.const_type? && ignore_constant_branches?)
+          end
+        end
+
+        def const_branch?(branch)
+          branch.const_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -8,47 +8,66 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   a = *[1, 2, 3]
       #   a = *'a'
       #   a = *1
-      #
-      #   begin
-      #     foo
-      #   rescue *[StandardError, ApplicationError]
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      #
-      # @example
+      #   ['a', 'b', *%w(c d e), 'f', 'g']
       #
       #   # good
-      #
       #   c = [1, 2, 3]
       #   a = *c
       #   a, b = *c
       #   a, *b = *c
       #   a = *1..10
       #   a = ['a']
+      #   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
       #
+      #   # bad
+      #   do_something(*['foo', 'bar', 'baz'])
+      #
+      #   # good
+      #   do_something('foo', 'bar', 'baz')
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   # good
       #   begin
       #     foo
       #   rescue StandardError, ApplicationError
       #     bar
       #   end
       #
+      #   # bad
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
       #   case foo
       #   when 1, 2, 3
       #     bar
       #   else
       #     baz
       #   end
+      #
+      # @example AllowPercentLiteralArrayArgument: true (default)
+      #
+      #   # good
+      #   do_something(*%w[foo bar baz])
+      #
+      # @example AllowPercentLiteralArrayArgument: false
+      #
+      #   # bad
+      #   do_something(*%w[foo bar baz])
+      #
       class RedundantSplatExpansion < Base
         extend AutoCorrector
 
@@ -75,6 +94,9 @@ module RuboCop
           redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
+              return if allow_percent_literal_array_argument? &&
+                        use_percent_literal_array_argument?(node)
+
               add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
                 autocorrect(corrector, node)
               end
@@ -170,6 +192,17 @@ module RuboCop
             elements.join(', ')
           end
         end
+
+        def use_percent_literal_array_argument?(node)
+          argument = node.children.first
+
+          node.parent.send_type? &&
+            (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
+        end
+
+        def allow_percent_literal_array_argument?
+          cop_config.fetch('AllowPercentLiteralArrayArgument', true)
+        end
       end
     end
   end