rubocop 0.50.0 → 0.51.0

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

@@ -10,7 +10,7 @@ module RuboCop
         def_node_matcher :case_equality?, '(send _ :=== _)'
 
         def on_send(node)
-          case_equality?(node) { add_offense(node, :selector) }
+          case_equality?(node) { add_offense(node, location: :selector) }
         end
       end
     end

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

@@ -48,12 +48,12 @@ module RuboCop
 
         def check_nested_style(node)
           return unless compact_node_name?(node)
-          add_offense(node, :name, NESTED_MSG)
+          add_offense(node, location: :name, message: NESTED_MSG)
         end
 
         def check_compact_style(node, body)
           return unless one_child?(body) && !compact_node_name?(node)
-          add_offense(node, :name, COMPACT_MSG)
+          add_offense(node, location: :name, message: COMPACT_MSG)
         end
 
         def one_child?(body)

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

@@ -15,7 +15,7 @@ module RuboCop
           class_check?(node) do |method_name|
             return if style == method_name
 
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           end
         end
 

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

@@ -51,7 +51,8 @@ module RuboCop
           return unless name == definee
 
           _, class_name = *definee
-          add_offense(definee, :name, message(class_name, method_name))
+          add_offense(definee, location: :name,
+                               message: message(class_name, method_name))
         end
 
         def message(class_name, method_name)

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

@@ -10,7 +10,7 @@ module RuboCop
         MSG = 'Replace class var %s with a class instance var.'.freeze
 
         def on_cvasgn(node)
-          add_offense(node, :name)
+          add_offense(node, location: :name)
         end
 
         def message(node)

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

@@ -41,7 +41,7 @@ module RuboCop
         def check_method_node(node)
           return unless preferred_methods[node.method_name]
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module RuboCop
 
         def_node_matcher :java_type_node?, <<-PATTERN
           (send
-            (const nil :Java)
+            (const nil? :Java)
             {:boolean :byte :char :double :float :int :long :short})
         PATTERN
 
@@ -21,7 +21,7 @@ module RuboCop
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
 
-          add_offense(node, :dot)
+          add_offense(node, location: :dot)
         end
 
         def autocorrect(node)

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

@@ -23,8 +23,11 @@ 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, first_word)
+            )
           end
         end
 

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

@@ -0,0 +1,81 @@
+# 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 ' \
+              '`%s` keyword.'.freeze
+
+        def investigate(processed_source)
+          heredoc_lines = extract_heredoc_lines(processed_source.ast)
+
+          processed_source.lines.each_with_index do |line, index|
+            next if heredoc_lines.any? { |r| r.include?(index + 1) }
+            next unless offensive?(line)
+
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 (line.index('#'))...(line.length))
+
+            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)
+          KEYWORDS.any? { |k| line =~ /^\s*#{k}\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)
+        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

@@ -283,7 +283,7 @@ module RuboCop
           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)

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

@@ -26,7 +26,7 @@ module RuboCop
           return if notice_found?(processed_source)
           range = source_range(processed_source.buffer, 1, 0)
           add_offense(insert_notice_before(processed_source),
-                      range, MSG % notice)
+                      location: range, message: MSG % notice)
         end
 
         private

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 _ :DateTime) ...)
+        PATTERN
+
+        def_node_matcher :historic_date?, <<-PATTERN
+          (send _ _ _ (const (const _ :Date) _))
+        PATTERN
+
+        def on_send(node)
+          return unless date_time?(node)
+          return if historic_date?(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module RuboCop
           return if node.single_line?
           return unless !node.arguments? && node.arguments.loc.begin
 
-          add_offense(node.arguments, :begin)
+          add_offense(node.arguments, location: :begin)
         end
         alias on_defs on_def
 

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

@@ -17,18 +17,14 @@ module RuboCop
       #   # good
       #   path = __dir__
       class Dir < Cop
-        extend TargetRubyVersion
-
         MSG = 'Use `__dir__` to get an absolute path to the current ' \
               "file's directory.".freeze
 
         def_node_matcher :dir_replacement?, <<-PATTERN
-          {(send (const nil :File) :expand_path (send (const nil :File) :dirname  #file_keyword?))
-           (send (const nil :File) :dirname     (send (const nil :File) :realpath #file_keyword?))}
+          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
+           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
         PATTERN
 
-        minimum_target_ruby_version 2.0
-
         def on_send(node)
           dir_replacement?(node) do
             add_offense(node)

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

@@ -38,7 +38,7 @@ module RuboCop
           return if namespace?(body)
           return if documentation_comment?(node) || nodoc_comment?(node)
 
-          add_offense(node, :keyword, format(MSG, type))
+          add_offense(node, location: :keyword, message: format(MSG, type))
         end
 
         def namespace?(node)

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

@@ -27,7 +27,7 @@ module RuboCop
         def on_send(node)
           return unless double_negative?(node) && node.keyword_bang?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -33,7 +33,7 @@ module RuboCop
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
-          add_offense(node, range)
+          add_offense(node, location: range)
         end
 
         private

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

@@ -34,7 +34,8 @@ module RuboCop
             return unless first_argument_returned?(args, return_value)
             return if accumulator_param_assigned_to?(body, args)
 
-            add_offense(node, method.loc.selector, format(MSG, method_name))
+            add_offense(node, location: method.loc.selector,
+                              message: format(MSG, method_name))
           end
         end
 

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_case(case_node)
           return if case_node.condition
 
-          add_offense(case_node, :keyword)
+          add_offense(case_node, location: :keyword)
         end
 
         private

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

@@ -101,13 +101,13 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, :else)
+          add_offense(node, location: :else)
         end
 
         def nil_check(node)
           return unless node.else_branch && node.else_branch.nil_type?
 
-          add_offense(node, :else)
+          add_offense(node, location: :else)
         end
 
         def autocorrect(node)

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

@@ -12,23 +12,23 @@ module RuboCop
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
         STR_MSG = 'Use string literal `%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_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 _)'
+                         '(block (send (const nil? :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil :Hash) :new) args _)'
+                         '(block (send (const nil? :Hash) :new) args _)'
 
         def on_send(node)
-          add_offense(node, :expression, ARR_MSG)  if offense_array_node?(node)
-          add_offense(node, :expression, HASH_MSG) if offense_hash_node?(node)
+          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, :expression,
-                        format(STR_MSG, preferred_string_literal))
+            add_offense(node,
+                        message: format(STR_MSG, preferred_string_literal))
           end
         end
 

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

@@ -3,23 +3,10 @@
 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)
@@ -29,56 +16,25 @@ 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
-            raise encoding_mismatch_message unless matching_encoding?
-
-            lambda do |corrector|
-              corrector.insert_before(range, "#{encoding}\n")
-            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, :right))
           end
         end
 
         private
 
-        def encoding
-          cop_config[AUTO_CORRECT_ENCODING_COMMENT]
-        end
-
-        def matching_encoding?
-          encoding =~ ENCODING_PATTERN
-        end
-
-        def encoding_mismatch_message
-          "#{encoding} does not match #{ENCODING_PATTERN}"
-        end
-
         def offense(processed_source, line_number)
           line = processed_source[line_number]
 
-          if !encoding_present?(line) && !encoding_omitable?
-            MSG_MISSING
-          elsif encoding_present?(line) && encoding_omitable?
-            MSG_UNNECESSARY
-          end
-        end
-
-        def encoding_present?(line)
-          MagicComment.parse(line).encoding
+          MSG_UNNECESSARY if encoding_omitable?(line)
         end
 
-        def encoding_omitable?
-          return true if style == :never
-
-          style != :always && processed_source.buffer.source.ascii_only?
+        def encoding_omitable?(line)
+          line =~ ENCODING_PATTERN
         end
 
         def encoding_line_number(processed_source)