rubocop 0.80.0 → 0.84.0

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for *rescue* blocks with no body.
       #
-      # @example AllowComments: false (default)
+      # @example
       #
       #   # bad
       #   def some_method
@@ -14,25 +14,11 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   def some_method
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
-      #   # bad
       #   begin
       #     do_something
       #   rescue
       #   end
       #
-      #   # bad
-      #   begin
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
       #   # good
       #   def some_method
       #     do_something
@@ -47,47 +33,56 @@ module RuboCop
       #     handle_exception
       #   end
       #
-      # @example AllowComments: true
+      # @example AllowComments: true (default)
       #
-      #   # bad
+      #   # good
       #   def some_method
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # bad
+      #   # good
       #   begin
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # good
+      # @example AllowComments: false
+      #
+      #   # bad
       #   def some_method
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
       #
-      #   # good
+      #   # bad
       #   begin
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
       class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
           return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
 
           add_offense(node)
         end
 
         private
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        def comment_between_rescue_and_end?(node)
+          end_line = nil
+          node.each_ancestor(:kwbegin) do |ancestor|
+            end_line = ancestor.loc.end.line
+            break
+          end
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end
       end
     end

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

@@ -16,9 +16,7 @@ module RuboCop
                                                 config, options)
           cop = new(config, options)
 
-          if processed_source.parser_error
-            cop.add_offense_from_error(processed_source.parser_error)
-          end
+          cop.add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
 
           processed_source.diagnostics.each do |diagnostic|
             cop.add_offense_from_diagnostic(diagnostic,

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

@@ -33,8 +33,6 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return false if target_ruby_version <= 2.3
-
           lambda do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end

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

@@ -38,9 +38,34 @@ module RuboCop
       #   def do_something(unused)
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
       class UnusedMethodArgument < Cop
         include UnusedArgument
 
+        def_node_matcher :not_implemented?, <<~PATTERN
+          {(send nil? :raise (const nil? :NotImplementedError))
+           (send nil? :fail ...)}
+        PATTERN
+
         def autocorrect(node)
           UnusedArgCorrector.correct(processed_source, node)
         end
@@ -51,16 +76,17 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? &&
                     cop_config['AllowUnusedKeywordArguments']
-
-          if cop_config['IgnoreEmptyMethods']
-            body = variable.scope.node.body
-
-            return if body.nil?
-          end
+          return if ignored_method?(variable.scope.node.body)
 
           super
         end
 
+        def ignored_method?(body)
+          cop_config['IgnoreEmptyMethods'] && body.nil? ||
+            cop_config['IgnoreNotImplementedMethods'] &&
+              not_implemented?(body)
+        end
+
         def message(variable)
           message = +"Unused method argument - `#{variable.name}`."
 

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

@@ -21,7 +21,7 @@ module RuboCop
         def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
-            (str $_))
+            ${(str _) (array ...)})
         PATTERN
 
         def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
@@ -32,7 +32,7 @@ module RuboCop
         def on_send(node)
           uri_regexp_with_argument?(node) do |double_colon, arg|
             register_offense(
-              node, top_level: double_colon ? '::' : '', arg: "('#{arg}')"
+              node, top_level: double_colon ? '::' : '', arg: "(#{arg.source})"
             )
           end
 
@@ -51,10 +51,10 @@ module RuboCop
             double_colon, arg = captured_values
 
             top_level = double_colon ? '::' : ''
-            argument = arg ? "('#{arg}')" : ''
+            argument = arg ? "(#{arg.source})" : ''
 
             corrector.replace(
-              node.loc.expression,
+              node,
               "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
             )
           end

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

@@ -125,6 +125,8 @@ module RuboCop
       #     delegate :method_a, to: :method_b
       #   end
       class UselessAccessModifier < Cop
+        include RangeHelp
+
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
@@ -145,6 +147,16 @@ module RuboCop
           check_node(node.children[1]) # singleton class body
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.remove(range)
+          end
+        end
+
         private
 
         def_node_matcher :static_method_definition?, <<~PATTERN
@@ -215,9 +227,7 @@ module RuboCop
             add_offense(node, message: format(MSG, current: cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            if unused
-              add_offense(unused, message: format(MSG, current: cur_vis))
-            end
+            add_offense(unused, message: format(MSG, current: cur_vis)) if unused
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node

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

@@ -31,7 +31,6 @@ module RuboCop
       #     do_something(some_var)
       #   end
       class UselessAssignment < Cop
-        include NameSimilarity
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def join_force?(force_class)
@@ -94,7 +93,9 @@ module RuboCop
         end
 
         def similar_name_message(variable)
-          similar_name = find_similar_name(variable.name, variable.scope)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name,
+                                                          variable_like_names)
           " Did you mean `#{similar_name}`?" if similar_name
         end
 

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

@@ -40,6 +40,11 @@ module RuboCop
           diagnostic.reason == :useless_else
         end
 
+        def find_offense_node_by(diagnostic)
+          # TODO: When implementing auto-correction, this method should return
+          # an offense node passed as first argument of `add_offense` method.
+        end
+
         def alternative_message(_diagnostic)
           MSG
         end

data/lib/rubocop/cop/migration/department_name.rb

@@ -14,19 +14,22 @@ module RuboCop
           /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
 
         # The token that makes up a disable comment.
-        # The token used after `# rubocop: disable` are `A-z`, `/`, and `,`.
-        # Also `A-z` includes `all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z/,]+}.freeze
+        # The allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
-            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
-              break unless valid_content_token?(name.strip)
 
-              check_cop_name(name, comment, offset)
+            Regexp.last_match(4).scan(/[^,]+|[\W]+/) do |name|
+              trimmed_name = name.strip
+
+              check_cop_name(trimmed_name, comment, offset) unless valid_content_token?(trimmed_name)
+
+              break if contain_unexpected_character_for_department_name?(name)
 
               offset += name.length
             end
@@ -38,25 +41,31 @@ module RuboCop
           cop_name = range.source
           qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
                                                                nil, shall_warn)
-          unless qualified_cop_name.include?('/')
-            qualified_cop_name = qualified_legacy_cop_name(cop_name)
-          end
+          qualified_cop_name = qualified_legacy_cop_name(cop_name) unless qualified_cop_name.include?('/')
 
           ->(corrector) { corrector.replace(range, qualified_cop_name) }
         end
 
         private
 
-        def check_cop_name(name, comment, offset)
-          return if name !~ /^[A-Z]/ || name =~ %r{/}
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
 
+        def check_cop_name(name, comment, offset)
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
+
           add_offense(range, location: range)
         end
 
         def valid_content_token?(content_token)
-          !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+          !/\W+/.match(content_token).nil? ||
+            !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
+
+        def contain_unexpected_character_for_department_name?(name)
+          name.match?(%r{[^A-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)

data/lib/rubocop/cop/mixin/alignment.rb

@@ -25,9 +25,7 @@ module RuboCop
       end
 
       def check_alignment(items, base_column = nil)
-        unless items.empty?
-          base_column ||= display_column(items.first.source_range)
-        end
+        base_column ||= display_column(items.first.source_range) unless items.empty?
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range

data/lib/rubocop/cop/mixin/array_min_size.rb

@@ -38,9 +38,7 @@ module RuboCop
       def largest_brackets_size(style, ary_size)
         self.class.largest_brackets ||= -Float::INFINITY
 
-        if style == :brackets && ary_size > self.class.largest_brackets
-          self.class.largest_brackets = ary_size
-        end
+        self.class.largest_brackets = ary_size if style == :brackets && ary_size > self.class.largest_brackets
 
         self.class.largest_brackets
       end
@@ -48,9 +46,7 @@ module RuboCop
       def smallest_percent_size(style, ary_size)
         @smallest_percent ||= Float::INFINITY
 
-        if style == :percent && ary_size < @smallest_percent
-          @smallest_percent = ary_size
-        end
+        @smallest_percent = ary_size if style == :percent && ary_size < @smallest_percent
 
         @smallest_percent
       end

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -88,9 +88,7 @@ module RuboCop
         # or redundant edits, we only mark one offense at a time.
         return true if contained_by_breakable_collection_on_same_line?(node)
 
-        if contained_by_multiline_collection_that_could_be_broken_up?(node)
-          return true
-        end
+        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
 
         false
       end
@@ -133,17 +131,13 @@ module RuboCop
       def contained_by_multiline_collection_that_could_be_broken_up?(node)
         node.each_ancestor.find do |ancestor|
           if ancestor.hash_type? || ancestor.array_type?
-            if breakable_collection?(ancestor, ancestor.children)
-              return children_could_be_broken_up?(ancestor.children)
-            end
+            return children_could_be_broken_up?(ancestor.children) if breakable_collection?(ancestor, ancestor.children)
           end
 
           next unless ancestor.send_type?
 
           args = process_args(ancestor.arguments)
-          if breakable_collection?(ancestor, args)
-            return children_could_be_broken_up?(args)
-          end
+          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
         end
 
         false
@@ -175,9 +169,7 @@ module RuboCop
         # ...then each key/value pair is treated as a method 'argument'
         # when determining where line breaks should appear.
         if (last_arg = args.last)
-          if last_arg.hash_type? && !last_arg.braces?
-            args = args.concat(args.pop.children)
-          end
+          args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
         end
         args
       end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -67,9 +67,7 @@ module RuboCop
       def style
         @style ||= begin
           s = cop_config[style_parameter_name].to_sym
-          unless supported_styles.include?(s)
-            raise "Unknown style #{s} selected!"
-          end
+          raise "Unknown style #{s} selected!" unless supported_styles.include?(s)
 
           s
         end

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -18,9 +18,7 @@ module RuboCop
 
       def report_opposing_styles(node, name)
         alternative_styles.each do |alternative|
-          if valid_name?(node, name, alternative)
-            return unexpected_style_detected(alternative)
-          end
+          return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
       end
 

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -20,7 +20,7 @@ module RuboCop
         return if ignored_node?(node)
 
         end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
+        return if accept_end_kw_alignment?(end_loc)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -49,6 +49,11 @@ module RuboCop
         add_offense(node, location: end_loc, message: msg)
       end
 
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+      end
+
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end