rubocop 0.49.1 → 0.52.0

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

@@ -5,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)
@@ -23,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?
@@ -44,6 +66,12 @@ 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
           range_between(start, start + length)

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
+          line.start_with?(*KEYWORDS) &&
+            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

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

@@ -6,6 +6,8 @@ module RuboCop
       # Helper module to provide common methods to classes needed for the
       # ConditionalAssignment Cop.
       module ConditionalAssignmentHelper
+        extend NodePattern::Macros
+
         EQUAL = '='.freeze
         END_ALIGNMENT = 'Lint/EndAlignment'.freeze
         ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
@@ -31,6 +33,7 @@ module RuboCop
           branch.begin_type? ? [*branch].last : branch
         end
 
+        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
@@ -47,6 +50,7 @@ module RuboCop
             node.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
           conf = cop.config.for_cop(END_ALIGNMENT)
@@ -104,9 +108,7 @@ module RuboCop
       # assignment to the same variable when using the return of the
       # condition can be used instead.
       #
-      # @example
-      #   EnforcedStyle: assign_to_condition
-      #
+      # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
       #   if foo
       #     bar = 1
@@ -151,7 +153,7 @@ module RuboCop
       #            2
       #          end
       #
-      #   EnforcedStyle: assign_inside_condition
+      # @example EnforcedStyle: assign_inside_condition
       #   # bad
       #   bar = if foo
       #           1
@@ -219,12 +221,12 @@ module RuboCop
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
-        def_node_matcher :assignment_type?, <<-END
+        def_node_matcher :assignment_type?, <<-PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
             (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
           }
-        END
+        PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
@@ -264,24 +266,38 @@ module RuboCop
           check_node(node, branches)
         end
 
+        def autocorrect(node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(node)
+          else
+            move_assignment_outside_condition(node)
+          end
+        end
+
         private
 
         def check_assignment_to_condition(node)
-          return unless style == :assign_inside_condition
-          return unless assignment_rhs_exist?(node)
+          return unless candidate_node?(node)
+
           ignore_node(node)
 
           assignment = assignment_node(node)
-          return unless condition?(assignment)
-          return if allowed_ternary?(assignment)
+          return unless candidate_condition?(assignment)
 
           _condition, *branches, else_branch = *assignment
-          return unless else_branch # empty else
+
+          return unless else_branch
           return if allowed_single_line?([*branches, else_branch])
 
-          add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
+          add_offense(node, message: ASSIGN_TO_CONDITION_MSG)
         end
 
+        def candidate_node?(node)
+          style == :assign_inside_condition && assignment_rhs_exist?(node)
+        end
+
+        def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
+
         def allowed_ternary?(assignment)
           assignment.if_type? && assignment.ternary? && !include_ternary?
         end
@@ -290,14 +306,6 @@ module RuboCop
           single_line_conditions_only? && branches.any?(&:begin_type?)
         end
 
-        def autocorrect(node)
-          if assignment_type?(node)
-            move_assignment_inside_condition(node)
-          else
-            move_assignment_outside_condition(node)
-          end
-        end
-
         def assignment_node(node)
           *_variable, assignment = *node
 
@@ -356,7 +364,7 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def allowed_statements?(branches)
@@ -380,36 +388,20 @@ module RuboCop
 
           assignment = lhs(tail(branches[0]))
 
-          longest_rhs_exceeds_line_limit?(branches, assignment) ||
-            longest_line_exceeds_line_limit?(node, assignment)
-        end
-
-        def longest_rhs_exceeds_line_limit?(branches, assignment)
-          longest_rhs_full_length(branches, assignment) > max_line_length
+          longest_line_exceeds_line_limit?(node, assignment)
         end
 
         def longest_line_exceeds_line_limit?(node, assignment)
           longest_line(node, assignment).length > max_line_length
         end
 
-        def longest_rhs_full_length(branches, assignment)
-          longest_rhs(branches) + indentation_width + assignment.length
-        end
-
         def longest_line(node, assignment)
-          assignment_regex = /#{Regexp.escape(assignment).gsub(' ', '\s*')}/
+          assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
           lines = node.source.lines.map do |line|
             line.chomp.sub(assignment_regex, '')
           end
           longest_line = lines.max_by(&:length)
-          longest_line + assignment
-        end
-
-        def longest_rhs(branches)
-          line_lengths = branches.flat_map do |branch|
-            branch.children.last.source.split("\n").map(&:length)
-          end
-          line_lengths.max
+          assignment + longest_line
         end
 
         def line_length_cop_enabled?
@@ -475,7 +467,15 @@ module RuboCop
 
         def replace_branch_assignment(corrector, branch)
           _variable, *_operator, assignment = *branch
-          corrector.replace(branch.source_range, assignment.source)
+          source = assignment.source
+
+          replacement = if assignment.array_type? && !assignment.bracketed?
+                          "[#{source}]"
+                        else
+                          source
+                        end
+
+          corrector.replace(branch.source_range, replacement)
         end
 
         def correct_branches(corrector, branches)

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

@@ -16,14 +16,35 @@ module RuboCop
       # an offense is reported.
       #
       class Copyright < Cop
+        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
+              'any code.'.freeze
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
                                     'your RuboCop config'.freeze
 
-        def message
-          "Include a copyright notice matching /#{notice}/" \
-          'before any code.'
+        def investigate(processed_source)
+          return if notice.empty?
+          return if notice_found?(processed_source)
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(insert_notice_before(processed_source),
+                      location: range, message: format(MSG, notice: notice))
+        end
+
+        def autocorrect(token)
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          regex = Regexp.new(notice)
+          unless autocorrect_notice =~ regex
+            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                           "match Notice /#{notice}/"
+          end
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
         end
 
+        private
+
         def notice
           cop_config['Notice']
         end
@@ -32,13 +53,6 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source), range, message)
-        end
-
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)
@@ -49,40 +63,25 @@ module RuboCop
         def shebang_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT && token.text =~ /^#!.*$/
+          token.comment? && token.text =~ /^#!.*$/
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT &&
-            token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+          token.comment? && token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
         end
 
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
           processed_source.tokens.each do |token|
-            break unless token.type == :tCOMMENT
+            break unless token.comment?
             notice_found = !(token.text =~ notice_regexp).nil?
             break if notice_found
           end
           notice_found
         end
-
-        def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
-
-          lambda do |corrector|
-            range = token.nil? ? range_between(0, 0) : token.pos
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `DateTime` that should be replaced by
+      # `Date` or `Time`.
+      #
+      # @example
+      #
+      #   # bad - uses `DateTime` for current time
+      #   DateTime.now
+      #
+      #   # good - uses `Time` for current time
+      #   Time.now
+      #
+      #   # bad - uses `DateTime` for modern date
+      #   DateTime.iso8601('2016-06-29')
+      #
+      #   # good - uses `Date` for modern date
+      #   Date.iso8601('2016-06-29')
+      #
+      #   # good - uses `DateTime` with start argument for historical date
+      #   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+      class DateTime < Cop
+        MSG = 'Prefer Date or Time over DateTime.'.freeze
+
+        def_node_matcher :date_time?, <<-PATTERN
+          (send (const {nil? (cbase)} :DateTime) ...)
+        PATTERN
+
+        def_node_matcher :historic_date?, <<-PATTERN
+          (send _ _ _ (const (const nil? :Date) _))
+        PATTERN
+
+        def on_send(node)
+          return unless date_time?(node)
+          return if historic_date?(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end