rubocop 0.42.0 → 0.52.1

data/lib/rubocop/config_loader.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'yaml'
@@ -17,70 +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_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolve_inheritance(path, hash)
-        resolve_requires(path, hash)
+        # Resolve requires first in case they define additional cops
+        resolver.resolve_requires(path, hash)
+
+        add_missing_namespaces(path, hash)
+        target_ruby_version_to_f!(hash)
+
+        resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
+        resolver.resolve_inheritance(path, hash, file)
 
         hash.delete('inherit_from')
-        config = Config.new(hash, path)
 
-        config.deprecation_check do |deprecation_message|
-          warn("#{path} - #{deprecation_message}")
-        end
+        Config.create(hash, path)
+      end
+
+      # rubocop:disable Performance/HashEachMethods
+      def add_missing_namespaces(path, hash)
+        hash.keys.each do |key|
+          q = Cop::Cop.qualified_cop_name(key, path)
+          next if q == key
 
-        config.add_missing_namespaces
-        config.validate
-        config.make_excludes_absolute
-        config
+          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.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
@@ -96,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?
@@ -114,33 +104,52 @@ module RuboCop
       # 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)
-        configs =
-          if config.for_all_cops['DisabledByDefault']
-            disabled_default = transform(default_configuration) do |params|
-              params.merge('Enabled' => false) # Overwrite with false.
-            end
-            enabled_user_config = transform(config) do |params|
-              { 'Enabled' => true }.merge(params) # Set true if not set.
-            end
-            [disabled_default, enabled_user_config]
-          else
-            [default_configuration, config]
-          end
-        Config.new(merge(configs.first, configs.last), config_file)
+        resolver.merge_with_default(config, config_file)
+      end
+
+      def target_ruby_version_to_f!(hash)
+        version = 'TargetRubyVersion'
+        return unless hash['AllCops'] && hash['AllCops'][version]
+
+        hash['AllCops'][version] = hash['AllCops'][version].to_f
+      end
+
+      def add_inheritance_from_auto_generated_file
+        file_string = " #{AUTO_GENERATED_FILE}"
+
+        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
 
-      # 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 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
+
+      def resolver
+        @resolver ||= ConfigLoaderResolver.new
       end
 
       def load_yaml_configuration(absolute_path)
-        yaml_code = IO.read(absolute_path, encoding: 'UTF-8')
-        hash = yaml_safe_load(yaml_code) || {}
+        yaml_code = read_file(absolute_path)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
 
         puts "configuration from #{absolute_path}" if debug?
 
@@ -151,26 +160,29 @@ module RuboCop
         hash
       end
 
-      def yaml_safe_load(yaml_code)
+      # 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)
-            SafeYAML.load(yaml_code, nil, whitelisted_tags: %w(!ruby/regexp))
+            SafeYAML.load(yaml_code, filename,
+                          whitelisted_tags: %w[!ruby/regexp])
           else
-            YAML.safe_load(yaml_code, [Regexp])
+            YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, filename)
           end
         else
-          YAML.load(yaml_code)
+          YAML.load(yaml_code, filename) # rubocop:disable Security/YAMLLoad
         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)
@@ -188,5 +200,8 @@ module RuboCop
         dirs_to_search
       end
     end
+
+    # Initializing class ivars
+    clear_options
   end
 end

data/lib/rubocop/config_loader_resolver.rb

@@ -1,12 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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|
@@ -18,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
@@ -34,9 +34,108 @@ module RuboCop
         end
 
         hash['inherit_from'] = Array(hash['inherit_from'])
-        # Put gem configuration first so local configuration overrides it.
-        hash['inherit_from'].unshift gem_config_path(gem_name, config_path)
+        Array(config_path).reverse.each do |path|
+          # Put gem configuration first so local configuration overrides it.
+          hash['inherit_from'].unshift gem_config_path(gem_name, path)
+        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/config_store.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -26,6 +25,10 @@ module RuboCop
                                                         options_config)
     end
 
+    def force_default_config!
+      @options_config = ConfigLoader.default_configuration
+    end
+
     def for(file_or_dir)
       return @options_config if @options_config
 

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,7 +13,7 @@ module RuboCop
       end
 
       def support_autocorrect?
-        respond_to?(:autocorrect, true)
+        respond_to?(:autocorrect)
       end
 
       def autocorrect_enabled?

data/lib/rubocop/cop/badge.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Identifier of all cops containing a department and cop name.
+    #
+    # All cops are identified by their badge. For example, the badge
+    # for `RuboCop::Cop::Layout::Tab` is `Layout/Tab`. Badges can be
+    # parsed as either `Department/CopName` or just `CopName` to allow
+    # for badge references in source files that omit the department
+    # for RuboCop to infer.
+    class Badge
+      # Error raised when a badge parse fails.
+      class InvalidBadge < Error
+        MSG = 'Invalid badge %<badge>p. ' \
+              'Expected `Department/CopName` or `CopName`.'.freeze
+
+        def initialize(token)
+          super(format(MSG, badge: token))
+        end
+      end
+
+      attr_reader :department, :cop_name
+
+      def self.for(class_name)
+        new(*class_name.split('::').last(2))
+      end
+
+      def self.parse(identifier)
+        parts = identifier.split('/', 2)
+
+        raise InvalidBadge, identifier if parts.size > 2
+
+        if parts.one?
+          new(nil, *parts)
+        else
+          new(*parts)
+        end
+      end
+
+      def initialize(department, cop_name)
+        @department = department.to_sym if department
+        @cop_name   = cop_name
+      end
+
+      def ==(other)
+        hash == other.hash
+      end
+      alias eql? ==
+
+      def hash
+        [department, cop_name].hash
+      end
+
+      def match?(other)
+        cop_name == other.cop_name &&
+          (!qualified? || department == other.department)
+      end
+
+      def to_s
+        qualified? ? "#{department}/#{cop_name}" : cop_name
+      end
+
+      def qualified?
+        !department.nil?
+      end
+
+      def with_department(department)
+        self.class.new(department, cop_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # A Gem's requirements should be listed only once in a Gemfile.
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rubocop'
+      #
+      #   # bad
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   group :development, :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   gem 'rubocop', groups: [:development, :test]
+      class DuplicatedGem < Cop
+        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
+
+          duplicated_gem_nodes.each do |nodes|
+            nodes[1..-1].each do |node|
+              register_offense(
+                node,
+                node.first_argument.to_a.first,
+                nodes.first.first_line
+              )
+            end
+          end
+        end
+
+        private
+
+        def_node_search :gem_declarations, '(send nil? :gem str ...)'
+
+        def duplicated_gem_nodes
+          gem_declarations(processed_source.ast)
+            .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
+          offense_location =
+            source_range(processed_source.buffer, node.first_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
+  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