rubocop 0.47.1 → 0.48.0

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

@@ -25,10 +25,8 @@ module RuboCop
           return if block_length(node).zero?
 
           method, _args, _body = *node
-          return unless method.send_type?
-
-          _receiver, method_name, *args = *method
-          return unless method_name == :each && args.empty?
+          return unless method.send_type? && method.method?(:each) &&
+                        !method.arguments?
 
           if style == :for
             incorrect_style_detected(method)

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

@@ -24,12 +24,13 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless (selector = formatter(node))
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
 
-          detected_style = selector == :% ? :percent : selector
-          return if detected_style == style
+            return if detected_style == style
 
-          add_offense(node, :selector, message(detected_style))
+            add_offense(node, :selector, message(detected_style))
+          end
         end
 
         def message(detected_style)

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

@@ -12,7 +12,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
 
-        MSG = 'Missing frozen string literal comment.'.freeze
+        MSG = 'Missing magic comment `# frozen_string_literal: true`.'.freeze
         MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'.freeze
         SHEBANG = '#!'.freeze
 

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

@@ -40,6 +40,28 @@ module RuboCop
       #   else
       #     do_y
       #   end
+      #
+      #   @bad
+      #   switch foo
+      #   when 1
+      #     do_x
+      #   when 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   @good
+      #   switch foo
+      #   when 1
+      #     do_x
+      #     do_y
+      #   when 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
       class IdenticalConditionalBranches < Cop
         MSG = 'Move `%s` out of the conditional.'.freeze
 
@@ -58,7 +80,11 @@ module RuboCop
         def on_case(node)
           return unless node.else? && node.else_branch
 
-          check_branches(node.when_branches.map(&:body).push(node.else_branch))
+          branches = node.when_branches.map(&:body).push(node.else_branch)
+
+          return if branches.any?(&:nil?)
+
+          check_branches(branches)
         end
 
         private

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

@@ -13,8 +13,8 @@ module RuboCop
               'Another good alternative is the usage of control flow ' \
               '`&&`/`||`.'.freeze
 
-        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
-                            :gvasgn, :ivasgn, :masgn].freeze
+        ASSIGNMENT_TYPES = %i(lvasgn casgn cvasgn
+                              gvasgn ivasgn masgn).freeze
 
         def on_if(node)
           return unless eligible_node?(node)

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

@@ -16,8 +16,8 @@ module RuboCop
       #   # good
       #   value =
       #     if foo
-      #     'bar'
-      #   end
+      #       'bar'
+      #     end
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.

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

@@ -63,7 +63,8 @@ module RuboCop
           return if ignored_node?(hash_node)
 
           left_brace = hash_node.loc.begin
-          first_pair = hash_node.children.first
+          first_pair = hash_node.pairs.first
+
           if first_pair
             return if first_pair.source_range.line == left_brace.line
 

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of the here document bodies. The bodies
+      # are indented one step.
+      # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
+      # use the older rubies, you should introduce some library to your project
+      # (e.g. ActiveSupport, Powerpack or Unindent).
+      #
+      # @example
+      #
+      #   # bad
+      #   <<-END
+      #   something
+      #   END
+      #
+      #   # good
+      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
+      #   # following code.
+      #   <<~END
+      #     something
+      #   END
+      #
+      #   # good
+      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-END.strip_heredoc
+      #     something
+      #   END
+      class IndentHeredoc < Cop
+        include ConfigurableEnforcedStyle
+        include SafeMode
+
+        RUBY23_MSG = 'Use %d spaces for indentation in a heredoc by using ' \
+                     '`<<~` instead of `%s`.'.freeze
+        LIBRARY_MSG = 'Use %d spaces for indentation in a heredoc by using %s.'
+                      .freeze
+        StripMethods = {
+          unindent: 'unindent',
+          active_support: 'strip_heredoc',
+          powerpack: 'strip_indent'
+        }.freeze
+
+        def on_str(node)
+          return unless heredoc?(node)
+
+          body_indent_level = body_indent_level(node)
+
+          if heredoc_indent_type(node) == '~'
+            expected_indent_level = base_indent_level(node) + indentation_width
+            return if expected_indent_level == body_indent_level
+          else
+            return unless body_indent_level.zero?
+          end
+
+          add_offense(node, :heredoc_body)
+        end
+
+        alias on_dstr on_str
+        alias on_xstr on_str
+
+        def autocorrect(node)
+          check_style!
+
+          case style
+          when :squiggly
+            correct_by_squiggly(node)
+          else
+            correct_by_library(node)
+          end
+        end
+
+        private
+
+        def style
+          style = super
+          return style unless style == :auto_detection
+
+          if target_ruby_version >= 2.3
+            :squiggly
+          elsif rails?
+            :active_support
+          end
+        end
+
+        def message(node)
+          case style
+          when :squiggly
+            current_indent_type = "<<#{heredoc_indent_type(node)}"
+            format(RUBY23_MSG, indentation_width, current_indent_type)
+          when nil
+            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
+            format(LIBRARY_MSG, indentation_width, method)
+          else
+            method = "`String##{StripMethods[style]}`"
+            format(LIBRARY_MSG, indentation_width, method)
+          end
+        end
+
+        def correct_by_squiggly(node)
+          return if target_ruby_version < 2.3
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              corrector.replace(node.loc.heredoc_body, indented_body(node))
+            else
+              heredoc_begenning = node.loc.expression.source
+              corrected = heredoc_begenning.sub(/<<-?/, '<<~')
+              corrector.replace(node.loc.expression, corrected)
+            end
+          end
+        end
+
+        def correct_by_library(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.heredoc_body, indented_body(node))
+            corrected = ".#{StripMethods[style]}"
+            corrector.insert_after(node.loc.expression, corrected)
+          end
+        end
+
+        def check_style!
+          case style
+          when nil
+            raise Warning, "Auto-correction does not work for #{cop_name}. " \
+                           'Please configure EnforcedStyle.'
+          when :squiggly
+            if target_ruby_version < 2.3
+              raise Warning, '`squiggly` style is selectable only on Ruby ' \
+                             "2.3 or higher for #{cop_name}."
+            end
+          end
+        end
+
+        def heredoc?(node)
+          node.loc.is_a?(Parser::Source::Map::Heredoc)
+        end
+
+        def indented_body(node)
+          body = node.loc.heredoc_body.source
+          body_indent_level = body_indent_level(node)
+          correct_indent_level = base_indent_level(node) + indentation_width
+          body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
+        end
+
+        def body_indent_level(node)
+          body = node.loc.heredoc_body.source
+          indent_level(body)
+        end
+
+        def base_indent_level(node)
+          base_line_num = node.loc.expression.line
+          base_line = processed_source.lines[base_line_num - 1]
+          indent_level(base_line)
+        end
+
+        def indent_level(str)
+          str.scan(/^\s*/).reject { |line| line == "\n" }.min_by(&:size).size
+        end
+
+        # Returns '~', '-' or nil
+        def heredoc_indent_type(node)
+          node.source[/^<<([~-])/, 1]
+        end
+
+        def indentation_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+      end
+    end
+  end
+end

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

@@ -3,38 +3,70 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks for indentation that doesn't use two spaces.
+      # This cops checks for indentation that doesn't use the specified number
+      # of spaces.
       #
-      # @example
+      # See also the IndentationConsistency cop which is the companion to this
+      # one.
       #
+      # @example
+      #   # bad, Width: 2
       #   class A
       #    def test
       #     puts 'hello'
       #    end
       #   end
-      class IndentationWidth < Cop
+      #
+      #   # bad, Width: 2,
+      #          IgnoredPatterns:
+      #            - '^\s*module'
+      #   module A
+      #   class B
+      #     def test
+      #     puts 'hello'
+      #     end
+      #   end
+      #   end
+      #
+      #   # good, Width: 2
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #
+      #   # good, Width: 2,
+      #           IgnoredPatterns:
+      #             - '^\s*module'
+      #   module A
+      #   class B
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #   end
+      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
         include EndKeywordAlignment
         include AutocorrectAlignment
         include OnMethodDef
         include CheckAssignment
         include AccessModifierNode
+        include IgnoredPattern
 
         SPECIAL_MODIFIERS = %w(private protected).freeze
 
         def on_rescue(node)
-          _begin_node, *rescue_nodes, else_node = *node
-          rescue_nodes.each do |rescue_node|
-            _, _, body = *rescue_node
-            check_indentation(rescue_node.loc.keyword, body)
-          end
+          _begin_node, *_rescue_nodes, else_node = *node
           check_indentation(node.loc.else, else_node)
         end
 
         def on_ensure(node)
-          _body, ensure_body = *node
-          check_indentation(node.loc.keyword, ensure_body)
+          check_indentation(node.loc.keyword, node.body)
         end
 
+        alias on_resbody on_ensure
+        alias on_for     on_ensure
+
         def on_kwbegin(node)
           # Check indentation against end keyword but only if it's first on its
           # line.
@@ -69,26 +101,21 @@ module RuboCop
         def on_send(node)
           super
           return unless modifier_and_def_on_same_line?(node)
-          _, _, *args = *node
 
-          *_, body = *args.first
+          *_, body = *node.first_argument
 
           def_end_config = config.for_cop('Lint/DefEndAlignment')
           style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
-          base = style == 'def' ? args.first : node
+          base = style == 'def' ? node.first_argument : node
 
           check_indentation(base.source_range, body)
-          ignore_node(args.first)
+          ignore_node(node.first_argument)
         end
 
         def on_method_def(node, _method_name, _args, body)
           check_indentation(node.loc.keyword, body) unless ignored_node?(node)
         end
 
-        def on_for(node)
-          check_indentation(node.loc.keyword, node.body)
-        end
-
         def on_while(node, base = node)
           return if ignored_node?(node)
 
@@ -230,24 +257,29 @@ module RuboCop
         end
 
         def indentation_to_check?(base_loc, body_node)
-          return false unless body_node
+          return false if skip_check?(base_loc, body_node)
+
+          if %i(rescue ensure).include?(body_node.type)
+            block_body, = *body_node
+            return unless block_body
+          end
+
+          true
+        end
+
+        def skip_check?(base_loc, body_node)
+          return true if ignored_line?(base_loc)
+          return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return false if body_node.loc.line == base_loc.line
+          return true if body_node.loc.line == base_loc.line
 
-          return false if starts_with_access_modifier?(body_node)
+          return true if starts_with_access_modifier?(body_node)
 
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          return false unless body_node.loc.column == first_char_pos_on_line
-
-          if [:rescue, :ensure].include?(body_node.type)
-            block_body, = *body_node
-            return unless block_body
-          end
-
-          true
+          return true unless body_node.loc.column == first_char_pos_on_line
         end
 
         def offending_range(body_node, indentation)

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop check for usages of not (`not` or `!`) called on a method
+      # when an inverse of that method can be used instead.
+      # Methods that can be inverted by a not (`not` or `!`) should be defined
+      # in `InverseMethods`
+      # Methods that are inverted by inverting the return
+      # of the block that is passed to the method should be defined in
+      # `InverseBlocks`
+      #
+      # @example
+      #   # bad
+      #   !foo.none?
+      #   !foo.any? { |f| f.even? }
+      #   !foo.blank?
+      #   !(foo == bar)
+      #   foo.select { |f| !f.even? }
+      #   foo.reject { |f| f != 7 }
+      #
+      #   # good
+      #   foo.none?
+      #   foo.blank?
+      #   foo.any? { |f| f.even? }
+      #   foo != bar
+      #   foo == bar
+      class InverseMethods < Cop
+        MSG = 'Use `%{inverse}` instead of inverting `%{method}`.'.freeze
+        EQUALITY_METHODS = %i(== != =~ !~ <= >= < >).freeze
+
+        def_node_matcher :inverse_candidate?, <<-PATTERN
+          {
+            (send $(send (...) $_ ...) :!)
+            (send (block $(send (...) $_) ...) :!)
+            (send (begin $(send (...) $_ ...)) :!)
+          }
+        PATTERN
+
+        def_node_matcher :inverse_block?, <<-PATTERN
+          (block $(send (...) $_) ... { $(send ... :!)
+                                        $(send (...) {:!= :!~} ...)
+                                        (begin ... $(send ... :!))
+                                        (begin ... $(send (...) {:!= :!~} ...))
+                                      })
+        PATTERN
+
+        def on_send(node)
+          inverse_candidate?(node) do |_method_call, method|
+            return unless inverse_methods.key?(method)
+
+            add_offense(node,
+                        :expression,
+                        format(MSG, method: method,
+                                    inverse: inverse_methods[method]))
+          end
+        end
+
+        def on_block(node)
+          inverse_block?(node) do |_method_call, method, _block|
+            return unless inverse_blocks.key?(method)
+
+            add_offense(node,
+                        :expression,
+                        format(MSG, method: method,
+                                    inverse: inverse_blocks[method]))
+          end
+        end
+
+        def autocorrect(node)
+          method_call, method = inverse_candidate?(node)
+
+          if method_call && method
+            lambda do |corrector|
+              corrector.remove(not_to_receiver(node, method_call))
+              corrector.replace(method_call.loc.selector,
+                                inverse_methods[method].to_s)
+
+              if EQUALITY_METHODS.include?(method)
+                corrector.remove(end_parentheses(node, method_call))
+              end
+            end
+          else
+            correct_inverse_block(node)
+          end
+        end
+
+        def correct_inverse_block(node)
+          method_call, method, block = inverse_block?(node)
+          selector = block.loc.selector.source
+
+          lambda do |corrector|
+            corrector.replace(method_call.loc.selector,
+                              inverse_blocks[method].to_s)
+
+            if ['!=', '!~'].include?(selector)
+              selector[0] = '='
+              corrector.replace(block.loc.selector, selector)
+            else
+              corrector.remove(block.loc.selector)
+            end
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+                               .merge(cop_config['InverseMethods'].invert)
+        end
+
+        def inverse_blocks
+          @inverse_blocks ||= cop_config['InverseBlocks']
+                              .merge(cop_config['InverseBlocks'].invert)
+        end
+
+        def not_to_receiver(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.selector.begin_pos,
+                                    method_call.loc.expression.begin_pos)
+        end
+
+        def end_parentheses(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    method_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end