rubocop 0.52.1 → 0.53.0

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

@@ -15,6 +15,8 @@ module RuboCop
       #   attr_reader :one, :two, :three
       #
       class Attr < Cop
+        include RangeHelp
+
         MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'.freeze
 
         def on_send(node)

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

@@ -17,12 +17,14 @@ module RuboCop
       #   # of comments...
       #
       class BlockComments < Cop
+        include RangeHelp
+
         MSG = 'Do not use block comments.'.freeze
         BEGIN_LENGTH = "=begin\n".length
         END_LENGTH = "\n=end".length
 
         def investigate(processed_source)
-          processed_source.comments.each do |comment|
+          processed_source.each_comment do |comment|
             next unless comment.document?
 
             add_offense(comment)

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

@@ -41,6 +41,7 @@ module RuboCop
       #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG = '%<type>s curly braces around a hash parameter.'.freeze
 
@@ -129,7 +130,7 @@ module RuboCop
         def remove_braces_with_whitespace(corrector, node, space)
           right_brace_and_space = right_brace_and_space(node.loc.end, space)
 
-          if comment_on_line?(right_brace_and_space.line)
+          if processed_source.comment_on_line?(right_brace_and_space.line)
             remove_braces(corrector, node)
           elsif node.multiline?
             remove_braces_with_range(corrector,
@@ -183,10 +184,6 @@ module RuboCop
           range_with_surrounding_comma(brace_and_space, :left)
         end
 
-        def comment_on_line?(line)
-          processed_source.comments.any? { |c| c.loc.line == line }
-        end
-
         def remove_braces(corrector, node)
           corrector.remove(node.loc.begin)
           corrector.remove(node.loc.end)

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

@@ -23,6 +23,7 @@ module RuboCop
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
                      'compact style.'.freeze

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

@@ -6,6 +6,29 @@ module RuboCop
       # This cop checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
       # reduce the number of offenses that would be reported.
+      #
+      # Setting value for class variable need to take care.
+      # If some class has been inherited by other classes, setting value
+      # for class variable affected children classes.
+      # So using class instance variable is better in almost case.
+      #
+      # @example
+      #   # bad
+      #   class A
+      #     @@test = 10
+      #   end
+      #
+      #   # good
+      #   class A
+      #     @test = 10
+      #   end
+      #
+      #   class A
+      #     def test
+      #       @@test # you can access class variable without offence
+      #     end
+      #   end
+      #
       class ClassVars < Cop
         MSG = 'Replace class var %<class_var>s with a class ' \
               'instance var.'.freeze

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

@@ -22,8 +22,7 @@ module RuboCop
 
         def_node_matcher :java_type_node?, <<-PATTERN
           (send
-            (const nil? :Java)
-            {:boolean :byte :char :double :float :int :long :short})
+            (const nil? :Java) _)
         PATTERN
 
         def self.autocorrect_incompatible_with

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

@@ -32,6 +32,7 @@ module RuboCop
       #   # OPTIMIZE: does not work
       class CommentAnnotation < Cop
         include AnnotationComment
+        include RangeHelp
 
         MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
               'upper case, followed by a colon, and a space, ' \
@@ -40,8 +41,8 @@ module RuboCop
                        'is missing a note.'.freeze
 
         def investigate(processed_source)
-          processed_source.comments.each_with_index do |comment, ix|
-            next unless first_comment_line?(processed_source.comments, ix)
+          processed_source.comments.each_with_index do |comment, index|
+            next unless first_comment_line?(processed_source.comments, index)
 
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
@@ -68,8 +69,9 @@ module RuboCop
 
         private
 
-        def first_comment_line?(comments, ix)
-          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        def first_comment_line?(comments, index)
+          index.zero? ||
+            comments[index - 1].loc.line < comments[index].loc.line - 1
         end
 
         def annotation_range(comment, margin, length)

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

@@ -33,13 +33,15 @@ module RuboCop
       #     y
       #   end
       class CommentedKeyword < Cop
+        include RangeHelp
+
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'.freeze
 
         def investigate(processed_source)
           heredoc_lines = extract_heredoc_lines(processed_source.ast)
 
-          processed_source.comments.each do |comment|
+          processed_source.each_comment do |comment|
             location = comment.location
             line_position = location.line
             line = processed_source.lines[line_position - 1]

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

@@ -9,7 +9,7 @@ module RuboCop
         extend NodePattern::Macros
 
         EQUAL = '='.freeze
-        END_ALIGNMENT = 'Lint/EndAlignment'.freeze
+        END_ALIGNMENT = 'Layout/EndAlignment'.freeze
         ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
         KEYWORD = 'keyword'.freeze
 

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

@@ -16,6 +16,8 @@ module RuboCop
       # an offense is reported.
       #
       class Copyright < Cop
+        include RangeHelp
+
         MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'.freeze
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
@@ -75,7 +77,7 @@ module RuboCop
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
-          processed_source.tokens.each do |token|
+          processed_source.each_token do |token|
             break unless token.comment?
             notice_found = !(token.text =~ notice_regexp).nil?
             break if notice_found

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

@@ -17,6 +17,8 @@ module RuboCop
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
       class EachWithObject < Cop
+        include RangeHelp
+
         MSG = 'Use `each_with_object` instead of `%<method>s`.'.freeze
         METHODS = %i[inject reduce].freeze
 
@@ -51,7 +53,11 @@ module RuboCop
 
             return_value = return_value(node.body)
 
-            corrector.remove(return_value.loc.expression)
+            if return_value_occupies_whole_line?(return_value)
+              corrector.remove(whole_line_expression(return_value))
+            else
+              corrector.remove(return_value.loc.expression)
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize
@@ -90,6 +96,14 @@ module RuboCop
 
           accumulator_var == return_var
         end
+
+        def return_value_occupies_whole_line?(node)
+          whole_line_expression(node).source.strip == node.source
+        end
+
+        def whole_line_expression(node)
+          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+        end
       end
     end
   end

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

@@ -23,6 +23,7 @@ module RuboCop
       #   a { do_something }
       class EmptyBlockParameter < Cop
         include EmptyParameter
+        include RangeHelp
 
         MSG = 'Omit pipes for the empty block parameters.'.freeze
 

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

@@ -36,6 +36,8 @@ module RuboCop
       #     puts 'more'
       #   end
       class EmptyCaseCondition < Cop
+        include RangeHelp
+
         MSG = 'Do not use empty `case` condition, instead use an `if` '\
               'expression.'.freeze
 

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

@@ -92,6 +92,7 @@ module RuboCop
       class EmptyElse < Cop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG = 'Redundant `else`-clause.'.freeze
 
@@ -108,7 +109,7 @@ module RuboCop
           return false if comment_in_else?(node)
 
           lambda do |corrector|
-            end_pos = base_if_node(node).loc.end.begin_pos
+            end_pos = base_node(node).loc.end.begin_pos
             corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
           end
         end
@@ -142,7 +143,7 @@ module RuboCop
 
         def comment_in_else?(node)
           range = else_line_range(node.loc)
-          processed_source.comments.find { |c| range.include?(c.loc.line) }
+          processed_source.find_comment { |c| range.include?(c.loc.line) }
         end
 
         def else_line_range(loc)
@@ -150,9 +151,12 @@ module RuboCop
           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
+        def base_node(node)
+          return node if node.case_type?
+          return node unless node.elsif?
+          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
+            parent.loc.end
+          end
         end
 
         def autocorrect_forbidden?(type)

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

@@ -18,6 +18,7 @@ module RuboCop
       #   -> (arg) { do_something(arg) }
       class EmptyLambdaParameter < Cop
         include EmptyParameter
+        include RangeHelp
 
         MSG = 'Omit parentheses for the empty lambda parameters.'.freeze
 

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces empty line after guard clause
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo
+      #     return if need_return?
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if need_return?
+      #
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if something?
+      #     return if something_different?
+      #
+      #     bar
+      #   end
+      #
+      #   # also good
+      #   def foo
+      #     if something?
+      #       do_something
+      #       return if need_return?
+      #     end
+      #   end
+      class EmptyLineAfterGuardClause < Cop
+        include RangeHelp
+
+        MSG = 'Add empty line after guard clause.'.freeze
+
+        def on_if(node)
+          return unless contains_guard_clause?(node)
+
+          return if node.parent.nil? || node.parent.single_line?
+          return if next_sibling_empty_or_guard_clause?(node)
+
+          return if next_line_empty?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node_range = range_by_whole_lines(node.source_range)
+            corrector.insert_after(node_range, "\n")
+          end
+        end
+
+        private
+
+        def contains_guard_clause?(node)
+          node.if_branch && node.if_branch.guard_clause?
+        end
+
+        def next_line_empty?(node)
+          processed_source[node.last_line].blank?
+        end
+
+        def next_sibling_empty_or_guard_clause?(node)
+          next_sibling = node.parent.children[node.sibling_index + 1]
+          return true if next_sibling.nil?
+
+          next_sibling.if_type? && contains_guard_clause?(next_sibling)
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,7 @@ module RuboCop
       #   s = ''
       class EmptyLiteral < Cop
         include FrozenStringLiteral
+        include RangeHelp
 
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # This cop checks ensures source files have no utf-8 encoding comments.
       class Encoding < Cop
+        include RangeHelp
+
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
         SHEBANG = '#!'.freeze

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for use of the `File.expand_path` arguments.
+      # Likewise, it also checks for the `Pathname.new` argument.
+      #
+      # Contrastive bad case and good case are alternately shown in
+      # the following examples.
+      #
+      # @example
+      #   # bad
+      #   File.expand_path('..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__dir__)
+      #
+      #   # bad
+      #   File.expand_path('../..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path('..', __dir__)
+      #
+      #   # bad
+      #   File.expand_path('.', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__FILE__)
+      #
+      #   # bad
+      #   Pathname(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname(__dir__).expand_path
+      #
+      #   # bad
+      #   Pathname.new(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname.new(__dir__).expand_path
+      #
+      class ExpandPathArguments < Cop
+        include RangeHelp
+
+        MSG = 'Use `expand_path(%<new_path>s%<new_default_dir>s)` instead of ' \
+              '`expand_path(%<current_path>s, __FILE__)`.'.freeze
+        PATHNAME_MSG = 'Use `Pathname(__dir__).expand_path` instead of ' \
+                       '`Pathname(__FILE__).parent.expand_path`.'.freeze
+        PATHNAME_NEW_MSG = 'Use `Pathname.new(__dir__).expand_path` ' \
+                           'instead of ' \
+                           '`Pathname.new(__FILE__).parent.expand_path`.'.freeze
+
+        def_node_matcher :file_expand_path, <<-PATTERN
+          (send
+            (const nil? :File) :expand_path
+            $_
+            $_)
+        PATTERN
+
+        def_node_matcher :pathname_parent_expand_path, <<-PATTERN
+          (send
+            (send
+              (send nil? :Pathname
+                $_) :parent) :expand_path)
+        PATTERN
+
+        def_node_matcher :pathname_new_parent_expand_path, <<-PATTERN
+          (send
+            (send
+              (send
+                (const nil? :Pathname) :new
+                $_) :parent) :expand_path)
+        PATTERN
+
+        def on_send(node)
+          if (captured_values = file_expand_path(node))
+            current_path, default_dir = captured_values
+
+            inspect_offense_for_expand_path(node, current_path, default_dir)
+          elsif (default_dir = pathname_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_MSG)
+          elsif (default_dir = pathname_new_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_NEW_MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if (captured_values = file_expand_path(node))
+              current_path, default_dir = captured_values
+
+              autocorrect_expand_path(corrector, current_path, default_dir)
+            elsif (default_dir = pathname_parent_expand_path(node)) ||
+                  (default_dir = pathname_new_parent_expand_path(node))
+              corrector.replace(default_dir.loc.expression, '__dir__')
+              remove_parent_method(corrector, default_dir)
+            end
+          end
+        end
+
+        private
+
+        def unrecommended_argument?(default_dir)
+          default_dir.source == '__FILE__'
+        end
+
+        def inspect_offense_for_expand_path(node, current_path, default_dir)
+          return unless unrecommended_argument?(default_dir) &&
+                        current_path.str_type?
+
+          current_path = strip_surrounded_quotes!(current_path.source)
+
+          parent_path = parent_path(current_path)
+          new_path = parent_path == '' ? '' : "'#{parent_path}', "
+
+          new_default_dir = depth(current_path).zero? ? '__FILE__' : '__dir__'
+
+          message = format(
+            MSG,
+            new_path: new_path,
+            new_default_dir: new_default_dir,
+            current_path: "'#{current_path}'"
+          )
+
+          add_offense(node, location: :selector, message: message)
+        end
+
+        def autocorrect_expand_path(corrector, current_path, default_dir)
+          stripped_current_path = strip_surrounded_quotes!(current_path.source)
+
+          case depth(stripped_current_path)
+          when 0
+            range = arguments_range(current_path)
+
+            corrector.replace(range, '__FILE__')
+          when 1
+            range = arguments_range(current_path)
+
+            corrector.replace(range, '__dir__')
+          else
+            new_path = "'#{parent_path(stripped_current_path)}'"
+
+            corrector.replace(current_path.loc.expression, new_path)
+            corrector.replace(default_dir.loc.expression, '__dir__')
+          end
+        end
+
+        def strip_surrounded_quotes!(path_string)
+          path_string.slice!(path_string.length - 1)
+          path_string.slice!(0)
+
+          path_string
+        end
+
+        def depth(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.reject { |path| path == '.' }.count
+        end
+
+        def parent_path(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.delete('.')
+          paths.each_with_index do |path, index|
+            if path == '..'
+              paths.delete_at(index)
+              break
+            end
+          end
+
+          paths.join(File::SEPARATOR)
+        end
+
+        def remove_parent_method(corrector, default_dir)
+          node = default_dir.parent.parent.parent.children.first
+
+          corrector.remove(node.loc.dot)
+          corrector.remove(node.loc.selector)
+        end
+
+        def arguments_range(node)
+          range_between(node.parent.first_argument.source_range.begin_pos,
+                        node.parent.last_argument.source_range.end_pos)
+        end
+      end
+    end
+  end
+end