rubocop 0.49.1 → 0.52.0

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

@@ -26,69 +26,26 @@ module RuboCop
       #   gem 'rspec'
       class OrderedGems < Cop
         include ConfigurableEnforcedStyle
+        include OrderedGemNode
 
         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?
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
             next unless case_insensitive_out_of_order?(
-              current.children[2].children.first.to_s,
-              previous.children[2].children.first.to_s
+              gem_name(current),
+              gem_name(previous)
             )
             register_offense(previous, current)
           end
         end
 
-        def case_insensitive_out_of_order?(string_a, string_b)
-          string_a.downcase < string_b.downcase
-        end
-
-        def consecutive_lines(previous, current)
-          first_line = get_source_range(current).first_line
-          previous.source_range.last_line == first_line - 1
-        end
-
-        def register_offense(previous, current)
-          add_offense(
-            current,
-            current.source_range,
-            format(
-              MSG,
-              current.children[2].children.first,
-              previous.children[2].children.first
-            )
-          )
-        end
-
-        def autocorrect(node)
-          previous = previous_declaration(node)
-
-          current_range = declaration_with_comment(node)
-          previous_range = declaration_with_comment(previous)
-
-          lambda do |corrector|
-            swap_range(corrector, current_range, previous_range)
-          end
-        end
-
-        def declaration_with_comment(node)
-          buffer = processed_source.buffer
-          begin_pos = get_source_range(node).begin_pos
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
-          end_pos = buffer.line_range(end_line).end_pos
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
-        end
-
-        def swap_range(corrector, range1, range2)
-          src1 = range1.source
-          src2 = range2.source
-          corrector.replace(range1, src2)
-          corrector.replace(range2, src1)
-        end
+        private
 
         def previous_declaration(node)
           declarations = gem_declarations(processed_source.ast)
@@ -96,16 +53,8 @@ module RuboCop
           declarations.to_a[node_index - 1]
         end
 
-        def get_source_range(node)
-          unless cop_config['TreatCommentsAsGroupSeparators']
-            first_comment = processed_source.ast_with_comments[node].first
-            return first_comment.loc.expression unless first_comment.nil?
-          end
-          node.source_range
-        end
-
         def_node_search :gem_declarations, <<-PATTERN
-          (:send, nil, :gem, ...)
+          (:send nil? :gem str ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/commissioner.rb

@@ -34,7 +34,7 @@ module RuboCop
 
       callback_methods.each do |callback|
         next unless method_defined?(callback)
-        class_eval <<-EOS, __FILE__, __LINE__ + 1
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{callback}(node)
             @callbacks[:"#{callback}"] ||= @cops.select do |cop|
               cop.respond_to?(:"#{callback}")
@@ -47,7 +47,7 @@ module RuboCop
 
             #{!no_child_callbacks.include?(callback) && 'super'}
           end
-        EOS
+        RUBY
       end
 
       def investigate(processed_source)
@@ -102,9 +102,12 @@ module RuboCop
         end
       end
 
+      # Allow blind rescues here, since we're absorbing and packaging or
+      # re-raising exceptions that can be raised from within the individual
+      # cops' `#investigate` methods.
       def with_cop_error_handling(cop, node = nil)
         yield
-      rescue => e
+      rescue StandardError => e
         raise e if @options[:raise_error]
         if node
           line = node.loc.line

data/lib/rubocop/cop/cop.rb

@@ -105,28 +105,33 @@ module RuboCop
       end
 
       def cop_config
-        @cop_config ||= @config.for_cop(self)
+        # Use department configuration as basis, but let individual cop
+        # configuration override.
+        @cop_config ||= @config.for_cop(self.class.department.to_s)
+                               .merge(@config.for_cop(self))
       end
 
       def message(_node = nil)
         self.class::MSG
       end
 
-      def add_offense(node, loc, message = nil, severity = nil)
-        location = find_location(node, loc)
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense(node, location: :expression, message: nil, severity: nil)
+        loc = find_location(node, location)
 
-        return if duplicate_location?(location)
+        return if duplicate_location?(loc)
 
         severity = custom_severity || severity || default_severity
 
         message ||= message(node)
         message = annotate(message)
 
-        status = enabled_line?(location.line) ? correct(node) : :disabled
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
 
-        @offenses << Offense.new(severity, location, message, name, status)
+        @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`

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Dependencies in the gemspec should be alphabetically sorted.
+      #
+      # @example
+      #   # bad
+      #   spec.add_dependency 'rubocop'
+      #   spec.add_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_dependency 'rspec'
+      #   spec.add_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_dependency 'rubocop'
+      #
+      #   spec.add_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_development_dependency 'rubocop'
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rspec'
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_runtime_dependency 'rubocop'
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rspec'
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      class OrderedDependencies < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        MSG = 'Dependencies should be sorted in an alphabetical order within ' \
+              'their section of the gemspec. '\
+              'Dependency `%<previous>s` should appear before `%<current>s`.'
+              .freeze
+
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+          dependency_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless case_insensitive_out_of_order?(
+              gem_name(current),
+              gem_name(previous)
+            )
+            unless get_dependency_name(previous) == get_dependency_name(current)
+              next
+            end
+
+            register_offense(previous, current)
+          end
+        end
+
+        private
+
+        def previous_declaration(node)
+          declarations = dependency_declarations(processed_source.ast)
+          node_index = declarations.find_index(node)
+          declarations.to_a[node_index - 1]
+        end
+
+        def get_dependency_name(node)
+          node.method_name
+        end
+
+        def_node_search :dependency_declarations, <<-PATTERN
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+        PATTERN
+      end
+    end
+  end
+end

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