rubbycop 0.49.0

data/lib/rubbycop/config_loader.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+
+module RubbyCop
+  # This class represents the configuration of the RubbyCop application
+  # and all its cops. A Config is associated with a YAML configuration
+  # file from which it was read. Several different Configs can be used
+  # during a run of the rubbycop program, if files in several
+  # directories are inspected.
+  class ConfigLoader
+    DOTFILE = '.rubbycop.yml'.freeze
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+    AUTO_GENERATED_FILE = '.rubbycop_todo.yml'.freeze
+
+    class << self
+      include ConfigLoaderResolver
+
+      attr_accessor :debug, :auto_gen_config
+      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
+
+      def clear_options
+        @debug = @auto_gen_config = @root_level = nil
+      end
+
+      def load_file(path)
+        path = File.absolute_path(path)
+        hash = load_yaml_configuration(path)
+
+        # Resolve requires first in case they define additional cops
+        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)
+
+        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
+      end
+
+      def add_missing_namespaces(path, hash)
+        hash.keys.each do |k|
+          q = Cop::Cop.qualified_cop_name(k, path)
+          next if q == k
+
+          hash[q] = hash.delete(k)
+        end
+      end
+
+      # 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
+      end
+
+      # Returns the path of .rubbycop.yml searching upwards in the
+      # directory structure starting at the given directory where the
+      # inspected file is. If no .rubbycop.yml is found there, the
+      # user's home directory is checked. If there's no .rubbycop.yml
+      # there either, the path to the default file is returned.
+      def configuration_file_for(target_dir)
+        config_files_in_path(target_dir).first || DEFAULT_FILE
+      end
+
+      def configuration_from_file(config_file)
+        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))
+        end
+        merge_with_default(config, config_file)
+      end
+
+      def default_configuration
+        @default_configuration ||= begin
+                                     print 'Default ' if debug?
+                                     load_file(DEFAULT_FILE)
+                                   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 = 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)
+      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
+
+      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|
+          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
+        end
+
+        transform(config) do |params|
+          { 'Enabled' => true }.merge(params) # Set true if not set.
+        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)] }]
+      end
+
+      def load_yaml_configuration(absolute_path)
+        yaml_code = IO.read(absolute_path, encoding: Encoding::UTF_8)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
+
+        unless hash.is_a?(Hash)
+          raise(TypeError, "Malformed configuration in #{absolute_path}")
+        end
+
+        hash
+      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, filename,
+                          whitelisted_tags: %w[!ruby/regexp])
+          else
+            YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, filename)
+          end
+        else
+          YAML.load(yaml_code, filename) # rubbycop: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)
+        end
+        possible_config_files.select { |config_file| File.exist?(config_file) }
+      end
+
+      def dirs_to_search(target_dir)
+        dirs_to_search = []
+        Pathname.new(File.expand_path(target_dir)).ascend do |dir_pathname|
+          break if dir_pathname.to_s == @root_level
+          dirs_to_search << dir_pathname.to_s
+        end
+        dirs_to_search << Dir.home if ENV.key? 'HOME'
+        dirs_to_search
+      end
+    end
+
+    # Initializing class ivars
+    clear_options
+  end
+end

data/lib/rubbycop/config_loader_resolver.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+
+module RubbyCop
+  # A mixin to break up ConfigLoader
+  module ConfigLoaderResolver
+    def resolve_requires(path, hash)
+      config_dir = File.dirname(path)
+      Array(hash.delete('require')).each do |r|
+        if r.start_with?('.')
+          require(File.join(config_dir, r))
+        else
+          require(r)
+        end
+      end
+    end
+
+    def resolve_inheritance(path, hash)
+      base_configs(path, hash['inherit_from']).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
+      end
+    end
+
+    def resolve_inheritance_from_gems(hash, gems)
+      (gems || {}).each_pair do |gem_name, config_path|
+        if gem_name == 'rubbycop'
+          raise ArgumentError,
+                "can't inherit configuration from the rubbycop gem"
+        end
+
+        hash['inherit_from'] = Array(hash['inherit_from'])
+        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
+  end
+end

data/lib/rubbycop/config_store.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # Handles caching of configurations and association of inspected
+  # ruby files to configurations.
+  class ConfigStore
+    def initialize
+      # @options_config stores a config that is specified in the command line.
+      # This takes precedence over configs located in any directories
+      @options_config = nil
+
+      # @path_cache maps directories to configuration paths. We search
+      # for .rubbycop.yml only if we haven't already found it for the
+      # given directory.
+      @path_cache = {}
+
+      # @object_cache maps configuration file paths to
+      # configuration objects so we only need to load them once.
+      @object_cache = {}
+    end
+
+    def options_config=(options_config)
+      loaded_config = ConfigLoader.load_file(options_config)
+      @options_config = ConfigLoader.merge_with_default(loaded_config,
+                                                        options_config)
+    end
+
+    def force_default_config!
+      @options_config = ConfigLoader.default_configuration
+    end
+
+    def for(file_or_dir)
+      return @options_config if @options_config
+
+      dir = if File.directory?(file_or_dir)
+              file_or_dir
+            else
+              File.dirname(file_or_dir)
+            end
+      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
+      path = @path_cache[dir]
+      @object_cache[path] ||= begin
+                                print "For #{dir}: " if ConfigLoader.debug?
+                                ConfigLoader.configuration_from_file(path)
+                              end
+    end
+  end
+end

data/lib/rubbycop/cop/autocorrect_logic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # This module encapsulates the logic for autocorrect behavior for a cop.
+    module AutocorrectLogic
+      def autocorrect?
+        autocorrect_requested? && support_autocorrect? && autocorrect_enabled?
+      end
+
+      def autocorrect_requested?
+        @options.fetch(:auto_correct, false)
+      end
+
+      def support_autocorrect?
+        respond_to?(:autocorrect, true)
+      end
+
+      def autocorrect_enabled?
+        # allow turning off autocorrect on a cop by cop basis
+        return true unless cop_config
+        cop_config['AutoCorrect'] != false
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/badge.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Identifier of all cops containing a department and cop name.
+    #
+    # All cops are identified by their badge. For example, the badge
+    # for `RubbyCop::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 RubbyCop 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/rubbycop/cop/bundler/duplicated_gem.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Bundler
+      # A Gem's requirements should be listed only once in a Gemfile.
+      # @example
+      #   # bad
+      #   gem 'rubbycop'
+      #   gem 'rubbycop'
+      #
+      #   # bad
+      #   group :development do
+      #     gem 'rubbycop'
+      #   end
+      #
+      #   group :test do
+      #     gem 'rubbycop'
+      #   end
+      #
+      #   # good
+      #   group :development, :test do
+      #     gem 'rubbycop'
+      #   end
+      #
+      #   # good
+      #   gem 'rubbycop', groups: [:development, :test]
+      class DuplicatedGem < Cop
+        MSG = 'Gem `%s` requirements already given on line %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.method_args.first.to_a.first,
+                nodes.first.loc.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 { |e| e.method_args.first }
+            .keep_if { |_, nodes| nodes.length > 1 }
+            .values
+        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)
+          )
+        end
+      end
+    end
+  end
+end