rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/space_around_keyword.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks the spacing around the keywords.
       #
       # @example
@@ -26,22 +25,22 @@ module RuboCop
       #
       #   something = 123 if test
       class SpaceAroundKeyword < Cop
-        MSG_BEFORE = 'Space before keyword `%s` is missing.'.freeze
-        MSG_AFTER = 'Space after keyword `%s` is missing.'.freeze
+        MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'.freeze
+        MSG_AFTER = 'Space after keyword `%<range>s` is missing.'.freeze
 
         DO = 'do'.freeze
         SAFE_NAVIGATION = '&.'.freeze
         ACCEPT_LEFT_PAREN =
-          %w(break defined? next not rescue return super yield).freeze
+          %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
-          %w(super yield).freeze
+          %w[super yield].freeze
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
         end
 
         def on_block(node)
-          check(node, [:begin, :end].freeze)
+          check(node, %i[begin end].freeze)
         end
 
         def on_break(node)
@@ -49,7 +48,7 @@ module RuboCop
         end
 
         def on_case(node)
-          check(node, [:keyword, :else].freeze)
+          check(node, %i[keyword else].freeze)
         end
 
         def on_ensure(node)
@@ -57,15 +56,15 @@ module RuboCop
         end
 
         def on_for(node)
-          check(node, [:begin, :end].freeze)
+          check(node, %i[begin end].freeze)
         end
 
         def on_if(node)
-          check(node, [:keyword, :else, :begin, :end].freeze, 'then'.freeze)
+          check(node, %i[keyword else begin end].freeze, 'then'.freeze)
         end
 
         def on_kwbegin(node)
-          check(node, [:begin, :end].freeze, nil)
+          check(node, %i[begin end].freeze, nil)
         end
 
         def on_next(node)
@@ -109,7 +108,7 @@ module RuboCop
         end
 
         def on_until(node)
-          check(node, [:begin, :end, :keyword].freeze)
+          check(node, %i[begin end keyword].freeze)
         end
 
         def on_when(node)
@@ -117,7 +116,7 @@ module RuboCop
         end
 
         def on_while(node)
-          check(node, [:begin, :end, :keyword].freeze)
+          check(node, %i[begin end keyword].freeze)
         end
 
         def on_yield(node)
@@ -128,6 +127,14 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
+        def autocorrect(range)
+          if space_before_missing?(range)
+            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
+          else
+            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
+          end
+        end
+
         private
 
         def check(node, locations, begin_keyword = DO)
@@ -167,7 +174,9 @@ module RuboCop
         end
 
         def offense(range, msg)
-          add_offense(range, range, msg % range.source)
+          add_offense(range,
+                      location: range,
+                      message: format(msg, range: range.source))
         end
 
         def space_before_missing?(range)
@@ -179,16 +188,20 @@ module RuboCop
         def space_after_missing?(range)
           pos = range.end_pos
           char = range.source_buffer.source[pos]
-          return false unless char
-          return false if accept_left_parenthesis?(range) &&
-                          char == '('.freeze
-          return false if accept_left_square_bracket?(range) &&
-                          char == '['.freeze
+
+          return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
 
+        def accepted_opening_delimiter?(range, char)
+          return true unless char
+
+          accept_left_square_bracket?(range) && char == '[' ||
+            accept_left_parenthesis?(range) && char == '('
+        end
+
         def accept_left_parenthesis?(range)
           ACCEPT_LEFT_PAREN.include?(range.source)
         end
@@ -204,22 +217,13 @@ module RuboCop
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
-          while (ancestor = node.parent)
+          node.each_ancestor do |ancestor|
             return true if ancestor.and_type? || ancestor.or_type?
             return false unless ancestor.send_type?
             return true if operator?(ancestor.method_name)
-            node = ancestor
           end
           false
         end
-
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
-          else
-            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that operators have space around them, except for **
+      # which should not have surrounding space.
+      #
+      # @example
+      #   # bad
+      #   total = 3*4
+      #   "apple"+"juice"
+      #   my_number = 38/4
+      #   a ** b
+      #
+      #   # good
+      #   total = 3 * 4
+      #   "apple" + "juice"
+      #   my_number = 38 / 4
+      #   a**b
+      class SpaceAroundOperators < Cop
+        include PrecedingFollowingAlignment
+
+        IRREGULAR_METHODS = %i[[] ! []=].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::SelfAssignment]
+        end
+
+        def on_pair(node)
+          return unless node.hash_rocket?
+
+          return if hash_table_style? && !node.parent.pairs_on_same_line?
+
+          check_operator(node.loc.operator, node.source_range)
+        end
+
+        def on_if(node)
+          return unless node.ternary?
+
+          check_operator(node.loc.question, node.if_branch.source_range)
+          check_operator(node.loc.colon, node.else_branch.source_range)
+        end
+
+        def on_resbody(node)
+          return unless node.loc.assoc
+
+          _, variable, = *node
+
+          check_operator(node.loc.assoc, variable.source_range)
+        end
+
+        def on_send(node)
+          if node.setter_method?
+            on_special_asgn(node)
+          elsif regular_operator?(node)
+            check_operator(node.loc.selector, node.first_argument.source_range)
+          end
+        end
+
+        def on_binary(node)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(node.loc.operator, rhs.source_range)
+        end
+
+        def on_special_asgn(node)
+          _, _, right, = *node
+
+          return unless right
+          check_operator(node.loc.operator, right.source_range)
+        end
+
+        alias on_or       on_binary
+        alias on_and      on_binary
+        alias on_lvasgn   on_binary
+        alias on_masgn    on_binary
+        alias on_casgn    on_special_asgn
+        alias on_ivasgn   on_binary
+        alias on_cvasgn   on_binary
+        alias on_gvasgn   on_binary
+        alias on_class    on_binary
+        alias on_or_asgn  on_binary
+        alias on_and_asgn on_binary
+        alias on_op_asgn  on_special_asgn
+
+        def autocorrect(range)
+          lambda do |corrector|
+            if range.source =~ /\*\*/
+              corrector.replace(range, '**')
+            elsif range.source.end_with?("\n")
+              corrector.replace(range, " #{range.source.strip}\n")
+            else
+              corrector.replace(range, " #{range.source.strip} ")
+            end
+          end
+        end
+
+        private
+
+        def regular_operator?(send_node)
+          !send_node.unary_operation? && !send_node.dot? &&
+            operator_with_regular_syntax?(send_node)
+        end
+
+        def operator_with_regular_syntax?(send_node)
+          send_node.operator_method? &&
+            !IRREGULAR_METHODS.include?(send_node.method_name)
+        end
+
+        def check_operator(op, right_operand)
+          with_space = range_with_surrounding_space(range: op)
+          return if with_space.source.start_with?("\n")
+
+          offense(op, with_space, right_operand) do |msg|
+            add_offense(with_space, location: op, message: msg)
+          end
+        end
+
+        def offense(op, with_space, right_operand)
+          msg = offense_message(op, with_space, right_operand)
+          yield msg if msg
+        end
+
+        def offense_message(op, with_space, right_operand)
+          if op.is?('**')
+            'Space around operator `**` detected.' unless with_space.is?('**')
+          elsif with_space.source !~ /^\s.*\s$/
+            "Surrounding space missing for operator `#{op.source}`."
+          elsif excess_leading_space?(op, with_space) ||
+                excess_trailing_space?(right_operand, with_space)
+            "Operator `#{op.source}` should be surrounded by a single space."
+          end
+        end
+
+        def excess_leading_space?(op, with_space)
+          with_space.source =~ /^  / &&
+            (!allow_for_alignment? || !aligned_with_operator?(op))
+        end
+
+        def excess_trailing_space?(right_operand, with_space)
+          with_space.source =~ /  $/ &&
+            (!allow_for_alignment? || !aligned_with_something?(right_operand))
+        end
+
+        def align_hash_cop_config
+          config.for_cop('Layout/AlignHash')
+        end
+
+        def hash_table_style?
+          align_hash_cop_config &&
+            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that block braces have or don't have a space before the opening
+      # brace depending on configuration.
+      #
+      # @example
+      #   # bad
+      #   foo.map{ |a|
+      #     a.bar.to_s
+      #   }
+      #
+      #   # good
+      #   foo.map { |a|
+      #     a.bar.to_s
+      #   }
+      class SpaceBeforeBlockBraces < Cop
+        include ConfigurableEnforcedStyle
+
+        MISSING_MSG = 'Space missing to the left of {.'.freeze
+        DETECTED_MSG = 'Space detected to the left of {.'.freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::SymbolProc]
+        end
+
+        def on_block(node)
+          return if node.keywords?
+
+          left_brace = node.loc.begin
+          space_plus_brace = range_with_surrounding_space(range: left_brace)
+          used_style =
+            space_plus_brace.source.start_with?('{') ? :no_space : :space
+
+          if empty_braces?(node.loc)
+            check_empty(left_brace, space_plus_brace, used_style)
+          else
+            check_non_empty(left_brace, space_plus_brace, used_style)
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            else           corrector.insert_before(range, ' ')
+            end
+          end
+        end
+
+        private
+
+        def check_empty(left_brace, space_plus_brace, used_style)
+          return if style_for_empty_braces == used_style
+
+          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] =
+            used_style.to_s
+
+          if style_for_empty_braces == :space
+            add_offense(left_brace, location: left_brace, message: MISSING_MSG)
+          else
+            space = range_between(space_plus_brace.begin_pos,
+                                  left_brace.begin_pos)
+            add_offense(space, location: space, message: DETECTED_MSG)
+          end
+        end
+
+        def check_non_empty(left_brace, space_plus_brace, used_style)
+          case used_style
+          when style  then correct_style_detected
+          when :space then space_detected(left_brace, space_plus_brace)
+          else             space_missing(left_brace)
+          end
+        end
+
+        def space_missing(left_brace)
+          add_offense(left_brace, location: left_brace, message: MISSING_MSG) do
+            opposite_style_detected
+          end
+        end
+
+        def space_detected(left_brace, space_plus_brace)
+          space = range_between(space_plus_brace.begin_pos,
+                                left_brace.begin_pos)
+          add_offense(space, location: space, message: DETECTED_MSG) do
+            opposite_style_detected
+          end
+        end
+
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          when nil then style
+          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
+          end
+        end
+
+        def empty_braces?(loc)
+          loc.begin.end_pos == loc.end.begin_pos
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for comma (,) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   [1 , 2 , 3]
+      #   a(1 , 2)
+      #   each { |a , b| }
+      #
+      #   # good
+      #   [1, 2, 3]
+      #   a(1, 2)
+      #   each { |a, b| }
+      class SpaceBeforeComma < Cop
+        include SpaceBeforePunctuation
+
+        def autocorrect(space)
+          PunctuationCorrector.remove_space(space)
+        end
+
+        def kind(token)
+          'comma' if token.comma?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/space_before_comment.rb

@@ -1,24 +1,28 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for missing space between a token and a comment on the
       # same line.
+      #
+      # @example
+      #   # bad
+      #   1 + 1# this operation does ...
+      #
+      #   # good
+      #   1 + 1 # this operation does ...
       class SpaceBeforeComment < Cop
         MSG = 'Put a space before an end-of-line comment.'.freeze
 
         def investigate(processed_source)
           processed_source.tokens.each_cons(2) do |t1, t2|
-            next unless t2.type == :tCOMMENT
-            next unless t1.pos.line == t2.pos.line
-            add_offense(t2.pos, t2.pos) if t1.pos.end == t2.pos.begin
+            next unless t2.comment?
+            next unless t1.line == t2.line
+            add_offense(t2.pos, location: t2.pos) if t1.pos.end == t2.pos.begin
           end
         end
 
-        private
-
         def autocorrect(range)
           ->(corrector) { corrector.insert_before(range, ' ') }
         end

data/lib/rubocop/cop/{style → layout}/space_before_first_arg.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks that exactly one space is used between a method name and the
       # first argument for method calls without parentheses.
       #
@@ -12,9 +11,15 @@ module RuboCop
       # config parameter is true.
       #
       # @example
-      #   @bad
+      #   # bad
       #   something  x
       #   something   y, z
+      #   something'hello'
+      #
+      #   # good
+      #   something x
+      #   something y, z
+      #   something 'hello'
       #
       class SpaceBeforeFirstArg < Cop
         include PrecedingFollowingAlignment
@@ -23,16 +28,16 @@ module RuboCop
               'the first argument.'.freeze
 
         def on_send(node)
-          return unless regular_method_call_with_params?(node)
+          return unless regular_method_call_with_arguments?(node)
           return unless expect_params_after_method_name?(node)
 
-          _receiver, _method_name, *args = *node
-          arg1 = args.first.source_range
-          arg1_with_space = range_with_surrounding_space(arg1, :left)
-          space = Parser::Source::Range.new(arg1.source_buffer,
-                                            arg1_with_space.begin_pos,
-                                            arg1.begin_pos)
-          add_offense(space, space) if space.length > 1
+          first_arg = node.first_argument.source_range
+          first_arg_with_space = range_with_surrounding_space(range: first_arg,
+                                                              side: :left)
+          space = range_between(first_arg_with_space.begin_pos,
+                                first_arg.begin_pos)
+
+          add_offense(space, location: space) if space.length != 1
         end
 
         def autocorrect(range)
@@ -41,20 +46,18 @@ module RuboCop
 
         private
 
-        def regular_method_call_with_params?(node)
-          _receiver, method_name, *args = *node
-
-          !(args.empty? || operator?(method_name) || node.asgn_method_call?)
+        def regular_method_call_with_arguments?(node)
+          node.arguments? && !node.operator_method? && !node.setter_method?
         end
 
         def expect_params_after_method_name?(node)
-          return false if parentheses?(node)
+          return false if node.parenthesized?
 
-          _receiver, _method_name, *args = *node
-          arg1 = args.first.source_range
+          first_arg = node.first_argument
 
-          arg1.line == node.loc.line &&
-            !(allow_for_alignment? && aligned_with_something?(arg1))
+          same_line?(first_arg, node) &&
+            !(allow_for_alignment? &&
+              aligned_with_something?(first_arg.source_range))
         end
       end
     end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for semicolon (;) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   x = 1 ; y = 2
+      #
+      #   # good
+      #   x = 1; y = 2
+      class SpaceBeforeSemicolon < Cop
+        include SpaceBeforePunctuation
+
+        def autocorrect(space)
+          PunctuationCorrector.remove_space(space)
+        end
+
+        def kind(token)
+          'semicolon' if token.semicolon?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for spaces between -> and opening parameter
+      # brace in lambda literals.
+      #
+      # @example EnforcedStyle: require_no_space (default)
+      #     # bad
+      #     a = -> (x, y) { x + y }
+      #
+      #     # good
+      #     a = ->(x, y) { x + y }
+      #
+      # @example EnforcedStyle: require_space
+      #     # bad
+      #     a = ->(x, y) { x + y }
+      #
+      #     # good
+      #     a = -> (x, y) { x + y }
+      class SpaceInLambdaLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        ARROW = '->'.freeze
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and opening brace ' \
+                            'in lambda literals'.freeze
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and opening ' \
+                               'brace in lambda literals'.freeze
+
+        def on_send(node)
+          return unless arrow_lambda_with_args?(node)
+          if style == :require_space && !space_after_arrow?(node)
+            add_offense(node,
+                        location: node.parent.loc.expression,
+                        message: MSG_REQUIRE_SPACE)
+          elsif style == :require_no_space && space_after_arrow?(node)
+            add_offense(node,
+                        location: node.parent.loc.expression,
+                        message: MSG_REQUIRE_NO_SPACE)
+          end
+        end
+
+        def autocorrect(lambda_node)
+          children = lambda_node.parent.children
+          lambda do |corrector|
+            if style == :require_space
+              corrector.insert_before(children[1].source_range, ' ')
+            else
+              space_range = range_between(children[0].source_range.end_pos,
+                                          children[1].source_range.begin_pos)
+              corrector.remove(space_range)
+            end
+          end
+        end
+
+        private
+
+        def arrow_lambda_with_args?(node)
+          lambda_node?(node) && arrow_form?(node) && args?(node)
+        end
+
+        def lambda_node?(node)
+          receiver, call = *node
+          receiver.nil? && call == :lambda
+        end
+
+        def arrow_form?(lambda_node)
+          lambda_node.loc.selector.source == ARROW
+        end
+
+        def args?(lambda_node)
+          _call, args, _body = *lambda_node.parent
+          !args.children.empty?
+        end
+
+        def space_after_arrow?(lambda_node)
+          arrow = lambda_node.parent.children[0]
+          parentheses = lambda_node.parent.children[1]
+          parentheses.source_range.begin_pos - arrow.source_range.end_pos > 0
+        end
+      end
+    end
+  end
+end