rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/generator.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Source and spec generator for new cops
+    #
+    # This generator will take a cop name and generate a source file
+    # and spec file when given a valid qualified cop name.
+    class Generator
+      SOURCE_TEMPLATE = <<-RUBY.strip_indent
+        # frozen_string_literal: true
+
+        # TODO: when finished, run `rake generate_cops_documentation` to update the docs
+        module RuboCop
+          module Cop
+            module %<department>s
+              # TODO: Write cop description and example of bad / good code.
+              #
+              # @example
+              #   # bad
+              #   bad_method()
+              #
+              #   # bad
+              #   bad_method(args)
+              #
+              #   # good
+              #   good_method()
+              #
+              #   # good
+              #   good_method(args)
+              class %<cop_name>s < Cop
+                # TODO: Implement the cop into here.
+                #
+                # In many cases, you can use a node matcher for matching node pattern.
+                # See. https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
+                #
+                # For example
+                MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
+
+                def_node_matcher :bad_method?, <<-PATTERN
+                  (send nil? :bad_method ...)
+                PATTERN
+
+                def on_send(node)
+                  return unless bad_method?(node)
+                  add_offense(node)
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      SPEC_TEMPLATE = <<-SPEC.strip_indent
+        # frozen_string_literal: true
+
+        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s do
+          subject(:cop) { described_class.new(config) }
+
+          let(:config) { RuboCop::Config.new }
+
+          # TODO: Write test code
+          #
+          # For example
+          it 'registers an offense when using `#bad_method`' do
+            expect_offense(<<-RUBY.strip_indent)
+              bad_method
+              ^^^^^^^^^^ Use `#good_method` instead of `#bad_method`.
+            RUBY
+          end
+
+          it 'does not register an offense when using `#good_method`' do
+            expect_no_offenses(<<-RUBY.strip_indent)
+              good_method
+            RUBY
+          end
+        end
+      SPEC
+
+      def initialize(name, output: $stdout)
+        @badge = Badge.parse(name)
+        @output = output
+        return if badge.qualified?
+
+        raise ArgumentError, 'Specify a cop name with Department/Name style'
+      end
+
+      def write_source
+        write_unless_file_exists(source_path, generated_source)
+      end
+
+      def write_spec
+        write_unless_file_exists(spec_path, generated_spec)
+      end
+
+      def inject_require(root_file_path: 'lib/rubocop.rb')
+        RequireFileInjector.new(
+          source_path: source_path,
+          root_file_path: root_file_path
+        ).inject
+      end
+
+      def inject_config(config_file_path: 'config/enabled.yml')
+        config = File.readlines(config_file_path)
+        content = <<-YAML.strip_indent
+          #{badge}:
+            Description: 'TODO: Write a description of the cop.'
+            Enabled: true
+
+        YAML
+        target_line = config.find.with_index(1) do |line, index|
+          next if line =~ /^[\s#]/
+          break index - 1 if badge.to_s < line
+        end
+        config.insert(target_line, content)
+        File.write(config_file_path, config.join)
+        output.puts <<-MESSAGE.strip_indent
+          [modify] A configuration for the cop is added into #{config_file_path}.
+                   If you want to disable the cop by default, move the added config to config/disabled.yml
+        MESSAGE
+      end
+
+      def todo
+        <<-TODO.strip_indent
+          Do 3 steps:
+            1. Add an entry to the "New features" section in CHANGELOG.md,
+               e.g. "Add new `#{badge}` cop. ([@your_id][])"
+            2. Modify the description of #{badge} in config/enabled.yml
+            3. Implement your new cop in the generated file!
+        TODO
+      end
+
+      private
+
+      attr_reader :badge, :output
+
+      def write_unless_file_exists(path, contents)
+        if File.exist?(path)
+          warn "rake new_cop: #{path} already exists!"
+          exit!
+        end
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+
+        File.write(path, contents)
+        output.puts "[create] #{path}"
+      end
+
+      def generated_source
+        generate(SOURCE_TEMPLATE)
+      end
+
+      def generated_spec
+        generate(SPEC_TEMPLATE)
+      end
+
+      def generate(template)
+        format(template, department: badge.department, cop_name: badge.cop_name)
+      end
+
+      def spec_path
+        File.join(
+          'spec',
+          'rubocop',
+          'cop',
+          snake_case(badge.department.to_s),
+          "#{snake_case(badge.cop_name.to_s)}_spec.rb"
+        )
+      end
+
+      def source_path
+        File.join(
+          'lib',
+          'rubocop',
+          'cop',
+          snake_case(badge.department.to_s),
+          "#{snake_case(badge.cop_name.to_s)}.rb"
+        )
+      end
+
+      def snake_case(camel_case_string)
+        return 'rspec' if camel_case_string == 'RSpec'
+        camel_case_string
+          .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
+          .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+          .downcase
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ignored_node.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

data/lib/rubocop/cop/internal_affairs/node_destructuring.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node destructuring is done either using the node
+      # extensions or using a splat.
+      #
+      # @example Using splat expansion
+      #
+      #   # bad
+      #   receiver, method_name, arguments = send_node.children
+      #
+      #   # good
+      #   receiver, method_name, arguments = *send_node
+      #
+      # @example Using node extensions
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = send_node.children
+      #
+      #   # good
+      #   method_name = send_node.method_name
+      class NodeDestructuring < Cop
+        MSG = 'Use the methods provided with the node extensions, or ' \
+              'destructure the node using `*`.'.freeze
+
+        def_node_matcher :node_children_destructuring?, <<-PATTERN
+          (masgn (mlhs ...) (send (send nil? [#node_suffix? _]) :children))
+        PATTERN
+
+        def on_masgn(node)
+          node_children_destructuring?(node) do
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def node_suffix?(method_name)
+          method_name.to_s.end_with?('node')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node types are checked using the predicate helpers.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.type == :send
+      #
+      #   # good
+      #   node.send_type?
+      #
+      class NodeTypePredicate < Cop
+        MSG = 'Use `#%<type>s_type?` to check node type.'.freeze
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send (send $_ :type) :== (sym $_))
+        PATTERN
+
+        def on_send(node)
+          node_type_check(node) do |_receiver, node_type|
+            return unless Parser::Meta::NODE_TYPES.include?(node_type)
+
+            add_offense(node, message: format(MSG, type: node_type))
+          end
+        end
+
+        def autocorrect(node)
+          receiver, node_type = node_type_check(node)
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            receiver.loc.expression.end_pos + 1,
+                                            node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, "#{node_type}_type?")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for potential uses of the location keywords which can be used as
+      # shortcut arguments to `#add_offense`.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, location: node.loc.selector)
+      #
+      #   # good
+      #   add_offense(node, location: :selector)
+      class OffenseLocationKeyword < Cop
+        MSG = 'Use `:%<keyword>s` as the location argument to ' \
+              '`#add_offense`.'.freeze
+
+        def on_send(node)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |location, keyword|
+              add_offense(location, message: format(MSG, keyword: keyword))
+            end
+          end
+        end
+
+        def autocorrect(node)
+          (*, keyword) = offending_location_argument(node.parent)
+
+          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+        end
+
+        private
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :offending_location_argument, <<-PATTERN
+          (pair (sym :location) $(send (send $_node :loc) $_keyword))
+        PATTERN
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            offending_location_argument(pair) do |location, node, keyword|
+              yield(location, keyword) if searched_node == node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `location` argument to `#add_offense`. `location`
+      # argument has a default value of `:expression` and this method will
+      # automatically use it.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, location: :expression)
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, location: :selector)
+      #
+      class RedundantLocationArgument < Cop
+        MSG = 'Redundant location argument to `#add_offense`.'.freeze
+
+        def_node_matcher :add_offense_kwargs, <<-PATTERN
+          (send nil? :add_offense _ $hash)
+        PATTERN
+
+        def_node_matcher :redundant_location_argument?, <<-PATTERN
+          (pair (sym :location) (sym :expression))
+        PATTERN
+
+        def on_send(node)
+          redundant_location_argument(node) { |argument| add_offense(argument) }
+        end
+
+        def autocorrect(node)
+          range = offending_range(node)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def redundant_location_argument(node)
+          add_offense_kwargs(node) do |kwargs|
+            result =
+              kwargs.pairs.find { |arg| redundant_location_argument?(arg) }
+
+            yield result if result
+          end
+        end
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant message arguments to `#add_offense`. This method
+      # will automatically use `#message` or `MSG` (in that order of priority)
+      # if they are defined.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, message: MSG)
+      #   add_offense(node, message: message)
+      #   add_offense(node, message: message(node))
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, message: CUSTOM_MSG)
+      #   add_offense(node, message: message(other_node))
+      #
+      class RedundantMessageArgument < Cop
+        MSG = 'Redundant message argument to `#add_offense`.'.freeze
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :redundant_message_argument, <<-PATTERN
+          (pair
+            (sym :message)
+            ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
+        PATTERN
+
+        def_node_matcher :message_method_call, '(send nil? :message $_node)'
+
+        def on_send(node)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |pair|
+              add_offense(pair)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          range = offending_range(node)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            redundant_message_argument(pair) do |message_argument|
+              node = message_method_call(message_argument)
+
+              yield pair if !node || node == searched_node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that cops are not tested using `described_class::MSG`.
+      #
+      # @example
+      #
+      #     # bad
+      #     expect(cop.messages).to eq([described_class::MSG])
+      #
+      #     # good
+      #     expect(cop.messages).to eq(['Do not write bad code like that.'])
+      #
+      class UselessMessageAssertion < Cop
+        MSG = 'Do not specify cop behavior using `described_class::MSG`.'.freeze
+
+        def_node_search :described_class_msg, <<-PATTERN
+          (const (send nil? :described_class) :MSG)
+        PATTERN
+
+        def_node_matcher :rspec_expectation_on_msg?, <<-PATTERN
+          (send (send nil? :expect #contains_described_class_msg?) :to ...)
+        PATTERN
+
+        def investigate(_processed_source)
+          assertions_using_described_class_msg.each do |node|
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def contains_described_class_msg?(node)
+          described_class_msg(node).any?
+        end
+
+        def assertions_using_described_class_msg
+          described_class_msg(processed_source.ast).reject do |node|
+            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+          end
+        end
+
+        # Only process spec files
+        def relevant_file?(file)
+          file.end_with?('_spec.rb')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'internal_affairs/node_destructuring'
+require_relative 'internal_affairs/node_type_predicate'
+require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_location_argument'
+require_relative 'internal_affairs/useless_message_assertion'

data/lib/rubocop/cop/{style → layout}/access_modifier_indentation.rb

@@ -1,17 +1,41 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Modifiers should be indented as deep as method definitions, or as deep
       # as the class/module keyword, depending on configuration.
+      #
+      # @example EnforcedStyle: indent (default)
+      #   # bad
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      # @example EnforcedStyle: outdent
+      #   # bad
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
       class AccessModifierIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
-        include AccessModifierNode
 
-        MSG = '%s access modifiers like `%s`.'.freeze
+        MSG = '%<style>s access modifiers like `%<node>s`.'.freeze
 
         def on_class(node)
           _name, _base_class, body = *node
@@ -29,8 +53,13 @@ module RuboCop
         end
 
         def on_block(node)
-          _method, _args, body = *node
-          check_body(body, node) if node.class_constructor?
+          return unless node.class_constructor?
+
+          check_body(node.body, node)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
         end
 
         private
@@ -38,7 +67,7 @@ module RuboCop
         def check_body(body, node)
           return if body.nil? # Empty class etc.
 
-          modifiers = body.children.select { |c| modifier_node?(c) }
+          modifiers = body.each_child_node(:send).select(&:access_modifier?)
           class_column = node.source_range.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }
@@ -52,7 +81,7 @@ module RuboCop
           if @column_delta.zero?
             correct_style_detected
           else
-            add_offense(send_node, :expression) do
+            add_offense(send_node) do
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else
@@ -63,7 +92,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, style.capitalize, node.loc.selector.source)
+          format(MSG, style: style.capitalize, node: node.loc.selector.source)
         end
 
         def expected_indent_offset

data/lib/rubocop/cop/layout/align_array.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      #
+      # @example
+      #   # bad
+      #   a = [1, 2, 3,
+      #     4, 5, 6]
+      #   array = ['run',
+      #        'forrest',
+      #        'run']
+      #
+      #   # good
+      #   a = [1, 2, 3,
+      #        4, 5, 6]
+      #   a = ['run',
+      #        'forrest',
+      #        'run']
+      class AlignArray < Cop
+        include Alignment
+
+        MSG = 'Align the elements of an array literal if they span more ' \
+              'than one line.'.freeze
+
+        def on_array(node)
+          check_alignment(node.children)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+      end
+    end
+  end
+end