Add Rake/ConstantDefinitionInTask cop

Adds a new cop, `Rake/ConstantDefinitionInTask`, that registers an offense
for a constant assignment inside a task or namespace.

```ruby
task :foo do
  CONST = 1
end

namespace :foo do
  CONST = 1
end

CONST = 1
task :foo do
end
```

A constant assigned inside a `task` or `namespace` block is defined to the
top level, not scoped to the block. That is the same surprise the existing
cops already cover for methods and classes:

* `Rake/MethodDefinitionInTask` for methods
* `Rake/ClassDefinitionInTask` for classes and modules
* `Rake/ConstantDefinitionInTask` (new) for plain constant assignments

Rake files are also sometimes loaded rather than required, so a constant
that leaks to the top level can produce "already initialized constant"
warnings on reload.

The cop reuses `Helper::TaskDefinition`, and like `Rake/ClassDefinitionInTask`
it skips nodes inside a `class`, `module`, or `Class.new` body via
`Helper::ClassDefinition.in_class_definition?`, because those constants are
not defined to the top level.

Adds the cop and its spec, a `config/default.yml` entry (`Enabled: pending`,
`VersionAdded: '<<next>>'`), a `register_cop` directive in
`lib/rubocop/cop/rake.rb` so the cop is registered for lazy loading, the
cop count in `spec/lazy_loading_spec.rb`, and a CHANGELOG entry.
`bundle exec rake` is green.

Author: corsonknowles

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master (unreleased)
 
+### New features
+
+* [#65](https://github.com/rubocop/rubocop-rake/pull/65): Add `Rake/ConstantDefinitionInTask` cop. ([@corsonknowles][])
+
 ### Changes
 
 * [#66](https://github.com/rubocop/rubocop-rake/pull/66): Speed up loading rubocop-rake by lazily loading only the cops needed for a run. This requires RuboCop 1.89.0+. ([@koic][])
@@ -82,3 +86,4 @@
 [@jaruuuu]: https://github.com/jaruuuu
 [@koic]: https://github.com/koic
 [@tejasbubane]: https://github.com/tejasbubane
+[@corsonknowles]: https://github.com/corsonknowles

config/default.yml

@@ -9,6 +9,11 @@ Rake/ClassDefinitionInTask:
   Enabled: true
   VersionAdded: '0.3.0'
 
+Rake/ConstantDefinitionInTask:
+  Description: 'Do not assign a constant in rake task, because it will be defined to the top level.'
+  Enabled: pending
+  VersionAdded: '<<next>>'
+
 Rake/Desc:
   Description: 'Describe the task with `desc` method.'
   Enabled: true

lib/rubocop/cop/rake.rb

@@ -10,6 +10,7 @@ module Rake
       extend LazyLoader
 
       register_cop :ClassDefinitionInTask, "#{__dir__}/rake/class_definition_in_task"
+      register_cop :ConstantDefinitionInTask, "#{__dir__}/rake/constant_definition_in_task"
       register_cop :Desc, "#{__dir__}/rake/desc"
       register_cop :DuplicateTask, "#{__dir__}/rake/duplicate_task"
       register_cop :DuplicateNamespace, "#{__dir__}/rake/duplicate_namespace"

lib/rubocop/cop/rake/constant_definition_in_task.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rake
+      # Detects constant assignment in a task or namespace,
+      # because it is defined to the top level.
+      # It is confusing because the scope looks in the task or namespace,
+      # but actually it is defined to the top level.
+      #
+      # Class and module definitions are covered by `Rake/ClassDefinitionInTask`.
+      #
+      # @example
+      #   # bad
+      #   task :foo do
+      #     CONST = 1
+      #   end
+      #
+      #   # bad
+      #   namespace :foo do
+      #     CONST = 1
+      #   end
+      #
+      #   # good - It is also defined to the top level,
+      #   #        but it looks expected behavior.
+      #   CONST = 1
+      #   task :foo do
+      #   end
+      #
+      class ConstantDefinitionInTask < Base
+        MSG = 'Do not assign a constant in rake task, because it will be defined to the top level.'
+
+        def on_casgn(node)
+          return if Helper::ClassDefinition.in_class_definition?(node)
+          return unless Helper::TaskDefinition.in_task_or_namespace?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

spec/lazy_loading_spec.rb

@@ -24,7 +24,7 @@ def run_script(source)
       puts "loaded_cop_files=\#{loaded.size}"
     RUBY
 
-    expect(output).to include('registered=5', 'loaded_cop_files=0')
+    expect(output).to include('registered=6', 'loaded_cop_files=0')
   end
 
   it 'resolves every helper file in `lib/rubocop/cop/rake/helper` through an autoload' do

spec/rubocop/cop/rake/constant_definition_in_task_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::Rake::ConstantDefinitionInTask, :config do
+  it 'registers an offense to a constant assignment in a task' do
+    expect_offense(<<~RUBY)
+      task :foo do
+        CONST = 1
+        ^^^^^^^^^ Do not assign a constant in rake task, because it will be defined to the top level.
+      end
+    RUBY
+  end
+
+  it 'registers an offense to a constant assignment in a namespace' do
+    expect_offense(<<~RUBY)
+      namespace :foo do
+        CONST = 1
+        ^^^^^^^^^ Do not assign a constant in rake task, because it will be defined to the top level.
+
+        task :bar do
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense to a constant assignment at the top level' do
+    expect_no_offenses(<<~RUBY)
+      CONST = 1
+
+      task :foo do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense to a constant assignment inside a class in a task' do
+    expect_no_offenses(<<~RUBY)
+      task :foo do
+        Class.new do
+          CONST = 1
+        end
+      end
+    RUBY
+  end
+end