rubocop 0.54.0 → 0.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b90da169ae8cd99e01c43d41be0a4d43911dcf77
-  data.tar.gz: 5c1db29014d29765ee9400b93d695a0beee04e4a
+  metadata.gz: b6193bafb35931ae47f1a4d40c8b9919f4f8df07
+  data.tar.gz: 8b4c066f46a71fe4d35d84d0b1063f22130e2b4d
 SHA512:
-  metadata.gz: 750f559ae4fe5bdc11721d45907baf604f37b182602045ef38c62ca277302e3834a99bb7dab80ddd5eb70be9d358b309aeb37129a85aefeb0234ffdb54848f04
-  data.tar.gz: f3f987115edf268066df468d4077c1f1e160dce133b277b6ac6a261cf26a7e26e41f6f54fe24eecf626858931016a7562e9386b7f2a3180f1c31f0500dfe2f67
+  metadata.gz: a619c39a295a5cfdc1a2d82a51391f8d995ea04e20a865eba6951056f57766be7df10718194782f715750f0d9007c6ee730688289acd277c371fc408e137c065
+  data.tar.gz: 3ad640cddf0bedeaa238e9e13beef2da09f156c1bc957784c2779cc65076a7f142e0b85c113a6221e7792e491db4ebabeafea4c7424a92750523ddd55ecb4128

data/README.md

@@ -52,7 +52,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version locking in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.54.0', require: false
+gem 'rubocop', '~> 0.55.0', require: false
 ```
 
 ## Quickstart
@@ -75,6 +75,10 @@ RuboCop supports the following Ruby implementations:
 * MRI 2.1+
 * JRuby 9.0+
 
+The Rails cops support the following versions:
+
+* Rails 4.0+
+
 ## Team
 
 Here's a list of RuboCop's core developers:

data/config/default.yml

@@ -604,6 +604,12 @@ Layout/SpaceInsideHashLiteralBraces:
     - space
     - no_space
 
+Layout/SpaceInsideParens:
+  EnforcedStyle: no_space
+  SupportedStyles:
+    - space
+    - no_space
+
 Layout/SpaceInsideReferenceBrackets:
   EnforcedStyle: no_space
   SupportedStyles:
@@ -648,6 +654,9 @@ Layout/TrailingBlankLines:
     - final_newline
     - final_blank_line
 
+Layout/TrailingWhitespace:
+  AllowInHeredoc: false
+
 #################### Naming ##########################
 
 Naming/FileName:
@@ -712,8 +721,7 @@ Naming/FileName:
 
 Naming/HeredocDelimiterNaming:
   Blacklist:
-    - END
-    - !ruby/regexp '/EO[A-Z]{1}/'
+    - !ruby/regexp '/(^|\s)(EO[A-Z]{1}|END)(\s|$)/'
 
 Naming/HeredocDelimiterCase:
   EnforcedStyle: uppercase
@@ -769,6 +777,10 @@ Naming/UncommunicativeMethodParamName:
     - io
     - id
     - to
+    - by
+    - 'on'
+    - in
+    - at
   # Blacklisted names that will register an offense
   ForbiddenNames: []
 
@@ -1121,6 +1133,9 @@ Style/MethodCallWithArgsParentheses:
   IgnoreMacros: true
   IgnoredMethods: []
 
+Style/MethodCallWithoutArgsParentheses:
+  IgnoredMethods: []
+
 Style/MethodDefParentheses:
   EnforcedStyle: require_parentheses
   SupportedStyles:

data/config/enabled.yml

@@ -654,6 +654,13 @@ Lint/SafeNavigationChain:
   Description: 'Do not chain ordinary method call after safe navigation operator.'
   Enabled: true
 
+Lint/SafeNavigationConsistency:
+  Description: >-
+                 Check to make sure that if safe navigation is used for a method
+                 call in an `&&` or `||` condition that safe navigation is used
+                 for all method calls on that same object.
+  Enabled: true
+
 Lint/ScriptPermission:
   Description: 'Grant script file execute permission.'
   Enabled: true
@@ -1056,6 +1063,12 @@ Performance/UnfreezeString:
   Description: 'Use unary plus to get an unfrozen string literal.'
   Enabled: true
 
+Performance/UnneededSort:
+  Description: >-
+                  Use `min` instead of `sort.first`,
+                  `max_by` instead of `sort_by...last`, etc.
+  Enabled: true
+
 Performance/UriDefaultParser:
   Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'
   Enabled: true

data/lib/rubocop.rb

@@ -293,6 +293,7 @@ require_relative 'rubocop/cop/lint/require_parentheses'
 require_relative 'rubocop/cop/lint/rescue_exception'
 require_relative 'rubocop/cop/lint/rescue_type'
 require_relative 'rubocop/cop/lint/return_in_void_context'
+require_relative 'rubocop/cop/lint/safe_navigation_consistency'
 require_relative 'rubocop/cop/lint/safe_navigation_chain'
 require_relative 'rubocop/cop/lint/script_permission'
 require_relative 'rubocop/cop/lint/shadowed_argument'
@@ -370,6 +371,7 @@ require_relative 'rubocop/cop/performance/start_with'
 require_relative 'rubocop/cop/performance/string_replacement'
 require_relative 'rubocop/cop/performance/times_map'
 require_relative 'rubocop/cop/performance/unfreeze_string'
+require_relative 'rubocop/cop/performance/unneeded_sort'
 require_relative 'rubocop/cop/performance/uri_default_parser'
 
 require_relative 'rubocop/cop/style/alias'
@@ -598,6 +600,8 @@ require_relative 'rubocop/formatter/progress_formatter'
 require_relative 'rubocop/formatter/quiet_formatter'
 require_relative 'rubocop/formatter/tap_formatter'
 require_relative 'rubocop/formatter/worst_offenders_formatter'
+# relies on progress formatter
+require_relative 'rubocop/formatter/auto_gen_config_formatter'
 
 require_relative 'rubocop/formatter/formatter_set'
 

data/lib/rubocop/ast/node/mixin/binary_operator_node.rb

@@ -18,6 +18,26 @@ module RuboCop
       def rhs
         node_parts[1]
       end
+
+      # Returns all of the conditions, including nested conditions,
+      # of the binary operation.
+      #
+      # @return [Array<Node>] the left and right hand side of the binary
+      # operation and the let and right hand side of any nested binary
+      # operators
+      def conditions
+        lhs, rhs = *self
+        lhs = lhs.children.first if lhs.begin_type?
+        rhs = rhs.children.first if rhs.begin_type?
+
+        [lhs, rhs].each_with_object([]) do |side, collection|
+          if AST::Node::OPERATOR_KEYWORDS.include?(side.type)
+            collection.concat(side.conditions)
+          else
+            collection << side
+          end
+        end
+      end
     end
   end
 end

data/lib/rubocop/cli.rb

@@ -178,8 +178,12 @@ module RuboCop
       # This must be done after the options have already been processed,
       # because they can affect how ConfigStore behaves
       @options[:formatters] ||= begin
-        cfg = @config_store.for(Dir.pwd).for_all_cops
-        formatter = cfg['DefaultFormatter'] || 'progress'
+        if @options[:auto_gen_config]
+          formatter = 'autogenconf'
+        else
+          cfg = @config_store.for(Dir.pwd).for_all_cops
+          formatter = cfg['DefaultFormatter'] || 'progress'
+        end
         [[formatter, @options[:output_path]]]
       end
 

data/lib/rubocop/cop/commissioner.rb

@@ -11,10 +11,6 @@ module RuboCop
 
       attr_reader :errors
 
-      def self.callback_methods
-        Parser::Meta::NODE_TYPES.map { |type| :"on_#{type}" }
-      end
-
       def initialize(cops, forces = [], options = {})
         @cops = cops
         @forces = forces
@@ -24,30 +20,19 @@ module RuboCop
         reset_errors
       end
 
-      # In the dynamically generated methods below, a call to `super` is used
+      # Create methods like :on_send, :on_super, etc. They will be called
+      # during AST traversal and try to call corresponding methods on cops.
+      # A call to `super` is used
       # to continue iterating over the children of a node.
       # However, if we know that a certain node type (like `int`) never has
       # child nodes, there is no reason to pay the cost of calling `super`.
-      no_child_callbacks = NO_CHILD_NODES.map do |type|
-        :"on_#{type}"
-      end
-
-      callback_methods.each do |callback|
-        next unless method_defined?(callback)
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{callback}(node)
-            @callbacks[:"#{callback}"] ||= @cops.select do |cop|
-              cop.respond_to?(:"#{callback}")
-            end
-            @callbacks[:#{callback}].each do |cop|
-              with_cop_error_handling(cop, node) do
-                cop.send(:#{callback}, node)
-              end
-            end
-
-            #{!no_child_callbacks.include?(callback) && 'super'}
-          end
-        RUBY
+      Parser::Meta::NODE_TYPES.each do |node_type|
+        method_name = :"on_#{node_type}"
+        next unless method_defined?(method_name)
+        define_method(method_name) do |node|
+          trigger_responding_cops(method_name, node)
+          super(node) unless NO_CHILD_NODES.include?(node_type)
+        end
       end
 
       def investigate(processed_source)
@@ -63,6 +48,17 @@ module RuboCop
 
       private
 
+      def trigger_responding_cops(callback, node)
+        @callbacks[callback] ||= @cops.select do |cop|
+          cop.respond_to?(callback)
+        end
+        @callbacks[callback].each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.send(callback, node)
+          end
+        end
+      end
+
       def reset_errors
         @errors = Hash.new { |hash, k| hash[k] = [] }
       end

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

@@ -4,6 +4,39 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks for Windows-style line endings in the source code.
+      #
+      # @example EnforcedStyle: native (default)
+      #   # The `native` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on Windows, and LF is enforced on other platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on Windows.
+      #   puts 'Hello' # Return character is CR+LF on other than Windows.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on Windows.
+      #   puts 'Hello' # Return character is LF on other than Windows.
+      #
+      # @example EnforcedStyle: lf
+      #   # The `lf` style means that LF (Line Feed) is enforced on
+      #   # all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      # @example EnforcedStyle: crlf
+      #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
       class EndOfLine < Cop
         include ConfigurableEnforcedStyle
         include RangeHelp

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

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # Checks for spaces inside ordinary round parentheses.
       #
-      # @example
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that parentheses do not have spaces.
+      #
       #   # bad
       #   f( 3)
       #   g = (a + 3 )
@@ -13,21 +15,52 @@ module RuboCop
       #   # good
       #   f(3)
       #   g = (a + 3)
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that parentheses have a space at the
+      #   # beginning and end.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #
       class SpaceInsideParens < Cop
         include SurroundingSpace
         include RangeHelp
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Space inside parentheses detected.'.freeze
+        MSG       = 'Space inside parentheses detected.'.freeze
+        MSG_SPACE = 'No space inside parentheses detected.'.freeze
 
         def investigate(processed_source)
           @processed_source = processed_source
-          each_extraneous_space(processed_source.tokens) do |range|
-            add_offense(range, location: range)
+
+          if style == :space
+            each_missing_space(processed_source.tokens) do |range|
+              add_offense(range, location: range, message: MSG_SPACE)
+            end
+          else
+            each_extraneous_space(processed_source.tokens) do |range|
+              add_offense(range, location: range)
+            end
           end
         end
 
         def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
+          lambda do |corrector|
+            if style == :space
+              corrector.insert_before(range, ' ')
+            else
+              corrector.remove(range)
+            end
+          end
         end
 
         private
@@ -45,9 +78,35 @@ module RuboCop
           end
         end
 
+        def each_missing_space(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            next if can_be_ignored?(token1, token2)
+
+            next unless token2.line == token1.line && !token1.space_after?
+
+            if token1.left_parens?
+              yield range_between(token2.begin_pos, token2.begin_pos + 1)
+
+            elsif token2.right_parens?
+              yield range_between(token2.begin_pos, token2.end_pos)
+            end
+          end
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
+
+        def can_be_ignored?(token1, token2)
+          return true unless parens?(token1, token2)
+
+          # If the second token is a comment, that means that a line break
+          # follows, and that the rules for space inside don't apply.
+          return true if token2.comment?
+
+          # Ignore empty parens. # TODO: Could be configurable.
+          return true if token1.left_parens? && token2.right_parens?
+        end
       end
     end
   end

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

@@ -20,8 +20,10 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'.freeze
 
         def investigate(processed_source)
+          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             next unless line.end_with?(' ', "\t")
+            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, index + 1)
 
             range = source_range(processed_source.buffer,
                                  index + 1,
@@ -34,6 +36,24 @@ module RuboCop
         def autocorrect(range)
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def skip_heredoc?
+          cop_config.fetch('AllowInHeredoc', false)
+        end
+
+        def inside_heredoc?(heredoc_ranges, line_number)
+          heredoc_ranges.any? { |r| r.include?(line_number) }
+        end
+
+        def extract_heredoc_ranges(ast)
+          return [] unless ast
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            (body.first_line...body.last_line)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop check to make sure that if safe navigation is used for a method
+      # call in an `&&` or `||` condition that safe navigation is used for all
+      # method calls on that same object.
+      #
+      # @example
+      #   # bad
+      #   foo&.bar && foo.baz
+      #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
+      #   # bad
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
+      #   # good
+      #   foo.bar && foo.baz
+      #
+      #   # good
+      #   foo&.bar || foo&.baz
+      #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo&.baz)
+      #
+      class SafeNavigationConsistency < Cop
+        MSG = 'Ensure that safe navigation is used consistently ' \
+          'inside of `&&` and `||`.'.freeze
+
+        def on_csend(node)
+          return unless node.parent &&
+                        AST::Node::OPERATOR_KEYWORDS.include?(node.parent.type)
+          check(node)
+        end
+
+        def check(node)
+          ancestor = top_conditional_ancestor(node)
+          conditions = ancestor.conditions
+          safe_nav_receiver = node.receiver
+
+          method_calls = conditions.select(&:send_type?)
+          unsafe_method_calls = method_calls.select do |method_call|
+            safe_nav_receiver == method_call.receiver
+          end
+
+          unsafe_method_calls.each do |unsafe_method_call|
+            location =
+              node.loc.expression.join(unsafe_method_call.loc.expression)
+            add_offense(unsafe_method_call,
+                        location: location)
+          end
+        end
+
+        def autocorrect(node)
+          return unless node.dot?
+
+          lambda do |corrector|
+            corrector.insert_before(node.loc.dot, '&')
+          end
+        end
+
+        private
+
+        def top_conditional_ancestor(node)
+          parent = node.parent
+          unless parent &&
+                 (AST::Node::OPERATOR_KEYWORDS.include?(parent.type) ||
+                  (parent.begin_type? &&
+                   AST::Node::OPERATOR_KEYWORDS.include?(parent.parent.type)))
+            return node
+          end
+          top_conditional_ancestor(parent)
+        end
+      end
+    end
+  end
+end