rubocop 0.49.1 → 0.52.0

data/lib/rubocop/config_loader.rb

@@ -16,88 +16,54 @@ module RuboCop
     AUTO_GENERATED_FILE = '.rubocop_todo.yml'.freeze
 
     class << self
-      include ConfigLoaderResolver
-
-      attr_accessor :debug, :auto_gen_config
+      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion
       attr_writer :root_level # The upwards search is stopped at this level.
       attr_writer :default_configuration
 
       alias debug? debug
       alias auto_gen_config? auto_gen_config
+      alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
         @debug = @auto_gen_config = @root_level = nil
       end
 
-      def load_file(path)
-        path = File.absolute_path(path)
+      def load_file(file)
+        return if file.nil?
+        path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+
         hash = load_yaml_configuration(path)
 
         # Resolve requires first in case they define additional cops
-        resolve_requires(path, hash)
+        resolver.resolve_requires(path, hash)
 
         add_missing_namespaces(path, hash)
         target_ruby_version_to_f!(hash)
 
-        resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolve_inheritance(path, hash)
+        resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
+        resolver.resolve_inheritance(path, hash, file)
 
         hash.delete('inherit_from')
 
-        create_config(hash, path)
-      end
-
-      def create_config(hash, path)
-        config = Config.new(hash, path)
-
-        config.deprecation_check do |deprecation_message|
-          warn("#{path} - #{deprecation_message}")
-        end
-
-        config.validate
-        config.make_excludes_absolute
-        config
+        Config.create(hash, path)
       end
 
+      # rubocop:disable Performance/HashEachMethods
       def add_missing_namespaces(path, hash)
-        hash.keys.each do |k|
-          q = Cop::Cop.qualified_cop_name(k, path)
-          next if q == k
+        hash.keys.each do |key|
+          q = Cop::Cop.qualified_cop_name(key, path)
+          next if q == key
 
-          hash[q] = hash.delete(k)
+          hash[q] = hash.delete(key)
         end
       end
+      # rubocop:enable Performance/HashEachMethods
 
       # Return a recursive merge of two hashes. That is, a normal hash merge,
       # with the addition that any value that is a hash, and occurs in both
       # arguments, will also be merged. And so on.
       def merge(base_hash, derived_hash)
-        result = base_hash.merge(derived_hash)
-        keys_appearing_in_both = base_hash.keys & derived_hash.keys
-        keys_appearing_in_both.each do |key|
-          next unless base_hash[key].is_a?(Hash)
-          result[key] = merge(base_hash[key], derived_hash[key])
-        end
-        result
-      end
-
-      def base_configs(path, inherit_from)
-        configs = Array(inherit_from).compact.map do |f|
-          if f =~ /\A#{URI::Parser.new.make_regexp(%w[http https])}\z/
-            f = RemoteConfig.new(f, File.dirname(path)).file
-          else
-            f = File.expand_path(f, File.dirname(path))
-
-            if auto_gen_config?
-              next if f.include?(AUTO_GENERATED_FILE)
-            end
-
-            print 'Inheriting ' if debug?
-          end
-          load_file(f)
-        end
-
-        configs.compact
+        resolver.merge(base_hash, derived_hash)
       end
 
       # Returns the path of .rubocop.yml searching upwards in the
@@ -113,14 +79,21 @@ module RuboCop
         config = load_file(config_file)
         return config if config_file == DEFAULT_FILE
 
-        found_files = config_files_in_path(config_file)
-        if found_files.any? && found_files.last != config_file
-          print 'AllCops/Exclude ' if debug?
-          config.add_excludes_from_higher_level(load_file(found_files.last))
+        if ignore_parent_exclusion?
+          print 'Ignoring AllCops/Exclude from parent folders' if debug?
+        else
+          add_excludes_from_files(config, config_file)
         end
         merge_with_default(config, config_file)
       end
 
+      def add_excludes_from_files(config, config_file)
+        found_files = config_files_in_path(config_file)
+        return unless found_files.any? && found_files.last != config_file
+        print 'AllCops/Exclude ' if debug?
+        config.add_excludes_from_higher_level(load_file(found_files.last))
+      end
+
       def default_configuration
         @default_configuration ||= begin
                                      print 'Default ' if debug?
@@ -135,22 +108,7 @@ module RuboCop
       # so that only cops explicitly disabled in user configuration are
       # disabled.
       def merge_with_default(config, config_file)
-        default_configuration = self.default_configuration
-
-        disabled_by_default = config.for_all_cops['DisabledByDefault']
-        enabled_by_default = config.for_all_cops['EnabledByDefault']
-
-        if disabled_by_default || enabled_by_default
-          default_configuration = transform(default_configuration) do |params|
-            params.merge('Enabled' => !disabled_by_default)
-          end
-        end
-
-        if disabled_by_default
-          config = handle_disabled_by_default(config, default_configuration)
-        end
-
-        Config.new(merge(default_configuration, config), config_file)
+        resolver.merge_with_default(config, config_file)
       end
 
       def target_ruby_version_to_f!(hash)
@@ -160,40 +118,37 @@ module RuboCop
         hash['AllCops'][version] = hash['AllCops'][version].to_f
       end
 
-      private
-
-      def handle_disabled_by_default(config, new_default_configuration)
-        department_config = config.to_hash.reject { |cop| cop.include?('/') }
-        department_config.each do |dept, dept_params|
-          # Rails is always disabled by default and the department's Enabled
-          # flag works like the --rails command line option, which is that when
-          # AllCops:DisabledByDefault is true, each Rails cop must still be
-          # explicitly mentioned in user configuration in order to be enabled.
-          next if dept == 'Rails'
+      def add_inheritance_from_auto_generated_file
+        file_string = " #{AUTO_GENERATED_FILE}"
 
-          next unless dept_params['Enabled']
-
-          new_default_configuration.each do |cop, params|
-            next unless cop.start_with?(dept + '/')
-
-            # Retain original default configuration for cops in the department.
-            params['Enabled'] = default_configuration[cop]['Enabled']
-          end
+        if File.exist?(DOTFILE)
+          files = Array(load_yaml_configuration(DOTFILE)['inherit_from'])
+          return if files.include?(AUTO_GENERATED_FILE)
+          files.unshift(AUTO_GENERATED_FILE)
+          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
+          rubocop_yml_contents = IO.read(DOTFILE, encoding: Encoding::UTF_8)
+                                   .sub(/^inherit_from: *[.\w]+/, '')
+                                   .sub(/^inherit_from: *(\n *- *[.\w]+)+/, '')
         end
+        write_dotfile(file_string, rubocop_yml_contents)
+        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
+      end
+
+      private
 
-        transform(config) do |params|
-          { 'Enabled' => true }.merge(params) # Set true if not set.
+      def write_dotfile(file_string, rubocop_yml_contents)
+        File.open(DOTFILE, 'w') do |f|
+          f.write "inherit_from:#{file_string}\n\n"
+          f.write rubocop_yml_contents if rubocop_yml_contents
         end
       end
 
-      # Returns a new hash where the parameters of the given config hash have
-      # been replaced by parameters returned by the given block.
-      def transform(config)
-        Hash[config.map { |cop, params| [cop, yield(params)] }]
+      def resolver
+        @resolver ||= ConfigLoaderResolver.new
       end
 
       def load_yaml_configuration(absolute_path)
-        yaml_code = IO.read(absolute_path, encoding: Encoding::UTF_8)
+        yaml_code = read_file(absolute_path)
         hash = yaml_safe_load(yaml_code, absolute_path) || {}
 
         puts "configuration from #{absolute_path}" if debug?
@@ -205,6 +160,16 @@ module RuboCop
         hash
       end
 
+      # Read the specified file, or exit with a friendly, concise message on
+      # stderr. Care is taken to use the standard OS exit code for a "file not
+      # found" error.
+      def read_file(absolute_path)
+        IO.read(absolute_path, encoding: Encoding::UTF_8)
+      rescue Errno::ENOENT
+        warn(format('Configuration file not found: %s', absolute_path))
+        exit(Errno::ENOENT::Errno)
+      end
+
       def yaml_safe_load(yaml_code, filename)
         if YAML.respond_to?(:safe_load) # Ruby 2.1+
           if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
@@ -218,14 +183,6 @@ module RuboCop
         end
       end
 
-      def gem_config_path(gem_name, relative_config_path)
-        spec = Gem::Specification.find_by_name(gem_name)
-        return File.join(spec.gem_dir, relative_config_path)
-      rescue Gem::LoadError => e
-        raise Gem::LoadError,
-              "Unable to find gem #{gem_name}; is the gem installed? #{e}"
-      end
-
       def config_files_in_path(target)
         possible_config_files = dirs_to_search(target).map do |dir|
           File.join(dir, DOTFILE)

data/lib/rubocop/config_loader_resolver.rb

@@ -4,8 +4,8 @@ require 'yaml'
 require 'pathname'
 
 module RuboCop
-  # A mixin to break up ConfigLoader
-  module ConfigLoaderResolver
+  # A help class for ConfigLoader that handles configuration resolution.
+  class ConfigLoaderResolver
     def resolve_requires(path, hash)
       config_dir = File.dirname(path)
       Array(hash.delete('require')).each do |r|
@@ -17,8 +17,9 @@ module RuboCop
       end
     end
 
-    def resolve_inheritance(path, hash)
-      base_configs(path, hash['inherit_from']).reverse_each do |base_config|
+    def resolve_inheritance(path, hash, file)
+      base_configs(path, hash['inherit_from'], file)
+        .reverse_each do |base_config|
         base_config.each do |k, v|
           hash[k] = hash.key?(k) ? merge(v, hash[k]) : v if v.is_a?(Hash)
         end
@@ -39,5 +40,102 @@ module RuboCop
         end
       end
     end
+
+    # Merges the given configuration with the default one. If
+    # AllCops:DisabledByDefault is true, it changes the Enabled params so that
+    # only cops from user configuration are enabled.  If
+    # AllCops::EnabledByDefault is true, it changes the Enabled params so that
+    # only cops explicitly disabled in user configuration are disabled.
+    def merge_with_default(config, config_file)
+      default_configuration = ConfigLoader.default_configuration
+
+      disabled_by_default = config.for_all_cops['DisabledByDefault']
+      enabled_by_default = config.for_all_cops['EnabledByDefault']
+
+      if disabled_by_default || enabled_by_default
+        default_configuration = transform(default_configuration) do |params|
+          params.merge('Enabled' => !disabled_by_default)
+        end
+      end
+
+      if disabled_by_default
+        config = handle_disabled_by_default(config, default_configuration)
+      end
+
+      Config.new(merge(default_configuration, config), config_file)
+    end
+
+    # Returns a new hash where the parameters of the given config hash have
+    # been replaced by parameters returned by the given block.
+    # Return a recursive merge of two hashes. That is, a normal hash merge,
+    # with the addition that any value that is a hash, and occurs in both
+    # arguments, will also be merged. And so on.
+    def merge(base_hash, derived_hash)
+      result = base_hash.merge(derived_hash)
+      keys_appearing_in_both = base_hash.keys & derived_hash.keys
+      keys_appearing_in_both.each do |key|
+        next unless base_hash[key].is_a?(Hash)
+        result[key] = merge(base_hash[key], derived_hash[key])
+      end
+      result
+    end
+
+    private
+
+    def base_configs(path, inherit_from, file)
+      configs = Array(inherit_from).compact.map do |f|
+        ConfigLoader.load_file(inherited_file(path, f, file))
+      end
+
+      configs.compact
+    end
+
+    def inherited_file(path, inherit_from, file)
+      regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
+      if inherit_from =~ /\A#{regex}\z/
+        RemoteConfig.new(inherit_from, File.dirname(path))
+      elsif file.is_a?(RemoteConfig)
+        file.inherit_from_remote(inherit_from, path)
+      else
+        print 'Inheriting ' if ConfigLoader.debug?
+        File.expand_path(inherit_from, File.dirname(path))
+      end
+    end
+
+    def handle_disabled_by_default(config, new_default_configuration)
+      department_config = config.to_hash.reject { |cop| cop.include?('/') }
+      department_config.each do |dept, dept_params|
+        # Rails is always disabled by default and the department's Enabled flag
+        # works like the --rails command line option, which is that when
+        # AllCops:DisabledByDefault is true, each Rails cop must still be
+        # explicitly mentioned in user configuration in order to be enabled.
+        next if dept == 'Rails'
+
+        next unless dept_params['Enabled']
+
+        new_default_configuration.each do |cop, params|
+          next unless cop.start_with?(dept + '/')
+
+          # Retain original default configuration for cops in the department.
+          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
+        end
+      end
+
+      transform(config) do |params|
+        { 'Enabled' => true }.merge(params) # Set true if not set.
+      end
+    end
+
+    def transform(config)
+      Hash[config.map { |cop, params| [cop, yield(params)] }]
+    end
+
+    def gem_config_path(gem_name, relative_config_path)
+      spec = Gem::Specification.find_by_name(gem_name)
+      return File.join(spec.gem_dir, relative_config_path)
+    rescue Gem::LoadError => e
+      raise Gem::LoadError,
+            "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+    end
   end
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -13,7 +13,7 @@ module RuboCop
       end
 
       def support_autocorrect?
-        respond_to?(:autocorrect, true)
+        respond_to?(:autocorrect)
       end
 
       def autocorrect_enabled?

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
@@ -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
@@ -45,23 +45,25 @@ module RuboCop
 
         private
 
-        def_node_search :gem_declarations, '(send nil :gem str ...)'
+        def_node_search :gem_declarations, '(send nil? :gem str ...)'
 
         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)
           line_range = node.loc.column...node.loc.last_column
-
-          add_offense(
-            node,
-            source_range(processed_source.buffer, node.loc.line, line_range),
-            format(MSG, gem_name, line_of_first_occurrence)
+          offense_location =
+            source_range(processed_source.buffer, node.loc.line, line_range)
+          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

@@ -0,0 +1,67 @@
+# 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 `:%<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: source)
+
+            add_offense(
+              node,
+              location: source_range(node.first_argument.loc.expression),
+              message: 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