rubocop 0.40.0 → 0.41.0

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

@@ -98,18 +98,13 @@ module RuboCop
         end
 
         def nil_check(node, else_clause)
-          return unless else_clause && else_clause.type == :nil
-          add_offense(node, node.location, MSG)
+          return unless else_clause && else_clause.nil_type?
+          add_offense(node, :else, MSG)
         end
 
         def both_check(node, else_clause)
-          return if node.loc.else.nil?
-
-          if else_clause.nil?
-            add_offense(node, :else, MSG)
-          elsif else_clause.type == :nil
-            add_offense(node, :else, MSG)
-          end
+          empty_check(node, else_clause)
+          nil_check(node, else_clause)
         end
 
         def autocorrect(node)
@@ -119,8 +114,9 @@ module RuboCop
             end_pos = if node.loc.end
                         node.loc.end.begin_pos
                       else
-                        node.source_range.end_pos + 1
+                        node.parent.loc.end.begin_pos
                       end
+
             range = Parser::Source::Range.new(node.source_range.source_buffer,
                                               node.loc.else.begin_pos,
                                               end_pos)

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

@@ -27,8 +27,15 @@ module RuboCop
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
 
         def investigate(processed_source)
+          return if processed_source.ast.nil?
+
           if force_equal_sign_alignment?
             @asgn_tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+            # we don't want to operate on equals signs which are part of an
+            #   optarg in a method definition
+            # e.g.: def method(optarg = default_val); end
+            @asgn_tokens = remove_optarg_equals(@asgn_tokens, processed_source)
+
             # Only attempt to align the first = on each line
             @asgn_tokens = Set.new(@asgn_tokens.uniq { |t| t.pos.line })
             @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
@@ -94,13 +101,13 @@ module RuboCop
 
         def check_other(t1, t2, ast)
           return if t1.pos.line != t2.pos.line
-          return if t2.pos.begin_pos - 1 <= t1.pos.end_pos
           return if allow_for_alignment? && aligned_tok?(t2)
 
           start_pos = t1.pos.end_pos
-          return if ignored_ranges(ast).find { |r| r.include?(start_pos) }
-
           end_pos = t2.pos.begin_pos - 1
+          return if end_pos <= start_pos
+          return if ignored_range?(ast, start_pos)
+
           range = Parser::Source::Range.new(processed_source.buffer,
                                             start_pos, end_pos)
           # Unary + doesn't appear as a token and needs special handling.
@@ -117,6 +124,10 @@ module RuboCop
           end
         end
 
+        def ignored_range?(ast, start_pos)
+          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
+        end
+
         def unary_plus_non_offense?(range)
           range.resize(range.size + 1).source =~ /^ ?\+$/
         end
@@ -201,6 +212,12 @@ module RuboCop
           spaces  = leading.size - (leading =~ / *\Z/)
           asgn_token.pos.last_column - spaces + 1
         end
+
+        def remove_optarg_equals(asgn_tokens, processed_source)
+          optargs    = processed_source.ast.each_node(:optarg)
+          optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+          asgn_tokens.reject { |t| optarg_eql.include?(t.pos.begin_pos) }
+        end
       end
     end
   end

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

@@ -125,11 +125,23 @@ module RuboCop
           # We can't assume that the working directory, or any other, is the
           # "starting point" to build a namespace
           start = %w(lib spec test src)
-          if components.find { |c| start.include?(c) }
-            components = components.drop_while { |c| !start.include?(c) }
-            components.drop(1).map { |fn| to_module_name(fn) }
-          else
+          start_index = nil
+
+          # To find the closest namespace root take the path components, and
+          # then work through them backwards until we find a candidate. This
+          # makes sure we work from the actual root in the case of a path like
+          # /home/user/src/project_name/lib.
+          components.reverse.each_with_index do |c, i|
+            if start.include?(c)
+              start_index = components.size - i
+              break
+            end
+          end
+
+          if start_index.nil?
             [to_module_name(components.last)]
+          else
+            components[start_index..-1].map { |c| to_module_name(c) }
           end
         end
 

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

@@ -18,7 +18,7 @@ module RuboCop
 
         def investigate(processed_source)
           return if style == :when_needed && target_ruby_version < 2.3
-          return if processed_source.buffer.source.empty?
+          return if processed_source.tokens.empty?
 
           return if frozen_string_literal_comment_exists?(processed_source)
 

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

@@ -96,12 +96,19 @@ module RuboCop
 
           return false unless key.sym_type?
 
-          valid_19_syntax_symbol?(key.source)
+          acceptable_19_syntax_symbol?(key.source)
         end
 
-        def valid_19_syntax_symbol?(sym_name)
+        def acceptable_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
 
+          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
+            # Prefer { :production? => false } over { production?: false } and
+            # similarly for other non-alnum final characters (except quotes,
+            # to prefer { "x y": 1 } over { :"x y" => 1 }).
+            return false unless sym_name =~ /[\p{Alnum}"']\z/
+          end
+
           # Most hash keys can be matched against a simple regex.
           return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
 

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

@@ -52,19 +52,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          cond, body, _else = if_node_parts(node)
-
-          oneline =
-            "#{body.source} #{node.loc.keyword.source} " + cond.source
-          first_line_comment = processed_source.comments.find do |c|
-            c.loc.line == node.loc.line
-          end
-          if first_line_comment
-            oneline << ' ' << first_line_comment.loc.expression.source
-          end
-          oneline = "(#{oneline})" if parenthesize?(node)
-
-          ->(corrector) { corrector.replace(node.source_range, oneline) }
+          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
         end
 
         private
@@ -73,6 +61,25 @@ module RuboCop
         def nested_conditional?(node)
           node.children[1, 2].any? { |child| child && child.type == :if }
         end
+
+        def oneline(node)
+          cond, body, _else = if_node_parts(node)
+
+          expr = "#{body.source} #{node.loc.keyword.source} " + cond.source
+          if (comment_after = first_line_comment(node))
+            expr << ' ' << comment_after
+          end
+          expr = "(#{expr})" if parenthesize?(node)
+
+          expr
+        end
+
+        def first_line_comment(node)
+          comment =
+            processed_source.comments.find { |c| c.loc.line == node.loc.line }
+
+          comment ? comment.loc.expression.source : nil
+        end
       end
     end
   end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for `raise` or `fail` statements which do not specify an
+      # explicit exception class. (This raises a `RuntimeError`. Some projects
+      # might prefer to use exception classes which more precisely identify the
+      # nature of the error.)
+      #
+      # @example
+      #   @bad
+      #   raise 'Error message here'
+      #
+      #   @good
+      #   raise ArgumentError, 'Error message here'
+      class ImplicitRuntimeError < Cop
+        def_node_matcher :implicit_runtime_error_raise_or_fail,
+                         '(send nil ${:raise :fail} {str dstr})'
+
+        def on_send(node)
+          implicit_runtime_error_raise_or_fail(node) do |method|
+            add_offense(node, :expression, "Use `#{method}` with an explicit " \
+                                           'exception class and message, ' \
+                                           'rather than just a message.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,6 @@ module RuboCop
 
         def on_while(node)
           condition, = *node
-
           return unless condition.truthy_literal?
 
           add_offense(node, :keyword)
@@ -29,13 +28,49 @@ module RuboCop
 
         def on_until(node)
           condition, = *node
-
           return unless condition.falsey_literal?
 
           add_offense(node, :keyword)
         end
 
+        alias on_while_post on_while
+        alias on_until_post on_until
+
         def autocorrect(node)
+          if node.while_post_type? || node.until_post_type?
+            _, body = *node
+            return lambda do |corrector|
+              corrector.replace(body.loc.begin, 'loop do')
+              corrector.remove(body.loc.end.end.join(node.source_range.end))
+            end
+          end
+
+          if node.modifier_form?
+            range = node.source_range
+            replacement = modifier_replacement(node)
+          else
+            range = non_modifier_range(node)
+            replacement = 'loop do'
+          end
+
+          ->(corrector) { corrector.replace(range, replacement) }
+        end
+
+        private
+
+        def modifier_replacement(node)
+          _, body = *node
+          if node.single_line?
+            'loop { ' + body.source + ' }'
+          else
+            indentation = body.loc.expression.source_line[/\A(\s*)/]
+            "loop do\n" + indentation +
+              body.source.gsub(/^/, ' ' * configured_indentation_width) +
+              "\n#{indentation}end"
+          end
+        end
+
+        def non_modifier_range(node)
           condition_node, = *node
           start_range = node.loc.keyword.begin
           end_range = if node.loc.begin
@@ -43,9 +78,11 @@ module RuboCop
                       else
                         condition_node.source_range.end
                       end
-          lambda do |corrector|
-            corrector.replace(start_range.join(end_range), 'loop do')
-          end
+          start_range.join(end_range)
+        end
+
+        def configured_indentation_width
+          config.for_cop('IndentationWidth')['Width']
         end
       end
     end

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

@@ -137,6 +137,10 @@ module RuboCop
 
         def autocorrect_literal_to_method(corrector, node)
           block_method, args = *node
+
+          # Check for unparenthesized args' preceding and trailing whitespaces.
+          remove_unparenthesized_whitespaces(corrector, node)
+
           # Avoid correcting to `lambdado` by inserting whitespace
           # if none exists before or after the lambda arguments.
           if needs_whitespace?(block_method, args, node)
@@ -181,6 +185,24 @@ module RuboCop
           index = parent.children.index { |c| c.equal?(node) }
           index >= 2
         end
+
+        def remove_unparenthesized_whitespaces(corrector, node)
+          block_method, args = *node
+          return unless unparenthesized_literal_args?(args)
+          # First, remove leading whitespaces (beetween arrow and args)
+          corrector.remove_preceding(
+            args.source_range,
+            args.source_range.begin_pos - block_method.source_range.end_pos
+          )
+
+          # Then, remove trailing whitespaces (beetween args and 'do')
+          delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
+          corrector.remove_preceding(node.loc.begin, delta)
+        end
+
+        def unparenthesized_literal_args?(args)
+          args.source_range && args.source_range.begin && !parentheses?(args)
+        end
       end
     end
   end

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

@@ -11,10 +11,8 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_method_def(node, _method_name, args, _body)
-          if style == :require_parentheses ||
-             (style == :require_no_parentheses_except_multiline &&
-              args.multiline?)
-            if arguments?(args) && !parentheses?(args)
+          if require_parentheses?(args)
+            if arguments_without_parentheses?(args)
               missing_parentheses(node, args)
             else
               correct_style_detected
@@ -46,6 +44,16 @@ module RuboCop
 
         private
 
+        def require_parentheses?(args)
+          style == :require_parentheses ||
+            (style == :require_no_parentheses_except_multiline &&
+             args.multiline?)
+        end
+
+        def arguments_without_parentheses?(args)
+          arguments?(args) && !parentheses?(args)
+        end
+
         def missing_parentheses(node, args)
           add_offense(node, args.source_range,
                       'Use def with parentheses when there are parameters.') do

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

@@ -4,26 +4,48 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks for use of `extend self` in a module.
+      # This cops checks for use of `extend self` or `module_function` in a
+      # module.
+      #
+      # Supported styles are: module_function, extend_self.
       #
       # @example
       #
+      #   # Good if EnforcedStyle is module_function
       #   module Test
-      #     extend self
+      #     module_function
+      #     ...
+      #   end
       #
+      #   # Good if EnforcedStyle is extend_self
+      #   module Test
+      #     extend self
       #     ...
-      # end
+      #   end
+      #
+      # These offenses are not auto-corrected since there are different
+      # implications to each approach.
       class ModuleFunction < Cop
-        MSG = 'Use `module_function` instead of `extend self`.'.freeze
+        include ConfigurableEnforcedStyle
+
+        MODULE_FUNCTION_MSG = 'Use `module_function` instead of `extend self`.'
+                              .freeze
+        EXTEND_SELF_MSG = 'Use `extend self` instead of `module_function`.'
+                          .freeze
 
-        TARGET_NODE = s(:send, nil, :extend, s(:self))
+        MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
+        EXTEND_SELF_NODE = s(:send, nil, :extend, s(:self))
 
         def on_module(node)
           _name, body = *node
           return unless body && body.type == :begin
 
           body.children.each do |body_node|
-            add_offense(body_node, :expression) if body_node == TARGET_NODE
+            if style == :module_function && body_node == EXTEND_SELF_NODE
+              add_offense(body_node, :expression, MODULE_FUNCTION_MSG)
+            elsif style == :extend_self && body_node == MODULE_FUNCTION_NODE
+              add_offense(body_node, :expression, EXTEND_SELF_MSG)
+            end
           end
         end
       end

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

@@ -57,7 +57,7 @@ module RuboCop
 
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column
+                             @base.column + extra_indentation(given_style)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
@@ -65,20 +65,39 @@ module RuboCop
           rhs if @column_delta != 0
         end
 
+        def extra_indentation(given_style)
+          if given_style == :indented_relative_to_receiver
+            configured_indentation_width
+          else
+            0
+          end
+        end
+
         def message(node, lhs, rhs)
-          what = operation_description(node, rhs)
           if @base
-            "Align `#{rhs.source}` with `#{@base.source[/[^\n]*/]}` on " \
+            base_source = @base.source[/[^\n]*/]
+            if style == :indented_relative_to_receiver
+              "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+              "more than `#{base_source}` on line #{@base.line}."
+            else
+              "Align `#{rhs.source}` with `#{base_source}` on " \
               "line #{@base.line}."
+            end
           else
             used_indentation = rhs.column - indentation(lhs)
+            what = operation_description(node, rhs)
             "Use #{correct_indentation(node)} (not #{used_indentation}) " \
               "spaces for indenting #{what} spanning multiple lines."
           end
         end
 
         def alignment_base(node, rhs, given_style)
-          return nil unless given_style == :aligned
+          return nil if given_style == :indented
+
+          if given_style == :indented_relative_to_receiver
+            receiver_base = receiver_alignment_base(node)
+            return receiver_base if receiver_base
+          end
 
           semantic_alignment_base(node, rhs) ||
             syntactic_alignment_base(node, rhs)
@@ -111,17 +130,35 @@ module RuboCop
         # a.b
         #  .c
         def semantic_alignment_base(node, rhs)
-          return nil unless rhs.source.start_with?('.')
-          return nil if argument_in_method_call(node)
+          return unless rhs.source.start_with?('.')
+
+          node = semantic_alignment_node(node)
+          return unless node
+
+          node.loc.dot.join(node.loc.selector)
+        end
+
+        # a
+        #   .b
+        #   .c
+        def receiver_alignment_base(node)
+          node = semantic_alignment_node(node)
+          return unless node
+
+          node.receiver.source_range
+        end
 
-          node, = *node while node.send_type? && node.loc.dot ||
-                              node.block_type?
-          return nil unless node.parent.send_type?
+        def semantic_alignment_node(node)
+          return if argument_in_method_call(node)
 
-          first_send = node.parent
-          return nil if first_send.loc.dot.line != first_send.loc.line
+          # descend to root of method chain
+          node = node.receiver while node.receiver
+          # ascend to first call which has a dot
+          node = node.parent
+          node = node.parent until node.loc.dot
 
-          first_send.loc.dot.join(first_send.loc.selector)
+          return if node.loc.dot.line != node.loc.line
+          node
         end
 
         def operation_rhs(node)