rubocop 0.40.0 → 0.41.0

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

@@ -93,12 +93,10 @@ module RuboCop
 
         def on_send(node)
           receiver, method_name, *_args = *node
-          return unless receiver && receiver.type == :self
-          return if operator?(method_name) ||
-                    keyword?(method_name) ||
-                    constant_name?(method_name) ||
-                    node.asgn_method_call? ||
-                    @allowed_send_nodes.include?(node) ||
+          return unless receiver && receiver.self_type?
+          return unless regular_method_call?(node)
+
+          return if @allowed_send_nodes.include?(node) ||
                     @local_variables.include?(method_name)
 
           add_offense(node, :expression)
@@ -114,6 +112,15 @@ module RuboCop
 
         private
 
+        def regular_method_call?(node)
+          _receiver, method_name, *_args = *node
+
+          !(operator?(method_name) ||
+            keyword?(method_name) ||
+            constant_name?(method_name) ||
+            node.asgn_method_call?)
+        end
+
         def on_argument(node)
           name, = *node
           @local_variables << name

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

@@ -16,12 +16,14 @@ module RuboCop
         MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-
-          return unless method_name == :!
-          return unless receiver.loc.column - node.loc.column > 1
+          if node.keyword_bang? && whitespace_after_bang_op?(node)
+            add_offense(node, :expression)
+          end
+        end
 
-          add_offense(node, :expression)
+        def whitespace_after_bang_op?(node)
+          receiver, _method_name, *_args = *node
+          receiver.loc.column - node.loc.column > 1
         end
 
         def autocorrect(node)

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

@@ -30,6 +30,7 @@ module RuboCop
         MSG_AFTER = 'Space after keyword `%s` is missing.'.freeze
 
         DO = 'do'.freeze
+        SAFE_NAVIGATION = '&.'.freeze
         ACCEPT_LEFT_PAREN =
           %w(break defined? next not rescue return super yield).freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
@@ -183,6 +184,7 @@ module RuboCop
                           char == '('.freeze
           return false if accept_left_square_bracket?(range) &&
                           char == '['.freeze
+          return false if safe_navigation_call?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
@@ -195,6 +197,10 @@ module RuboCop
           ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
         end
 
+        def safe_navigation_call?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
+        end
+
         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

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

@@ -42,7 +42,7 @@ module RuboCop
             on_special_asgn(node)
           elsif !node.unary_operation? && !called_with_dot?(node)
             op = node.method_name
-            if op != :[] && op != :! && op != :[]= && operator?(op)
+            if operator_with_regular_syntax?(op)
               _, _, right, = *node
               check_operator(node.loc.selector, right.source_range)
             end
@@ -80,6 +80,10 @@ module RuboCop
           node.loc.dot
         end
 
+        def operator_with_regular_syntax?(op)
+          ![:[], :!, :[]=].include?(op) && operator?(op)
+        end
+
         def check_operator(op, right_operand)
           with_space = range_with_surrounding_space(op)
           return if with_space.source.start_with?("\n")

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

@@ -23,17 +23,11 @@ module RuboCop
               'the first argument.'.freeze
 
         def on_send(node)
-          return if parentheses?(node)
-
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if operator?(method_name)
-          return if node.asgn_method_call?
+          return unless regular_method_call_with_params?(node)
+          return unless expect_params_after_method_name?(node)
 
+          _receiver, _method_name, *args = *node
           arg1 = args.first.source_range
-          return if arg1.line > node.loc.line
-          return if allow_for_alignment? && aligned_with_something?(arg1)
-
           arg1_with_space = range_with_surrounding_space(arg1, :left)
           space = Parser::Source::Range.new(arg1.source_buffer,
                                             arg1_with_space.begin_pos,
@@ -44,6 +38,24 @@ module RuboCop
         def autocorrect(range)
           ->(corrector) { corrector.replace(range, ' ') }
         end
+
+        private
+
+        def regular_method_call_with_params?(node)
+          _receiver, method_name, *args = *node
+
+          !(args.empty? || operator?(method_name) || node.asgn_method_call?)
+        end
+
+        def expect_params_after_method_name?(node)
+          return false if parentheses?(node)
+
+          _receiver, _method_name, *args = *node
+          arg1 = args.first.source_range
+
+          arg1.line == node.loc.line &&
+            !(allow_for_alignment? && aligned_with_something?(arg1))
+        end
       end
     end
   end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unnecessary additional spaces inside array percent literals
+      # (i.e. %i/%w).
+      #
+      # @good
+      # %i(foo bar baz)
+      #
+      # @bad
+      # %w(foo  bar  baz)
+      class SpaceInsideArrayPercentLiteral < Cop
+        include MatchRange
+        include PercentLiteral
+
+        MSG = 'Use only a single space inside array percent literal.'.freeze
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
+          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/
+
+        def on_array(node)
+          process(node, *%w(%i %I %w %W))
+        end
+
+        def on_percent_literal(node)
+          each_unnecessary_space_match(node) do |range|
+            add_offense(node, range, MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_unnecessary_space_match(node) do |range|
+              corrector.replace(range, ' ')
+            end
+          end
+        end
+
+        private
+
+        def each_unnecessary_space_match(node, &blk)
+          each_match_range(
+            contents_range(node),
+            MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX,
+            &blk
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -37,7 +37,7 @@ module RuboCop
 
           if left_brace.end_pos == right_brace.begin_pos
             adjacent_braces(sb, left_brace, right_brace)
-          elsif left_brace.line == right_brace.line
+          else
             range = Parser::Source::Range.new(sb, left_brace.end_pos,
                                               right_brace.begin_pos)
             inner = range.source
@@ -70,7 +70,7 @@ module RuboCop
             space_inside_left_brace(left_brace, args_delimiter, sb)
           end
 
-          if inner =~ /\S$/
+          if inner =~ /\S$/ && block_length(node) == 0
             no_space(sb, right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else

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

@@ -34,11 +34,8 @@ module RuboCop
           return if t2.type == :tCOMMENT # Also indicates there's a line break.
 
           is_empty_braces = t1.text == '{' && t2.text == '}'
-          expect_space = if is_empty_braces
-                           cop_config['EnforcedStyleForEmptyBraces'] == 'space'
-                         else
-                           style == :space
-                         end
+          expect_space    = expect_space?(t1, t2)
+
           if offense?(t1, t2, expect_space)
             incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           else
@@ -46,12 +43,35 @@ module RuboCop
           end
         end
 
+        def expect_space?(t1, t2)
+          is_same_braces  = t1.text == t2.text
+          is_empty_braces = t1.text == '{' && t2.text == '}'
+
+          if is_same_braces && style == :compact
+            false
+          elsif is_empty_braces
+            cop_config['EnforcedStyleForEmptyBraces'] != 'no_space'
+          else
+            style != :no_space
+          end
+        end
+
         def incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           brace = (t1.text == '{' ? t1 : t2).pos
           range = expect_space ? brace : space_range(brace)
           add_offense(range, range,
                       message(brace, is_empty_braces, expect_space)) do
-            opposite_style_detected
+            if expect_space
+              if t1.text == t2.text
+                ambiguous_style_detected(:no_space, :compact)
+              else
+                unexpected_style_detected(:no_space)
+              end
+            elsif t1.text == t2.text
+              unexpected_style_detected(:space)
+            else
+              ambiguous_style_detected(:space, :compact)
+            end
           end
         end
 

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unnecessary additional spaces inside the delimiters of
+      # %i/%w/%x literals.
+      #
+      # @good
+      # %i(foo bar baz)
+      #
+      # @bad
+      # %w( foo bar baz )
+      #
+      # @bad
+      # %x(  ls -l )
+      class SpaceInsidePercentLiteralDelimiters < Cop
+        include MatchRange
+        include PercentLiteral
+
+        MSG = 'Do not use spaces inside percent literal delimiters.'.freeze
+        BEGIN_REGEX = /\A( +)/
+        END_REGEX = /(?<!\\)( +)\z/
+
+        def on_array(node)
+          process(node, *%w(%i %I %w %W))
+        end
+
+        def on_percent_literal(node)
+          add_offenses_for_unnecessary_spaces(node)
+        end
+
+        def on_xstr(node)
+          add_offenses_for_unnecessary_spaces(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            regex_matches(node) do |match_range|
+              corrector.remove(match_range)
+            end
+          end
+        end
+
+        private
+
+        def add_offenses_for_unnecessary_spaces(node)
+          return unless node.single_line?
+
+          regex_matches(node) do |match_range|
+            add_offense(node, match_range, MSG)
+          end
+        end
+
+        def regex_matches(node, &blk)
+          [BEGIN_REGEX, END_REGEX].each do |regex|
+            each_match_range(contents_range(node), regex, &blk)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,9 +20,10 @@ module RuboCop
           return if node.loc.is_a?(Parser::Source::Map::Heredoc)
 
           children = node.children
-          return unless children.all? { |c| c.str_type? || c.dstr_type? }
+          return unless all_string_literals?(children)
+
+          quote_styles = detect_quote_styles(node)
 
-          quote_styles = children.map { |c| c.loc.begin.source }.uniq
           if quote_styles.size > 1
             add_offense(node, :expression, MSG_INCONSISTENT)
           else
@@ -34,6 +35,22 @@ module RuboCop
 
         private
 
+        def all_string_literals?(nodes)
+          nodes.all? { |n| n.str_type? || n.dstr_type? }
+        end
+
+        def detect_quote_styles(node)
+          styles = node.children.map { |c| c.loc.begin }
+
+          # For multi-line strings that only have quote marks
+          # at the beginning of the first line and the end of
+          # the last, the begin and end region of each child
+          # is nil. The quote marks are in the parent node.
+          return [node.loc.begin.source] if styles.all?(&:nil?)
+
+          styles.map(&:source).uniq
+        end
+
         def message(*)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
@@ -59,13 +76,25 @@ module RuboCop
         def check_multiline_quote_style(node, quote)
           range = node.source_range
           children = node.children
-          if quote == "'" && style == :double_quotes
+          if unexpected_single_quotes?(quote)
             add_offense(node, range) if children.all? { |c| wrong_quotes?(c) }
-          elsif quote == '"' && style == :single_quotes
-            if children.none?(&:dstr_type?) &&
-               children.none? { |c| double_quotes_acceptable?(c.str_content) }
-              add_offense(node, range)
-            end
+          elsif unexpected_double_quotes?(quote) &&
+                !accept_child_double_quotes?(children)
+            add_offense(node, range)
+          end
+        end
+
+        def unexpected_single_quotes?(quote)
+          quote == "'" && style == :double_quotes
+        end
+
+        def unexpected_double_quotes?(quote)
+          quote == '"' && style == :single_quotes
+        end
+
+        def accept_child_double_quotes?(nodes)
+          nodes.any? do |n|
+            n.dstr_type? || double_quotes_acceptable?(n.str_content)
           end
         end
       end

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

@@ -19,13 +19,9 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:sym, node)
-            return if comments_in_array?(node)
-            return if symbols_contain_spaces?(node)
-            style_detected(:brackets)
-            add_offense(node, :expression, PERCENT_MSG) if style == :percent
-          elsif node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
-            style_detected(:percent)
-            add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+            check_bracketed_array(node)
+          elsif percent_array?(node)
+            check_percent_array(node)
           end
         end
 
@@ -44,6 +40,23 @@ module RuboCop
 
         private
 
+        def percent_array?(node)
+          node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
+        end
+
+        def check_bracketed_array(node)
+          return if comments_in_array?(node)
+          return if symbols_contain_spaces?(node)
+
+          style_detected(:brackets)
+          add_offense(node, :expression, PERCENT_MSG) if style == :percent
+        end
+
+        def check_percent_array(node)
+          style_detected(:percent)
+          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+        end
+
         def comments_in_array?(node)
           comments = processed_source.comments
           array_range = node.source_range.to_a
@@ -63,7 +76,7 @@ module RuboCop
         def autocorrect(node)
           syms = node.children.map { |c| c.children[0].to_s }
           corrected = if style == :percent
-                        escape = syms.any? { |s| double_quotes_required?(s) }
+                        escape = syms.any? { |s| needs_escaping?(s) }
                         syms = syms.map { |s| escape_string(s) } if escape
                         syms = syms.map { |s| s.gsub(/\)/, '\\)') }
                         if escape
@@ -80,10 +93,6 @@ module RuboCop
             corrector.replace(node.source_range, corrected)
           end
         end
-
-        def escape_string(string)
-          string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
-        end
       end
     end
   end