rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,38 +6,37 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
-      # SupportedStyles:
+      # @example EnforcedStyle: empty
+      #   # warn only on empty else
       #
-      # @example
-      #   # good for all styles
+      #   # bad
       #   if condition
       #     statement
       #   else
-      #     statement
       #   end
       #
-      #   # good for all styles
+      #   # good
       #   if condition
       #     statement
+      #   else
+      #     nil
       #   end
       #
-      # empty - warn only on empty else
-      #   @example
-      #   # bad
+      #   # good
       #   if condition
       #     statement
       #   else
+      #     statement
       #   end
       #
       #   # good
       #   if condition
       #     statement
-      #   else
-      #     nil
       #   end
       #
-      # nil - warn on else with nil in it
-      #   @example
+      # @example EnforcedStyle: nil
+      #   # warn on else with nil in it
+      #
       #   # bad
       #   if condition
       #     statement
@@ -52,8 +50,21 @@ module RuboCop
       #   else
       #   end
       #
-      # both - warn on empty else and else with nil in it
-      #   @example
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
+      #
       #   # bad
       #   if condition
       #     statement
@@ -66,6 +77,18 @@ module RuboCop
       #     statement
       #   else
       #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
       class EmptyElse < Cop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -73,64 +96,72 @@ module RuboCop
         MSG = 'Redundant `else`-clause.'.freeze
 
         def on_normal_if_unless(node)
-          check(node, if_else_clause(node))
+          check(node)
         end
 
         def on_case(node)
-          check(node, case_else_clause(node))
+          check(node)
         end
 
-        private
+        def autocorrect(node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node)
 
-        def check(node, else_clause)
-          case style
-          when :empty
-            empty_check(node, else_clause)
-          when :nil
-            nil_check(node, else_clause)
-          when :both
-            both_check(node, else_clause)
+          lambda do |corrector|
+            end_pos = base_if_node(node).loc.end.begin_pos
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
           end
         end
 
-        def empty_check(node, else_clause)
-          add_offense(node, :else, MSG) if node.loc.else && else_clause.nil?
+        private
+
+        def check(node)
+          empty_check(node) if empty_style?
+          nil_check(node) if nil_style?
         end
 
-        def nil_check(node, else_clause)
-          return unless else_clause && else_clause.nil_type?
-          add_offense(node, :else, MSG)
+        def nil_style?
+          style == :nil || style == :both
         end
 
-        def both_check(node, else_clause)
-          empty_check(node, else_clause)
-          nil_check(node, else_clause)
+        def empty_style?
+          style == :empty || style == :both
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
+        def empty_check(node)
+          return unless node.else? && !node.else_branch
 
-          lambda do |corrector|
-            end_pos = if node.loc.end
-                        node.loc.end.begin_pos
-                      else
-                        node.parent.loc.end.begin_pos
-                      end
-
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              node.loc.else.begin_pos,
-                                              end_pos)
-            corrector.remove(range)
-          end
+          add_offense(node, location: :else)
+        end
+
+        def nil_check(node)
+          return unless node.else_branch && node.else_branch.nil_type?
+
+          add_offense(node, location: :else)
+        end
+
+        def comment_in_else?(node)
+          range = else_line_range(node.loc)
+          processed_source.comments.find { |c| range.include?(c.loc.line) }
+        end
+
+        def else_line_range(loc)
+          return 0..0 if loc.else.nil? || loc.end.nil?
+          loc.else.first_line..loc.end.first_line
+        end
+
+        def base_if_node(node)
+          return node unless node.case_type? || node.elsif?
+          node.each_ancestor(:if).find { |parent| parent.loc.end } || node
         end
 
         def autocorrect_forbidden?(type)
-          [type, 'both'].include? missing_else_style
+          [type, 'both'].include?(missing_else_style)
         end
 
         def missing_else_style
-          missing_config = config.for_cop('Style/MissingElse')
-          missing_config['Enabled'] ? missing_config['EnforcedStyle'] : nil
+          missing_cfg = config.for_cop('Style/MissingElse')
+          missing_cfg.fetch('Enabled') ? missing_cfg['EnforcedStyle'] : nil
         end
       end
     end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # for empty lambda parameters do not cause syntax errors, but they are
+      # redundant.
+      #
+      # @example
+      #   # bad
+      #   -> () { do_something }
+      #
+      #   # good
+      #   -> { do_something }
+      #
+      #   # good
+      #   -> (arg) { do_something(arg) }
+      class EmptyLambdaParameter < Cop
+        include EmptyParameter
+
+        MSG = 'Omit parentheses for the empty lambda parameters.'.freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless send_node.send_type?
+          check(node) if node.send_node.stabby_lambda?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.send_node
+            range = range_between(
+              send_node.loc.expression.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,63 +5,50 @@ module RuboCop
     module Style
       # This cop checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
       class EmptyLiteral < Cop
         include FrozenStringLiteral
 
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
-        STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
-
-        # Empty array node
-        #
-        # (send
-        #   (const nil :Array) :new)
-        ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
-
-        # Empty hash node
-        #
-        # (send
-        #   (const nil :Hash) :new)
-        HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
-
-        # Empty string node
-        #
-        # (send
-        #   (const nil :String) :new)
-        STR_NODE = s(:send, s(:const, nil, :String), :new)
+        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
+                  '`String.new`.'.freeze
+
+        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
+        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
+        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_with_block,
+                         '(block (send (const nil? :Array) :new) args _)'
+        def_node_matcher :hash_with_block,
+                         '(block (send (const nil? :Hash) :new) args _)'
 
         def on_send(node)
-          case node
-          when ARRAY_NODE
-            add_offense(node, :expression, ARR_MSG)
-          when HASH_NODE
-            # If Hash.new takes a block, it can't be changed to {}.
-            return if node.parent && node.parent.block_type?
-
-            add_offense(node, :expression, HASH_MSG)
-          when STR_NODE
-            return if frozen_string_literals_enabled?(processed_source)
-
-            add_offense(node, :expression,
-                        format(STR_MSG, preferred_string_literal))
+          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
+          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
+
+          str_node(node) do
+            return if frozen_string_literals_enabled?
+
+            add_offense(node,
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
           end
         end
 
         def autocorrect(node)
-          name = case node
-                 when ARRAY_NODE
-                   '[]'
-                 when HASH_NODE
-                   # `some_method {}` is not same as `some_method Hash.new`
-                   # because the braces are interpreted as a block, so we avoid
-                   # the correction. Parentheses around the arguments would
-                   # solve the problem, but we let the user add those manually.
-                   return if first_arg_in_method_call_without_parentheses?(node)
-                   '{}'
-                 when STR_NODE
-                   preferred_string_literal
-                 end
-          ->(corrector) { corrector.replace(node.source_range, name) }
+          lambda do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
         end
 
         private
@@ -79,12 +65,54 @@ module RuboCop
           config.for_cop('Style/StringLiterals')
         end
 
-        def first_arg_in_method_call_without_parentheses?(node)
+        def first_argument_unparenthesized?(node)
           return false unless node.parent && node.parent.send_type?
 
           _receiver, _method_name, *args = *node.parent
           node.object_id == args.first.object_id && !parentheses?(node.parent)
         end
+
+        def replacement_range(node)
+          if hash_node(node) &&
+             first_argument_unparenthesized?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            _receiver, _method_name, *args = *node.parent
+
+            range_between(args[0].loc.expression.begin_pos - 1,
+                          args[-1].loc.expression.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
+        def correction(node)
+          if offense_array_node?(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif offense_hash_node?(node)
+            if first_argument_unparenthesized?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              _receiver, _method_name, *args = *node.parent
+              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style).
+      #
+      # Note: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example EnforcedStyle: compact (default)
+      #   # bad
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      #
+      #   # good
+      #   def foo(bar); end
+      #
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   def self.foo(bar); end
+      #
+      # @example EnforcedStyle: expanded
+      #   # bad
+      #   def foo(bar); end
+      #
+      #   def self.foo(bar); end
+      #
+      #   # good
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'.freeze
+
+        def on_def(node)
+          return if node.body || comment_lines?(node)
+          return if correct_style?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node))
+          end
+        end
+
+        private
+
+        def message(_node)
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def correct_style?(node)
+          compact_style? && compact?(node) ||
+            expanded_style? && expanded?(node)
+        end
+
+        def corrected(node)
+          arguments = node.arguments? ? node.arguments.source : ''
+          scope     = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
+
+        def joint(node)
+          indent = ' ' * node.loc.column
+
+          compact_style? ? '; ' : "\n#{indent}"
+        end
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end

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

@@ -1,26 +1,12 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the source file has a utf-8 encoding
-      # comment or not.
-      # Setting this check to "always" and "when_needed" makes sense only
-      # for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
-      # default source file encoding. There are three styles:
-      #
-      # when_needed - only enforce an encoding comment if there are non ASCII
-      #               characters, otherwise report an offense
-      # always - enforce encoding comment in all files
-      # never - enforce no encoding comment in all files
+      # This cop checks ensures source files have no utf-8 encoding comments.
       class Encoding < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG_MISSING = 'Missing utf-8 encoding comment.'.freeze
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
-        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
@@ -30,24 +16,13 @@ module RuboCop
           return unless (@message = offense(processed_source, line_number))
 
           range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, range, @message)
+          add_offense(range, location: range, message: @message)
         end
 
         def autocorrect(range)
-          if @message == MSG_MISSING
-            encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
-            if encoding && encoding =~ ENCODING_PATTERN
-              lambda do |corrector|
-                corrector.insert_before(range, "#{encoding}\n")
-              end
-            else
-              raise "#{encoding} does not match #{ENCODING_PATTERN}"
-            end
-          else
-            # Need to remove unnecessary encoding comment
-            lambda do |corrector|
-              corrector.remove(range_with_surrounding_space(range, :right))
-            end
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
           end
         end
 
@@ -55,17 +30,12 @@ module RuboCop
 
         def offense(processed_source, line_number)
           line = processed_source[line_number]
-          encoding_present = line =~ ENCODING_PATTERN
-          ascii_only = processed_source.buffer.source.ascii_only?
-          always_encode = style == :always
-          never_encode = style == :never
-          encoding_omitable = never_encode || (!always_encode && ascii_only)
 
-          if !encoding_present && !encoding_omitable
-            MSG_MISSING
-          elsif encoding_present && encoding_omitable
-            MSG_UNNECESSARY
-          end
+          MSG_UNNECESSARY if encoding_omitable?(line)
+        end
+
+        def encoding_omitable?(line)
+          line =~ ENCODING_PATTERN
         end
 
         def encoding_line_number(processed_source)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,7 +9,7 @@ module RuboCop
               'Use `Kernel#at_exit` instead.'.freeze
 
         def on_postexe(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end