rubocop 0.49.1 → 0.50.0

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

@@ -36,7 +36,7 @@ module RuboCop
             nodes[1..-1].each do |node|
               register_offense(
                 node,
-                node.method_args.first.to_a.first,
+                node.first_argument.to_a.first,
                 nodes.first.loc.line
               )
             end
@@ -49,9 +49,9 @@ module RuboCop
 
         def duplicated_gem_nodes
           gem_declarations(processed_source.ast)
-            .group_by { |e| e.method_args.first }
-            .keep_if { |_, nodes| nodes.length > 1 }
+            .group_by(&:first_argument)
             .values
+            .select { |nodes| nodes.size > 1 }
         end
 
         def register_offense(node, gem_name, line_of_first_occurrence)

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # The symbol argument `:gemcutter`, `:rubygems` and `:rubyforge`
+      # are deprecated. So please change your source to URL string that
+      # 'https://rubygems.org' if possible, or 'http://rubygems.org' if not.
+      #
+      # This autocorrect will replace these symbols with 'https://rubygems.org'.
+      # Because it is secure, HTTPS request is strongly recommended. And in
+      # most use cases HTTPS will be fine.
+      #
+      # However, it don't replace all `sources` of `http://` with `https://`.
+      # For example, when specifying an internal gem server using HTTP on the
+      # intranet, a use case where HTTPS can not be specified was considered.
+      # Consider using HTTP only if you can not use HTTPS.
+      #
+      # @example
+      #   # bad
+      #   source :gemcutter
+      #   source :rubygems
+      #   source :rubyforge
+      #
+      #   # good
+      #   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' " \
+              "if possible, or 'http://rubygems.org' if not.".freeze
+
+        def_node_matcher :insecure_protocol_source?, <<-PATTERN
+          (send nil :source
+            (sym ${:gemcutter :rubygems :rubyforge}))
+        PATTERN
+
+        def on_send(node)
+          insecure_protocol_source?(node) do |source|
+            message = format(MSG, source)
+
+            add_offense(
+              node, source_range(node.first_argument.loc.expression), message
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.first_argument.loc.expression, "'https://rubygems.org'"
+            )
+          end
+        end
+
+        private
+
+        def source_range(node)
+          range_between(node.begin_pos, node.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -30,19 +30,22 @@ module RuboCop
         MSG = 'Gems should be sorted in an alphabetical order within their '\
               'section of the Gemfile. '\
               'Gem `%s` should appear before `%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
 
+        private
+
         def case_insensitive_out_of_order?(string_a, string_b)
           string_a.downcase < string_b.downcase
         end
@@ -53,15 +56,12 @@ module RuboCop
         end
 
         def register_offense(previous, current)
-          add_offense(
-            current,
-            current.source_range,
-            format(
-              MSG,
-              current.children[2].children.first,
-              previous.children[2].children.first
-            )
-          )
+          add_offense(current, :expression,
+                      format(MSG, gem_name(current), gem_name(previous)))
+        end
+
+        def gem_name(declaration_node)
+          declaration_node.first_argument.str_content
         end
 
         def autocorrect(node)
@@ -105,7 +105,7 @@ module RuboCop
         end
 
         def_node_search :gem_declarations, <<-PATTERN
-          (:send, nil, :gem, ...)
+          (:send nil :gem ...)
         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,6 +102,11 @@ 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.
+      #
+      # rubocop:disable Lint/RescueWithoutErrorClass
       def with_cop_error_handling(cop, node = nil)
         yield
       rescue => e
@@ -113,6 +118,7 @@ module RuboCop
         error = CopError.new(e, line, column)
         @errors[cop] << error
       end
+      # rubocop:enable Lint/RescueWithoutErrorClass
     end
   end
 end

data/lib/rubocop/cop/cop.rb

@@ -112,7 +112,8 @@ module RuboCop
         self.class::MSG
       end
 
-      def add_offense(node, loc, message = nil, severity = nil)
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense(node, loc = :expression, message = nil, severity = nil)
         location = find_location(node, loc)
 
         return if duplicate_location?(location)
@@ -127,6 +128,7 @@ module RuboCop
         @offenses << Offense.new(severity, location, 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/generator.rb

@@ -43,7 +43,7 @@ module RuboCop
 
                 def on_send(node)
                   return unless bad_method?(node)
-                  add_offense(node, :expression)
+                  add_offense(node)
                 end
               end
             end
@@ -51,7 +51,7 @@ module RuboCop
         end
       RUBY
 
-      SPEC_TEMPLATE = <<-RUBY.strip_indent
+      SPEC_TEMPLATE = <<-SPEC.strip_indent
         # frozen_string_literal: true
 
         describe RuboCop::Cop::%<department>s::%<cop_name>s do
@@ -61,19 +61,20 @@ module RuboCop
           # TODO: Write test code
           #
           # For example
-          it 'registers an offense for offending code' do
-            inspect_source(cop, 'bad_method')
-            expect(cop.offenses.size).to eq(1)
-            expect(cop.messages)
-              .to eq(['Message of %<cop_name>s'])
+          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 'accepts' do
-            inspect_source(cop, 'good_method')
-            expect(cop.offenses).to be_empty
+          it 'does not register an offense when using `#good_method`' do
+            expect_no_offenses(<<-RUBY.strip_indent)
+              good_method
+            RUBY
           end
         end
-      RUBY
+      SPEC
 
       def initialize(name)
         @badge = Badge.parse(name)
@@ -91,18 +92,21 @@ module RuboCop
         write_unless_file_exists(spec_path, generated_spec)
       end
 
+      def inject_require
+        RequireFileInjector.new(require_path).inject
+      end
+
       def todo
         <<-TODO.strip_indent
-          created
-          - #{source_path}
-          - #{spec_path}
-
-          Do 4 steps
-          - Add an entry to `New feature` section in CHANGELOG.md
-            - e.g. Add new `#{badge.cop_name}` cop. ([@your_id][])
-          - Add `require '#{require_path}'` into lib/rubocop.rb
-          - Add an entry into config/enabled.yml or config/disabled.yml
-          - Implement a new cop to the generated file!
+          Files created:
+            - #{source_path}
+            - #{spec_path}
+
+          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
+            3. Implement your new cop in the generated file!
         TODO
       end
 
@@ -113,6 +117,9 @@ module RuboCop
       def write_unless_file_exists(path, contents)
         raise "#{path} already exists!" if File.exist?(path)
 
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+
         File.write(path, contents)
       end
 
@@ -158,6 +165,72 @@ module RuboCop
           .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
           .downcase
       end
+
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class RequireFileInjector
+        REQUIRE_PATH = /require ['"](.+)['"]/
+
+        def initialize(require_path)
+          @require_path    = require_path
+          @require_entries = File.readlines(rubocop_root_file_path)
+        end
+
+        def inject
+          return if require_exists? || !target_line
+
+          File.write(rubocop_root_file_path, updated_directives)
+        end
+
+        private
+
+        attr_reader :require_path, :require_entries
+
+        def rubocop_root_file_path
+          File.join('lib', 'rubocop.rb')
+        end
+
+        def require_exists?
+          require_entries.any? do |entry|
+            entry == injectable_require_directive
+          end
+        end
+
+        def updated_directives
+          require_entries.insert(target_line,
+                                 injectable_require_directive).join
+        end
+
+        def target_line
+          @target_line ||= begin
+            in_the_same_department = false
+            inject_parts = require_path_fragments(injectable_require_directive)
+
+            require_entries.find.with_index do |entry, index|
+              current_entry_parts = require_path_fragments(entry)
+
+              if inject_parts[0..-2] == current_entry_parts[0..-2]
+                in_the_same_department = true
+
+                break index if inject_parts.last < current_entry_parts.last
+              elsif in_the_same_department
+                break index
+              end
+            end
+          end
+        end
+
+        def require_path_fragments(require_directove)
+          path = require_directove.match(REQUIRE_PATH)
+
+          path ? path.captures.first.split('/') : []
+        end
+
+        def injectable_require_directive
+          "require '#{require_path}'\n"
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop/cop/internal_affairs/node_type_predicate'
+require 'rubocop/cop/internal_affairs/offense_location_keyword'
+require 'rubocop/cop/internal_affairs/redundant_message_argument'
+require 'rubocop/cop/internal_affairs/redundant_location_argument'
 require 'rubocop/cop/internal_affairs/useless_message_assertion'

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

@@ -16,17 +16,28 @@ module RuboCop
       class NodeTypePredicate < Cop
         MSG = 'Use `#%s_type?` to check node type.'.freeze
 
-        def_node_search :node_type_check, <<-PATTERN
-          (send (send _ :type) :== (sym $_))
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send (send $_ :type) :== (sym $_))
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do |node_type|
+          node_type_check(node) do |_receiver, node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
             add_offense(node, :expression, format(MSG, 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

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

@@ -0,0 +1,43 @@
+# 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, node.loc.selector)
+      #
+      #   # good
+      #   add_offense(node, :selector)
+      class OffenseLocationKeyword < Cop
+        MSG = 'Use `:%s` as the location argument to `#add_offense`.'.freeze
+
+        def on_send(node)
+          offense_location(node) do |location_argument, keyword|
+            add_offense(node, location_argument.loc.expression,
+                        format(MSG, keyword))
+          end
+        end
+
+        private
+
+        def_node_matcher :offense_location, <<-PATTERN
+          (send nil :add_offense _offender
+            $(send (send _offender :loc) $_) ...)
+        PATTERN
+
+        def autocorrect(node)
+          lambda do |corrector|
+            offense_location(node) do |location_argument, keyword|
+              corrector.replace(location_argument.loc.expression, ":#{keyword}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# 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, :expression)
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, :selector)
+      #   add_offense(node, :expression, 'message')
+      #
+      class RedundantLocationArgument < Cop
+        MSG = 'Redundant location argument to `#add_offense`.'.freeze
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil :add_offense _ (sym :expression))
+        PATTERN
+
+        def on_send(node)
+          node_type_check(node) do
+            add_offense(node.last_argument)
+          end
+        end
+
+        def autocorrect(node)
+          first, second = node.parent.arguments
+
+          range = range_between(
+            first.loc.expression.end_pos,
+            second.loc.expression.end_pos
+          )
+
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end