rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,30 +5,39 @@ module RuboCop
     module Style
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'.freeze
 
-        JAVA_TYPES = [:byte, :boolean, :byte, :short, :char,
-                      :int, :long, :float, :double].freeze
+        def_node_matcher :java_type_node?, <<-PATTERN
+          (send
+            (const nil? :Java)
+            {:boolean :byte :char :double :float :int :long :short})
+        PATTERN
 
-        JAVA_TYPE_NODES =
-          JAVA_TYPES.map { |t| s(:send, s(:const, nil, :Java), t) }
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
 
         def on_send(node)
           # ignore Java interop code like Java::int
-          return if JAVA_TYPE_NODES.include?(node)
-
-          receiver, method_name, *_args = *node
+          return if java_type_node?(node)
 
-          # discard methods with nil receivers and op methods(like [])
-          return unless receiver && node.loc.dot && node.loc.dot.is?('::')
-          return if allowed_name(method_name.to_s)
-
-          add_offense(node, :dot)
-        end
+          return unless node.receiver && node.double_colon?
+          return if node.camel_case_method?
 
-        def allowed_name(method_name)
-          method_name.match(/^[A-Z]/)
+          add_offense(node, location: :dot)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Cop
+        MSG = 'Do not use `::` for defining class methods.'.freeze
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+          add_offense(node, location: :operator)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,26 +5,75 @@ module RuboCop
     module Style
       # This cop enforces using `` or %x around command literals.
       #
-      # @example
-      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
       #   folders = `find . -type d`.split
       #
-      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   folders = %x(find . -type d).split
       #
-      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
       #   `
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   `
       #
-      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
       #   %x(
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   )
       #
-      #   # Bad unless AllowInnerBackticks is true.
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
       #   `echo \`ls\``
       class CommandLiteral < Cop
         include ConfigurableEnforcedStyle
@@ -43,24 +91,57 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+
         private
 
         def check_backtick_literal(node)
-          return if style == :backticks && !contains_disallowed_backtick?(node)
-          return if style == :mixed &&
-                    node.single_line? &&
-                    !contains_disallowed_backtick?(node)
+          return if allowed_backtick_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_PERCENT_X)
+          add_offense(node)
         end
 
         def check_percent_x_literal(node)
-          return if style == :backticks && contains_disallowed_backtick?(node)
-          return if style == :percent_x
-          return if style == :mixed && node.multiline?
-          return if style == :mixed && contains_disallowed_backtick?(node)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node)
+        end
+
+        def message(node)
+          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        end
+
+        def allowed_backtick_literal?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
+        end
 
-          add_offense(node, :expression, MSG_USE_BACKTICKS)
+        def allowed_percent_x_literal?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
         end
 
         def contains_disallowed_backtick?(node)
@@ -92,21 +173,6 @@ module RuboCop
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%x'].split(//)
         end
-
-        def autocorrect(node)
-          return if contains_backtick?(node)
-
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w(` `)
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
-        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,13 +5,38 @@ module RuboCop
     module Style
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
+      #
+      # @example
+      #   # bad
+      #   # TODO make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # TODO:make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # fixme: does not work
+      #
+      #   # good
+      #   # FIXME: does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE: does not work
       class CommentAnnotation < Cop
         include AnnotationComment
 
-        MSG = 'Annotation keywords like `%s` should be all upper case, ' \
-              'followed by a colon, and a space, ' \
+        MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
+              'upper case, followed by a colon, and a space, ' \
               'then a note describing the problem.'.freeze
-        MISSING_NOTE = 'Annotation comment, with keyword `%s`, ' \
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
                        'is missing a note.'.freeze
 
         def investigate(processed_source)
@@ -24,17 +48,14 @@ module RuboCop
                         !correct_annotation?(first_word, colon, space, note)
 
             length = concat_length(first_word, colon, space)
-            add_offense(comment, annotation_range(comment, margin, length),
-                        format(note ? MSG : MISSING_NOTE, first_word))
+            add_offense(
+              comment,
+              location: annotation_range(comment, margin, length),
+              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
+            )
           end
         end
 
-        private
-
-        def first_comment_line?(comments, ix)
-          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
-        end
-
         def autocorrect(comment)
           margin, first_word, colon, space, note = split_comment(comment)
           return if note.nil?
@@ -45,14 +66,19 @@ module RuboCop
           ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
 
+        private
+
+        def first_comment_line?(comments, ix)
+          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        end
+
         def annotation_range(comment, margin, length)
           start = comment.loc.expression.begin_pos + margin.length
-          source_buffer = comment.loc.expression.source_buffer
-          Parser::Source::Range.new(source_buffer, start, start + length)
+          range_between(start, start + length)
         end
 
         def concat_length(*args)
-          args.reduce(0) { |a, e| a + e.to_s.length }
+          args.reduce(0) { |acc, elem| acc + elem.to_s.length }
         end
 
         def correct_annotation?(first_word, colon, space, note)

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for comments put on the same line as some keywords.
+      # These keywords are: `begin`, `class`, `def`, `end`, `module`.
+      #
+      # Note that some comments (such as `:nodoc:` and `rubocop:disable`) are
+      # allowed.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   end # end if
+      #
+      #   # bad
+      #   class X # comment
+      #     statement
+      #   end
+      #
+      #   # bad
+      #   def x; end # comment
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   class X # :nodoc:
+      #     y
+      #   end
+      class CommentedKeyword < Cop
+        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|
+            location = comment.location
+            line_position = location.line
+            line = processed_source.lines[line_position - 1]
+            next if heredoc_lines.any? { |r| r.include?(line_position) }
+            next unless offensive?(line)
+            range = source_range(processed_source.buffer,
+                                 line_position,
+                                 (location.column)...(location.last_column))
+
+            add_offense(range, location: range)
+          end
+        end
+
+        private
+
+        KEYWORDS = %w[begin class def end module].freeze
+        ALLOWED_COMMENTS = %w[:nodoc: rubocop:disable].freeze
+
+        def offensive?(line)
+          line = line.lstrip
+          KEYWORDS.any? { |word| line =~ /^#{word}\s/ } &&
+            ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
+        end
+
+        def message(node)
+          line = node.source_line
+          keyword = /^\s*(\S+).*#/.match(line)[1]
+          format(MSG, keyword: keyword)
+        end
+
+        def extract_heredoc_lines(ast)
+          return [] unless ast
+          ast.each_node.with_object([]) do |node, heredocs|
+            next unless node.location.is_a?(Parser::Source::Map::Heredoc)
+            body = node.location.heredoc_body
+            heredocs << (body.first_line...body.last_line)
+          end
+        end
+      end
+    end
+  end
+end