rubocop 0.49.1 → 0.52.0

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

@@ -9,8 +9,9 @@ module RuboCop
         MSG = 'Indentation of first line in file detected.'.freeze
 
         def investigate(_processed_source)
-          token = first_token
-          space_before(token) { |space| add_offense(space, token.pos) }
+          space_before(first_token) do |space|
+            add_offense(space, location: first_token.pos)
+          end
         end
 
         def autocorrect(range)
@@ -25,16 +26,18 @@ module RuboCop
 
         def space_before(token)
           return unless token
-          return if token.pos.column.zero?
+          return if token.column.zero?
 
-          token_with_space =
-            range_with_surrounding_space(token.pos, :left, false)
+          space_range =
+            range_with_surrounding_space(range: token.pos,
+                                         side: :left,
+                                         newlines: false)
           # If the file starts with a byte order mark (BOM), the column can be
           # non-zero, but then we find out here if there's no space to the left
           # of the first token.
-          return if token_with_space == token.pos
+          return if space_range == token.pos
 
-          yield range_between(token_with_space.begin_pos, token.pos.begin_pos)
+          yield range_between(space_range.begin_pos, token.begin_pos)
         end
       end
     end

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

@@ -3,39 +3,54 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether comments have a leading space
-      # after the # denoting the start of the comment. The
-      # leading space is not required for some RDoc special syntax,
-      # like #++, #--, #:nodoc, etc. Neither is it required for
-      # =begin/=end comments.
+      # This cop checks whether comments have a leading space after the
+      # `#` denoting the start of the comment. The leading space is not
+      # required for some RDoc special syntax, like `#++`, `#--`,
+      # `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
+      # or rackup options.
+      #
+      # @example
+      #
+      #   # bad
+      #   #Some comment
+      #
+      #   # good
+      #   # Some comment
       class LeadingCommentSpace < Cop
-        MSG = 'Missing space after #.'.freeze
+        MSG = 'Missing space after `#`.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             next unless comment.text =~ /\A#+[^#\s=:+-]/
-            next if comment.text.start_with?('#!') && comment.loc.line == 1
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
 
-            # in config.ru files, if the first line starts with #\ it is treated
-            # as options (e.g. `#\ -p 8765` sets the request port to 8765)
-            next if comment.text.start_with?('#\\') && comment.loc.line == 1 &&
-                    config_ru?(processed_source.buffer.name)
-
-            add_offense(comment, :expression)
+            add_offense(comment)
           end
         end
 
         def autocorrect(comment)
           expr = comment.loc.expression
-          b = expr.begin_pos
-          hash_mark = range_between(b, b + 1)
+          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+
           ->(corrector) { corrector.insert_after(hash_mark, ' ') }
         end
 
         private
 
-        def config_ru?(file_path)
-          File.basename(file_path).eql?('config.ru')
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def rackup_options?(comment)
+          comment.text.start_with?('#\\')
+        end
+
+        def rackup_config_file?
+          File.basename(processed_source.buffer.name).eql?('config.ru')
         end
       end
     end

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

@@ -26,35 +26,68 @@ module RuboCop
       # The closing brace of a multi-line array literal must be on the same
       # line as the last element of the array.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
       #     [ :a,
+      #       :b ]
+      #
+      #     # good
+      #     [
+      #       :a,
       #       :b
       #     ]
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     [
       #       :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     [ :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # good
       #     [
       #       :a,
       #       :b
       #     ]
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
       class MultilineArrayBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
@@ -70,7 +103,7 @@ module RuboCop
           'after the last array element.'.freeze
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
-          'line as teh last array element.'.freeze
+          'line as the last array element.'.freeze
 
         def on_array(node)
           check_brace_layout(node)

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

@@ -6,30 +6,31 @@ module RuboCop
       # This cop checks whether the multiline assignments have a newline
       # after the assignment operator.
       #
-      # @example
-      #   # bad (with EnforcedStyle set to new_line)
+      # @example EnforcedStyle: new_line (default)
+      #   # bad
       #   foo = if expression
       #     'bar'
       #   end
       #
-      #   # good (with EnforcedStyle set to same_line)
-      #   foo = if expression
-      #     'bar'
-      #   end
-      #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     if expression
       #       'bar'
       #     end
       #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     begin
       #       compute
       #     rescue => e
       #       nil
       #     end
+      #
+      # @example EnforcedStyle: same_line
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
       class MultilineAssignmentLayout < Cop
         include CheckAssignment
         include ConfigurableEnforcedStyle
@@ -56,13 +57,13 @@ module RuboCop
         def check_new_line_offense(node, rhs)
           return unless node.loc.operator.line == rhs.loc.line
 
-          add_offense(node, :expression, NEW_LINE_OFFENSE)
+          add_offense(node, message: NEW_LINE_OFFENSE)
         end
 
         def check_same_line_offense(node, rhs)
           return unless node.loc.operator.line != rhs.loc.line
 
-          add_offense(node, :expression, SAME_LINE_OFFENSE)
+          add_offense(node, message: SAME_LINE_OFFENSE)
         end
 
         def autocorrect(node)

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

@@ -53,20 +53,6 @@ module RuboCop
           add_offense_for_expression(node, node.body, MSG)
         end
 
-        private
-
-        def args_on_beginning_line?(node)
-          !node.arguments? ||
-            node.loc.begin.line == node.arguments.loc.last_line
-        end
-
-        def add_offense_for_expression(node, expr, msg)
-          expression = expr.source_range
-          range = range_between(expression.begin_pos, expression.end_pos)
-
-          add_offense(node, range, msg)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             unless args_on_beginning_line?(node)
@@ -84,9 +70,26 @@ module RuboCop
           end
         end
 
+        private
+
+        def args_on_beginning_line?(node)
+          !node.arguments? ||
+            node.loc.begin.line == node.arguments.loc.last_line
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.source_range
+          range = range_between(expression.begin_pos, expression.end_pos)
+
+          add_offense(node, location: range, message: msg)
+        end
+
         def autocorrect_arguments(corrector, node)
-          end_pos = range_with_surrounding_space(node.arguments.source_range,
-                                                 :right, false).end_pos
+          end_pos = range_with_surrounding_space(
+            range: node.arguments.source_range,
+            side: :right,
+            newlines: false
+          ).end_pos
           range = range_between(node.loc.begin.end.begin_pos, end_pos)
           corrector.replace(range, " |#{block_arg_string(node.arguments)}|")
         end

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

@@ -26,35 +26,68 @@ module RuboCop
       # The closing brace of a multi-line hash literal must be on the same
       # line as the last element of the hash.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # bad
       #     { a: 1,
       #       b: 2
       #     }
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     {
       #       a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     { a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
       #     {
       #       a: 1,
       #       b: 2
       #     }
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
       class MultilineHashBraceLayout < Cop
         include MultilineLiteralBraceLayout
 

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

@@ -6,34 +6,34 @@ module RuboCop
       # This cop checks the indentation of the method name part in method calls
       # that span more than one line.
       #
-      # @example
+      # @example EnforcedStyle: aligned
       #   # bad
       #   while myvariable
       #   .b
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle: aligned
+      #   # good
       #   while myvariable
       #         .b
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle: aligned
+      #   # good
       #   Thing.a
       #        .b
       #        .c
       #
-      #   # good, EnforcedStyle:    indented,
-      #           IndentationWidth: 2
+      # @example EnforcedStyle: indented
+      #   # good
       #   while myvariable
       #     .b
       #
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle:    indented_relative_to_receiver,
-      #           IndentationWidth: 2
+      # @example EnforcedStyle: indented_relative_to_receiver
+      #   # good
       #   while myvariable
       #           .a
       #           .b
@@ -41,8 +41,7 @@ module RuboCop
       #     # do something
       #   end
       #
-      #   # good, EnforcedStyle:    indented_relative_to_receiver,
-      #           IndentationWidth: 2
+      #   # good
       #   myvariable = Thing
       #                  .a
       #                  .b
@@ -144,25 +143,21 @@ module RuboCop
         def syntactic_alignment_base(lhs, rhs)
           # a if b
           #      .c
-          n = kw_node_with_special_indentation(lhs)
-          if n
-            case n.type
-            when :for            then _, expression, = *n
-            when :return         then expression, = *n
-            when *MODIFIER_NODES then expression, = *n
-            end
-            return expression.source_range
+          kw_node_with_special_indentation(lhs) do |base|
+            return indented_keyword_expression(base).source_range
           end
 
           # a = b
           #     .c
-          n = part_of_assignment_rhs(lhs, rhs)
-          return assignment_rhs(n).source_range if n
+          part_of_assignment_rhs(lhs, rhs) do |base|
+            return assignment_rhs(base).source_range
+          end
 
           # a + b
           #     .c
-          n = operation_rhs(lhs)
-          return n.source_range if n
+          operation_rhs(lhs) do |base|
+            return base.source_range
+          end
         end
 
         # a.b
@@ -171,7 +166,7 @@ module RuboCop
           return unless rhs.source.start_with?('.')
 
           node = semantic_alignment_node(node)
-          return unless node
+          return unless node && node.loc.selector
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -202,12 +197,19 @@ module RuboCop
 
         def operation_rhs(node)
           receiver, = *node
-          receiver.each_ancestor(:send) do |a|
-            _, method, args = *a
-            return args if operator?(method) && args &&
-                           within_node?(receiver, args)
+
+          operation_rhs = receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, receiver)
           end
-          nil
+
+          return unless operation_rhs
+
+          yield operation_rhs.first_argument
+        end
+
+        def operator_rhs?(node, receiver)
+          node.operator_method? && node.arguments? &&
+            within_node?(receiver, node.first_argument)
         end
       end
     end