rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -26,8 +26,8 @@ module RuboCop
       #   # good
       #   gem 'rubocop', groups: [:development, :test]
       class DuplicatedGem < Cop
-        MSG = 'Gem `%s` requirements already given on line %d ' \
-              'of the Gemfile.'.freeze
+        MSG = 'Gem `%<gem_name>s` requirements already given on line '\
+          '%<line_of_first_occurrence>d of the Gemfile.'.freeze
 
         def investigate(processed_source)
           return unless processed_source.ast
@@ -58,12 +58,12 @@ module RuboCop
           line_range = node.loc.column...node.loc.last_column
           offense_location =
             source_range(processed_source.buffer, node.loc.line, line_range)
-
-          add_offense(
-            node,
-            location: offense_location,
-            message: format(MSG, gem_name, line_of_first_occurrence)
+          message = format(
+            MSG,
+            gem_name: gem_name,
+            line_of_first_occurrence: line_of_first_occurrence
           )
+          add_offense(node, location: offense_location, message: message)
         end
       end
     end

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -26,8 +26,9 @@ module RuboCop
       #   source 'https://rubygems.org' # strongly recommended
       #   source 'http://rubygems.org'
       class InsecureProtocolSource < Cop
-        MSG = 'The source `:%s` is deprecated because HTTP requests are ' \
-              "insecure. Please change your source to 'https://rubygems.org' " \
+        MSG = 'The source `:%<source>s` is deprecated because HTTP requests ' \
+              'are insecure. ' \
+              "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not.".freeze
 
         def_node_matcher :insecure_protocol_source?, <<-PATTERN
@@ -37,7 +38,7 @@ module RuboCop
 
         def on_send(node)
           insecure_protocol_source?(node) do |source|
-            message = format(MSG, source)
+            message = format(MSG, source: source)
 
             add_offense(
               node,

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -30,7 +30,7 @@ module RuboCop
 
         MSG = 'Gems should be sorted in an alphabetical order within their '\
               'section of the Gemfile. '\
-              'Gem `%s` should appear before `%s`.'.freeze
+              'Gem `%<previous>s` should appear before `%<current>s`.'.freeze
 
         def investigate(processed_source)
           return if processed_source.ast.nil?
@@ -54,7 +54,7 @@ module RuboCop
         end
 
         def_node_search :gem_declarations, <<-PATTERN
-          (:send nil? :gem ...)
+          (:send nil? :gem str ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/cop.rb

@@ -115,13 +115,23 @@ module RuboCop
         self.class::MSG
       end
 
-      def add_offense(node, *args, **kwargs, &block)
-        if args.any?
-          add_offense_deprecated(node, *args, &block)
-        else
-          add_offense_common(node, **kwargs, &block)
-        end
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense(node, location: :expression, message: nil, severity: nil)
+        loc = find_location(node, location)
+
+        return if duplicate_location?(loc)
+
+        severity = custom_severity || severity || default_severity
+
+        message ||= message(node)
+        message = annotate(message)
+
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
+
+        @offenses << Offense.new(severity, loc, message, name, status)
+        yield if block_given? && status != :disabled
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def find_location(node, loc)
         # Location can be provided as a symbol, e.g.: `:keyword`
@@ -222,46 +232,6 @@ module RuboCop
           warn(Rainbow(message).red)
         end
       end
-
-      def add_offense_deprecated(node, loc = :expression, message = nil,
-                                 severity = nil, &block)
-
-        caller = caller_locations(2..2).first
-        path = "#{caller.path}:#{caller.lineno}"
-        warn_message = <<-RUBY.strip_indent
-          #{path}
-          Warning: The usage of positional location, message, and severity
-          parameters to Cop#add_offense is deprecated.
-          Please use keyword arguments instead.
-
-          The positional arguments version of Cop#add_offense will be removed in
-          RuboCop 0.52
-        RUBY
-
-        warn(Rainbow(warn_message).red)
-
-        add_offense_common(node, location: loc, message: message,
-                                 severity: severity, &block)
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def add_offense_common(node, location: :expression, message: nil,
-                             severity: nil)
-        loc = find_location(node, location)
-
-        return if duplicate_location?(loc)
-
-        severity = custom_severity || severity || default_severity
-
-        message ||= message(node)
-        message = annotate(message)
-
-        status = enabled_line?(loc.line) ? correct(node) : :disabled
-
-        @offenses << Offense.new(severity, loc, message, name, status)
-        yield if block_given? && status != :disabled
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # An attribute assignment method calls should be listed only once
+      # in a gemspec.
+      #
+      # Assigning to an attribute with the same name using `spec.foo =` will be
+      # an unintended usage. On the other hand, duplication of methods such
+      # as `spec.requirements`, `spec.add_runtime_dependency` and others are
+      # permitted because it is the intended use of appending values.
+      #
+      # @example
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #     spec.name = 'rubocop2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.requirements << 'libmagick, v6.0'
+      #     spec.requirements << 'A good graphics card'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('parallel', '~> 1.10')
+      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #   end
+      class DuplicatedAssignment < Cop
+        MSG = '`%<assignment>s` method calls already given on line '\
+              '%<line_of_first_occurrence>d of the gemspec.'.freeze
+
+        def_node_search :gem_specification, <<-PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            (args
+              (arg $_)) ...)
+        PATTERN
+
+        def_node_search :assignment_method_declarations, <<-PATTERN
+          (send
+            (lvar #match_block_variable_name?) #assignment_method? ...)
+        PATTERN
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+
+          duplicated_assignment_method_nodes.each do |nodes|
+            nodes[1..-1].each do |node|
+              register_offense(
+                node,
+                node.method_name,
+                nodes.first.loc.line
+              )
+            end
+          end
+        end
+
+        private
+
+        def match_block_variable_name?(receiver_name)
+          gem_specification(processed_source.ast) do |block_variable_name|
+            return block_variable_name == receiver_name
+          end
+        end
+
+        def assignment_method?(method_name)
+          method_name.to_s.end_with?('=')
+        end
+
+        def duplicated_assignment_method_nodes
+          assignment_method_declarations(processed_source.ast)
+            .group_by(&:method_name)
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
+        def register_offense(node, assignment, line_of_first_occurrence)
+          line_range = node.loc.column...node.loc.last_column
+          offense_location =
+            source_range(processed_source.buffer, node.loc.line, line_range)
+          message = format(
+            MSG,
+            assignment: assignment,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(node, location: offense_location, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -54,9 +54,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include OrderedGemNode
 
-        MSG = 'Dependencies should be sorted in an alphabetical order within '\
+        MSG = 'Dependencies should be sorted in an alphabetical order within ' \
               'their section of the gemspec. '\
-              'Dependency `%s` should appear before `%s`.'.freeze
+              'Dependency `%<previous>s` should appear before `%<current>s`.'
+              .freeze
 
         def investigate(processed_source)
           return if processed_source.ast.nil?

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that `required_ruby_version` of gemspec and `TargetRubyVersion`
+      # of .rubocop.yml are equal.
+      # Thereby, RuboCop to perform static analysis working on the version
+      # required by gemspec.
+      #
+      # @example
+      #   # When `TargetRubyVersion` of .rubocop.yml is `2.3`.
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.2.0'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.4.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.3'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = ['>= 2.3.0', '< 2.5.0']
+      #   end
+      class RequiredRubyVersion < Cop
+        MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
+              'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+              '(%<target_ruby_version>s, declared in .rubocop.yml) ' \
+              'should be equal.'.freeze
+
+        def_node_search :required_ruby_version, <<-PATTERN
+          (send _ :required_ruby_version= ${(str _) (array (str _))})
+        PATTERN
+
+        def investigate(processed_source)
+          required_ruby_version(processed_source.ast) do |version|
+            ruby_version = extract_ruby_version(version)
+
+            return if ruby_version == target_ruby_version.to_s
+
+            add_offense(
+              processed_source.ast,
+              location: version.loc.expression,
+              message: message(ruby_version, target_ruby_version)
+            )
+          end
+        end
+
+        private
+
+        def extract_ruby_version(required_ruby_version)
+          if required_ruby_version.array_type?
+            required_ruby_version = required_ruby_version.children.detect do |v|
+              v.str_content =~ /[>=]/
+            end
+          end
+
+          required_ruby_version.str_content.match(/(\d\.\d)/)[1]
+        end
+
+        def message(required_ruby_version, target_ruby_version)
+          file_path = processed_source.buffer.name
+
+          format(
+            MSG,
+            required_ruby_version: required_ruby_version,
+            gemspec_filename: File.basename(file_path),
+            target_ruby_version: target_ruby_version
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator.rb

@@ -35,10 +35,10 @@ module RuboCop
                 # See. https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
                 #
                 # For example
-                MSG = 'Message of %<cop_name>s'.freeze
+                MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
 
                 def_node_matcher :bad_method?, <<-PATTERN
-                  (send nil :bad_method ...)
+                  (send nil? :bad_method ...)
                 PATTERN
 
                 def on_send(node)
@@ -55,9 +55,10 @@ module RuboCop
         # frozen_string_literal: true
 
         describe RuboCop::Cop::%<department>s::%<cop_name>s do
-          let(:config) { RuboCop::Config.new }
           subject(:cop) { described_class.new(config) }
 
+          let(:config) { RuboCop::Config.new }
+
           # TODO: Write test code
           #
           # For example
@@ -96,6 +97,22 @@ module RuboCop
         RequireFileInjector.new(require_path).inject
       end
 
+      def inject_config(path = 'config/enabled.yml')
+        config = File.readlines(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(path, config.join)
+      end
+
       def todo
         <<-TODO.strip_indent
           Files created:
@@ -103,11 +120,13 @@ module RuboCop
             - #{spec_path}
           File modified:
             - `require_relative '#{require_path}'` added into lib/rubocop.rb
+            - A configuration for the cop is added into config/enabled.yml
+              - If you want to disable the cop by default, move the added config to config/disabled.yml
 
           Do 3 steps:
             1. Add an entry to the "New features" section in CHANGELOG.md,
                e.g. "Add new `#{badge}` cop. ([@your_id][])"
-            2. Add an entry into config/enabled.yml or config/disabled.yml
+            2. Modify the description of #{badge} in config/enabled.yml
             3. Implement your new cop in the generated file!
         TODO
       end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,8 +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'
-require_relative 'internal_affairs/deprecated_positional_arguments'

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