rubbycop 0.49.0

data/lib/rubbycop/comment_config.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # This class parses the special `rubbycop:disable` comments in a source
+  # and provides a way to check if each cop is enabled at arbitrary line.
+  class CommentConfig
+    UNNEEDED_DISABLE = 'Lint/UnneededDisable'.freeze
+
+    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'.freeze
+    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}".freeze
+    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
+
+    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+      ('# rubbycop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
+    )
+
+    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
+
+    attr_reader :processed_source
+
+    def initialize(processed_source)
+      @processed_source = processed_source
+    end
+
+    def cop_enabled_at_line?(cop, line_number)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
+      disabled_line_ranges = cop_disabled_line_ranges[cop]
+      return true unless disabled_line_ranges
+
+      disabled_line_ranges.none? { |range| range.include?(line_number) }
+    end
+
+    def cop_disabled_line_ranges
+      @cop_disabled_line_ranges ||= analyze
+    end
+
+    private
+
+    def analyze
+      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
+
+      each_mentioned_cop do |cop_name, disabled, line, single_line|
+        analyses[cop_name] =
+          analyze_cop(analyses[cop_name], disabled, line, single_line)
+      end
+
+      analyses.each_with_object({}) do |element, hash|
+        cop_name, analysis = *element
+        hash[cop_name] = cop_line_ranges(analysis)
+      end
+    end
+
+    def analyze_cop(analysis, disabled, line, single_line)
+      if single_line
+        analyze_single_line(analysis, line, disabled)
+      elsif disabled
+        analyze_disabled(analysis, line)
+      else
+        analyze_rest(analysis, line)
+      end
+    end
+
+    def analyze_single_line(analysis, line, disabled)
+      return analysis unless disabled
+
+      CopAnalysis.new(analysis.line_ranges + [(line..line)],
+                      analysis.start_line_number)
+    end
+
+    def analyze_disabled(analysis, line)
+      if (start_line = analysis.start_line_number)
+        # Cop already disabled on this line, so we end the current disabled
+        # range before we start a new range.
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, line)
+    end
+
+    def analyze_rest(analysis, line)
+      if (start_line = analysis.start_line_number)
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, nil)
+    end
+
+    def cop_line_ranges(analysis)
+      return analysis.line_ranges unless analysis.start_line_number
+
+      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
+    end
+
+    def each_mentioned_cop
+      each_directive do |comment, cop_names, disabled|
+        comment_line_number = comment.loc.expression.line
+        single_line = !comment_only_line?(comment_line_number)
+
+        cop_names.each do |cop_name|
+          yield qualified_cop_name(cop_name), disabled, comment_line_number,
+                single_line
+        end
+      end
+    end
+
+    def each_directive
+      return if processed_source.comments.nil?
+
+      processed_source.comments.each do |comment|
+        directive = directive_parts(comment)
+        next unless directive
+
+        yield comment, *directive
+      end
+    end
+
+    def directive_parts(comment)
+      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
+      return unless match
+
+      switch, cops_string = match.captures
+
+      cop_names =
+        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
+
+      disabled = (switch == 'disable')
+
+      [cop_names, disabled]
+    end
+
+    def qualified_cop_name(cop_name)
+      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.buffer.name)
+    end
+
+    def all_cop_names
+      @all_cop_names ||= Cop::Cop.registry.names - [UNNEEDED_DISABLE]
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none? do |non_comment_line_number|
+        non_comment_line_number == line_number
+      end
+    end
+
+    def non_comment_token_line_numbers
+      @non_comment_token_line_numbers ||= begin
+        non_comment_tokens = processed_source.tokens.reject do |token|
+          token.type == :tCOMMENT
+        end
+
+        non_comment_tokens.map { |token| token.pos.line }.uniq
+      end
+    end
+  end
+end

data/lib/rubbycop/config.rb

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+# rubbycop:disable Metrics/ClassLength
+
+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 Config
+    include PathUtil
+
+    COMMON_PARAMS = %w[Exclude Include Severity
+                       AutoCorrect StyleGuide Details].freeze
+    # 2.1 is the oldest officially supported Ruby version.
+    DEFAULT_RUBY_VERSION = 2.1
+    KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3, 2.4].freeze
+    DEFAULT_RAILS_VERSION = 5.0
+    OBSOLETE_COPS = {
+      'Style/TrailingComma' =>
+        'The `Style/TrailingComma` cop no longer exists. Please use ' \
+        '`Style/TrailingCommaInLiteral` and/or ' \
+        '`Style/TrailingCommaInArguments` instead.',
+      'Rails/DefaultScope' =>
+        'The `Rails/DefaultScope` cop no longer exists.',
+      'Style/SingleSpaceBeforeFirstArg' =>
+        'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
+        '`Layout/SpaceBeforeFirstArg`.',
+      'Lint/SpaceBeforeFirstArg' =>
+        'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
+        'duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
+        '`Layout/SpaceBeforeFirstArg` instead.',
+      'Layout/SpaceAfterControlKeyword' =>
+        'The `Layout/SpaceAfterControlKeyword` cop has been removed. Please ' \
+        'use `Layout/SpaceAroundKeyword` instead.',
+      'Layout/SpaceBeforeModifierKeyword' =>
+        'The `Layout/SpaceBeforeModifierKeyword` cop has been removed. ' \
+        'Please use `Layout/SpaceAroundKeyword` instead.',
+      'Style/SpaceAfterControlKeyword' =>
+        'The `Style/SpaceAfterControlKeyword` cop has been removed. Please ' \
+        'use `Layout/SpaceAroundKeyword` instead.',
+      'Style/SpaceBeforeModifierKeyword' =>
+        'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
+        'use `Layout/SpaceAroundKeyword` instead.',
+      'Style/MethodCallParentheses' =>
+        'The `Style/MethodCallParentheses` cop has been renamed to ' \
+          '`Style/MethodCallWithoutArgsParentheses`.',
+      'Lint/Eval' =>
+        'The `Lint/Eval` cop has been renamed to `Security/Eval`.',
+      'Style/DeprecatedHashMethods' =>
+        'The `Style/DeprecatedHashMethods` cop has been renamed to ' \
+          '`Style/PreferredHashMethods`.'
+    }.freeze
+
+    OBSOLETE_PARAMETERS = [
+      {
+        cop: 'Layout/SpaceAroundOperators',
+        parameter: 'MultiSpaceAllowedForOperators',
+        alternative: 'If your intention was to allow extra spaces ' \
+                     'for alignment, please use AllowForAlignment: ' \
+                     'true instead.'
+      },
+      {
+        cop: 'Style/SpaceAroundOperators',
+        parameter: 'MultiSpaceAllowedForOperators',
+        alternative: 'If your intention was to allow extra spaces ' \
+                     'for alignment, please use AllowForAlignment: ' \
+                     'true instead.'
+      },
+      {
+        cop: 'AllCops',
+        parameter: 'RunRailsCops',
+        alternative: "Use the following configuration instead:\n" \
+                     "Rails:\n  Enabled: true"
+      },
+      {
+        cop: 'Layout/CaseIndentation',
+        parameter: 'IndentWhenRelativeTo',
+        alternative: '`IndentWhenRelativeTo` has been renamed to ' \
+                     '`EnforcedStyle`'
+      },
+      {
+        cop: 'Lint/BlockAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Lint/EndAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Lint/DefEndAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Rails/UniqBeforePluck',
+        parameter: 'EnforcedMode',
+        alternative: '`EnforcedMode` has been renamed to ' \
+                     '`EnforcedStyle`'
+      }
+    ].freeze
+
+    attr_reader :loaded_path
+
+    def initialize(hash = {}, loaded_path = nil)
+      @loaded_path = loaded_path
+      @for_cop = Hash.new do |h, cop|
+        qualified_cop_name = Cop::Cop.qualified_cop_name(cop, loaded_path)
+        cop_options = self[qualified_cop_name] || {}
+        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+        h[cop] = cop_options
+      end
+      @hash = hash
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def delete(key)
+      @hash.delete(key)
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def key?(key)
+      @hash.key?(key)
+    end
+
+    def keys
+      @hash.keys
+    end
+
+    def map(&block)
+      @hash.map(&block)
+    end
+
+    def merge(other_hash)
+      @hash.merge(other_hash)
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_s
+      @to_s ||= @hash.to_s
+    end
+
+    def make_excludes_absolute
+      each do |key, _|
+        validate_section_presence(key)
+        next unless self[key]['Exclude']
+
+        self[key]['Exclude'].map! do |exclude_elem|
+          if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
+            File.expand_path(File.join(base_dir_for_path_parameters,
+                                       exclude_elem))
+          else
+            exclude_elem
+          end
+        end
+      end
+    end
+
+    def add_excludes_from_higher_level(highest_config)
+      return unless highest_config.for_all_cops['Exclude']
+
+      excludes = for_all_cops['Exclude'] ||= []
+      highest_config.for_all_cops['Exclude'].each do |path|
+        unless path.is_a?(Regexp) || absolute?(path)
+          path = File.join(File.dirname(highest_config.loaded_path), path)
+        end
+        excludes << path unless excludes.include?(path)
+      end
+    end
+
+    def deprecation_check
+      %w[Exclude Include].each do |key|
+        plural = "#{key}s"
+        next unless for_all_cops[plural]
+
+        for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
+        for_all_cops.delete(plural)
+        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
+      end
+    end
+
+    def for_cop(cop)
+      @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
+    end
+
+    def for_all_cops
+      @for_all_cops ||= self['AllCops'] || {}
+    end
+
+    def validate
+      # Don't validate RubbyCop's own files. Avoids infinite recursion.
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
+                                                    'config'))
+      return if File.expand_path(loaded_path).start_with?(base_config_path)
+
+      valid_cop_names, invalid_cop_names = keys.partition do |key|
+        ConfigLoader.default_configuration.key?(key)
+      end
+
+      reject_obsolete_cops_and_parameters
+      warn_about_unrecognized_cops(invalid_cop_names)
+      check_target_ruby
+      validate_parameter_names(valid_cop_names)
+      validate_enforced_styles(valid_cop_names)
+      reject_mutually_exclusive_defaults
+    end
+
+    def file_to_include?(file)
+      relative_file_path = path_relative_to_config(file)
+
+      # Optimization to quickly decide if the given file is hidden (on the top
+      # level) and can not be matched by any pattern.
+      is_hidden = relative_file_path.start_with?('.') &&
+                  !relative_file_path.start_with?('..')
+      return false if is_hidden && !possibly_include_hidden?
+
+      absolute_file_path = File.expand_path(file)
+
+      patterns_to_include.any? do |pattern|
+        match_path?(pattern, relative_file_path) ||
+          match_path?(pattern, absolute_file_path)
+      end
+    end
+
+    # Returns true if there's a chance that an Include pattern matches hidden
+    # files, false if that's definitely not possible.
+    def possibly_include_hidden?
+      return @possibly_include_hidden if defined?(@possibly_include_hidden)
+
+      @possibly_include_hidden = patterns_to_include.any? do |s|
+        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
+      end
+    end
+
+    def file_to_exclude?(file)
+      file = File.expand_path(file)
+      patterns_to_exclude.any? do |pattern|
+        match_path?(pattern, file)
+      end
+    end
+
+    def patterns_to_include
+      for_all_cops['Include']
+    end
+
+    def patterns_to_exclude
+      for_all_cops['Exclude']
+    end
+
+    def path_relative_to_config(path)
+      relative_path(path, base_dir_for_path_parameters)
+    end
+
+    # Paths specified in configuration files starting with .rubbycop are
+    # relative to the directory where that file is. Paths in other config files
+    # are relative to the current directory. This is so that paths in
+    # config/default.yml, for example, are not relative to RubbyCop's config
+    # directory since that wouldn't work.
+    def base_dir_for_path_parameters
+      @base_dir_for_path_parameters ||=
+        if File.basename(loaded_path).start_with?('.rubbycop') &&
+           loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
+          File.expand_path(File.dirname(loaded_path))
+        else
+          Dir.pwd
+        end
+    end
+
+    def target_ruby_version
+      @target_ruby_version ||=
+        if for_all_cops['TargetRubyVersion']
+          @target_ruby_version_source = :rubbycop_yml
+
+          for_all_cops['TargetRubyVersion']
+        elsif File.file?('.ruby-version') &&
+              /\A(ruby-)?(?<version>\d+\.\d+)/ =~ File.read('.ruby-version')
+
+          @target_ruby_version_source = :dot_ruby_version
+
+          version.to_f
+        else
+          DEFAULT_RUBY_VERSION
+        end
+    end
+
+    def target_rails_version
+      @target_rails_version ||=
+        for_all_cops.fetch('TargetRailsVersion', DEFAULT_RAILS_VERSION)
+    end
+
+    private
+
+    def warn_about_unrecognized_cops(invalid_cop_names)
+      invalid_cop_names.each do |name|
+        if name == 'Syntax'
+          raise ValidationError,
+                "configuration for Syntax cop found in #{loaded_path}\n" \
+                'This cop cannot be configured.'
+        end
+
+        # There could be a custom cop with this name. If so, don't warn
+        next if Cop::Cop.registry.contains_cop_matching?([name])
+
+        warn Rainbow("Warning: unrecognized cop #{name} found in " \
+                     "#{loaded_path}").yellow
+      end
+    end
+
+    def validate_section_presence(name)
+      return unless key?(name) && self[name].nil?
+      raise ValidationError, "empty section #{name} found in #{loaded_path}"
+    end
+
+    def validate_parameter_names(valid_cop_names)
+      valid_cop_names.each do |name|
+        validate_section_presence(name)
+        self[name].each_key do |param|
+          next if COMMON_PARAMS.include?(param) ||
+                  ConfigLoader.default_configuration[name].key?(param)
+
+          warn Rainbow("Warning: unrecognized parameter #{name}:#{param} " \
+                       "found in #{loaded_path}").yellow
+        end
+      end
+    end
+
+    def validate_enforced_styles(valid_cop_names)
+      valid_cop_names.each do |name|
+        styles = self[name].select { |key, _| key.start_with?('Enforced') }
+
+        styles.each do |style_name, style|
+          supported_key = RubbyCop::Cop::Util.to_supported_styles(style_name)
+          valid = ConfigLoader.default_configuration[name][supported_key]
+          next unless valid
+          next if valid.include?(style)
+
+          msg = "invalid #{style_name} '#{style}' for #{name} found in " \
+            "#{loaded_path}\n" \
+            "Valid choices are: #{valid.join(', ')}"
+          raise ValidationError, msg
+        end
+      end
+    end
+
+    def reject_obsolete_cops_and_parameters
+      messages = [
+        obsolete_cops,
+        obsolete_parameters
+      ].flatten.compact
+      return if messages.empty?
+
+      raise ValidationError, messages.join("\n")
+    end
+
+    def obsolete_parameters
+      OBSOLETE_PARAMETERS.map do |params|
+        obsolete_parameter_message(params[:cop], params[:parameter],
+                                   params[:alternative])
+      end
+    end
+
+    def obsolete_parameter_message(cop, parameter, alternative)
+      return unless self[cop] && self[cop].key?(parameter)
+
+      "obsolete parameter #{parameter} (for #{cop}) " \
+        "found in #{loaded_path}" \
+        "\n#{alternative}"
+    end
+
+    def obsolete_cops
+      OBSOLETE_COPS.map do |cop_name, message|
+        next unless key?(cop_name) || key?(Cop::Badge.parse(cop_name).cop_name)
+        message + "\n(obsolete configuration found in #{loaded_path}, please" \
+                   ' update it)'
+      end
+    end
+
+    def check_target_ruby
+      return if KNOWN_RUBIES.include?(target_ruby_version)
+
+      msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
+
+      msg +=
+        case @target_ruby_version_source
+        when :dot_ruby_version
+          'in `.ruby-version`.'
+        when :rubbycop_yml
+          "in `TargetRubyVersion` parameter (in #{loaded_path})." \
+        end
+
+      msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
+
+      raise ValidationError, msg
+    end
+
+    def reject_mutually_exclusive_defaults
+      disabled_by_default = for_all_cops['DisabledByDefault']
+      enabled_by_default = for_all_cops['EnabledByDefault']
+      return unless disabled_by_default && enabled_by_default
+
+      msg = 'Cops cannot be both enabled by default and disabled by default'
+      raise ValidationError, msg
+    end
+
+    def enable_cop?(qualified_cop_name, cop_options)
+      cop_department, cop_name = qualified_cop_name.split('/')
+      department = cop_name.nil?
+
+      unless department
+        department_options = self[cop_department]
+        if department_options && department_options.fetch('Enabled') == false
+          return false
+        end
+      end
+
+      cop_options.fetch('Enabled', true)
+    end
+  end
+end