rubbycop 0.49.0

data/lib/rubbycop/options.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'shellwords'
+
+module RubbyCop
+  # This class handles command line options.
+  class Options
+    EXITING_OPTIONS = %i[version verbose_version show_cops].freeze
+    DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
+
+    def initialize
+      @options = {}
+      @validator = OptionsValidator.new(@options)
+    end
+
+    def parse(command_line_args)
+      args = args_from_file.concat(args_from_env).concat(command_line_args)
+      define_options(args).parse!(args)
+      # The --no-color CLI option sets `color: false` so we don't want the
+      # `no_color` key, which is created automatically.
+      @options.delete(:no_color)
+
+      @validator.validate_compatibility
+
+      if @options[:stdin]
+        # The parser has put the file name given after --stdin into
+        # @options[:stdin]. The args array should be empty.
+        if args.any?
+          raise ArgumentError, '-s/--stdin requires exactly one path.'
+        end
+        # We want the STDIN contents in @options[:stdin] and the file name in
+        # args to simplify the rest of the processing.
+        args = [@options[:stdin]]
+        @options[:stdin] = $stdin.binmode.read
+      end
+
+      [@options, args]
+    end
+
+    private
+
+    def args_from_file
+      if File.exist?('.rubbycop') && !File.directory?('.rubbycop')
+        IO.readlines('.rubbycop').map(&:strip)
+      else
+        []
+      end
+    end
+
+    def args_from_env
+      Shellwords.split(ENV.fetch('RUBOCOP_OPTS', ''))
+    end
+
+    def define_options(args)
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: rubbycop [options] [file1, file2, ...]'
+
+        add_list_options(opts)
+        add_only_options(opts)
+        add_configuration_options(opts, args)
+        add_formatting_options(opts)
+
+        option(opts, '-r', '--require FILE') { |f| require f }
+
+        add_severity_option(opts)
+        add_flags_with_optional_args(opts)
+        add_boolean_flags(opts)
+
+        option(opts, '-s', '--stdin FILE')
+      end
+    end
+
+    def add_only_options(opts)
+      add_cop_selection_csv_option('except', opts)
+      add_cop_selection_csv_option('only', opts)
+      option(opts, '--only-guide-cops')
+    end
+
+    def add_cop_selection_csv_option(option, opts)
+      option(opts, "--#{option} [COP1,COP2,...]") do |list|
+        @options[:"#{option}"] =
+          if list.empty?
+            ['']
+          else
+            list.split(',').map do |c|
+              Cop::Cop.qualified_cop_name(c, "--#{option} option")
+            end
+          end
+      end
+    end
+
+    def add_configuration_options(opts, args)
+      option(opts, '-c', '--config FILE')
+
+      option(opts, '--auto-gen-config')
+
+      option(opts, '--exclude-limit COUNT') do
+        @validator.validate_exclude_limit_option(args)
+      end
+
+      option(opts, '--force-exclusion')
+
+      option(opts, '--force-default-config')
+
+      option(opts, '--no-offense-counts') do
+        @options[:no_offense_counts] = true
+      end
+    end
+
+    def add_formatting_options(opts)
+      option(opts, '-f', '--format FORMATTER') do |key|
+        @options[:formatters] ||= []
+        @options[:formatters] << [key]
+      end
+
+      option(opts, '-o', '--out FILE') do |path|
+        if @options[:formatters]
+          @options[:formatters].last << path
+        else
+          @options[:output_path] = path
+        end
+      end
+    end
+
+    def add_severity_option(opts)
+      table = RubbyCop::Cop::Severity::CODE_TABLE.merge(A: :autocorrect)
+      option(opts, '--fail-level SEVERITY',
+             RubbyCop::Cop::Severity::NAMES + [:autocorrect],
+             table) do |severity|
+        @options[:fail_level] = severity
+      end
+    end
+
+    def add_flags_with_optional_args(opts)
+      option(opts, '--show-cops [COP1,COP2,...]') do |list|
+        @options[:show_cops] = list.nil? ? [] : list.split(',')
+      end
+    end
+
+    def add_boolean_flags(opts) # rubbycop:disable Metrics/MethodLength
+      option(opts, '-F', '--fail-fast')
+      option(opts, '-C', '--cache FLAG')
+      option(opts, '-d', '--debug')
+      option(opts, '-D', '--display-cop-names')
+      option(opts, '-E', '--extra-details')
+      option(opts, '-S', '--display-style-guide')
+      option(opts, '-R', '--rails')
+      option(opts, '-l', '--lint') do
+        @options[:only] ||= []
+        @options[:only] << 'Lint'
+      end
+      option(opts, '-a', '--auto-correct')
+
+      option(opts, '--[no-]color') { |c| @options[:color] = c }
+
+      option(opts, '-v', '--version')
+      option(opts, '-V', '--verbose-version')
+      option(opts, '-P', '--parallel')
+    end
+
+    def add_list_options(opts)
+      option(opts, '-L', '--list-target-files')
+    end
+
+    # Sets a value in the @options hash, based on the given long option and its
+    # value, in addition to calling the block if a block is given.
+    def option(opts, *args)
+      long_opt_symbol = long_opt_symbol(args)
+      args += Array(OptionsHelp::TEXT[long_opt_symbol])
+      opts.on(*args) do |arg|
+        @options[long_opt_symbol] = arg
+        yield arg if block_given?
+      end
+    end
+
+    # Finds the option in `args` starting with -- and converts it to a symbol,
+    # e.g. [..., '--auto-correct', ...] to :auto_correct.
+    def long_opt_symbol(args)
+      long_opt = args.find { |arg| arg.start_with?('--') }
+      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
+    end
+  end
+
+  # Validates option arguments and the options' compatibility with each other.
+  class OptionsValidator
+    # Cop name validation must be done later than option parsing, so it's not
+    # called from within Options.
+    def self.validate_cop_list(names)
+      return unless names
+
+      departments = Cop::Cop.registry.departments.map(&:to_s)
+
+      names.each do |name|
+        next if Cop::Cop.registry.names.include?(name)
+        next if departments.include?(name)
+        next if %w[Syntax Lint/Syntax].include?(name)
+
+        raise ArgumentError, "Unrecognized cop or department: #{name}."
+      end
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def validate_compatibility # rubbycop:disable Metrics/MethodLength
+      if only_includes_unneeded_disable?
+        raise ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
+      end
+      if except_syntax?
+        raise ArgumentError, 'Syntax checking can not be turned off.'
+      end
+      unless boolean_or_empty_cache?
+        raise ArgumentError, '-C/--cache argument must be true or false'
+      end
+      if no_offense_counts_without_auto_gen_config?
+        raise ArgumentError, '--no-offense-counts can only be used together ' \
+                             'with --auto-gen-config.'
+      end
+      validate_parallel
+
+      return if incompatible_options.size <= 1
+      raise ArgumentError, 'Incompatible cli options: ' \
+                           "#{incompatible_options.inspect}"
+    end
+
+    def validate_parallel
+      return unless @options.key?(:parallel)
+
+      if @options[:cache] == 'false'
+        raise ArgumentError, '-P/--parallel uses caching to speed up ' \
+                             'execution, so combining with --cache false is ' \
+                             'not allowed.'
+      end
+
+      combos = {
+        auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
+                         'while --auto-gen-config needs a non-cached run, ' \
+                         'so they cannot be combined.',
+        fail_fast: '-P/--parallel can not be combined with -F/--fail-fast.',
+        auto_correct: '-P/--parallel can not be combined with --auto-correct.'
+      }
+
+      combos.each { |key, msg| raise ArgumentError, msg if @options.key?(key) }
+    end
+
+    def only_includes_unneeded_disable?
+      @options.key?(:only) &&
+        (@options[:only] & %w[Lint/UnneededDisable UnneededDisable]).any?
+    end
+
+    def except_syntax?
+      @options.key?(:except) &&
+        (@options[:except] & %w[Lint/Syntax Syntax]).any?
+    end
+
+    def boolean_or_empty_cache?
+      !@options.key?(:cache) || %w[true false].include?(@options[:cache])
+    end
+
+    def no_offense_counts_without_auto_gen_config?
+      @options.key?(:no_offense_counts) && !@options.key?(:auto_gen_config)
+    end
+
+    def incompatible_options
+      @incompatible_options ||= @options.keys & Options::EXITING_OPTIONS
+    end
+
+    def validate_exclude_limit_option(args)
+      if @options[:exclude_limit] !~ /^\d+$/
+        # Emulate OptionParser's behavior to make failures consistent regardless
+        # of option order.
+        raise OptionParser::MissingArgument
+      end
+
+      # --exclude-limit is valid if there's a parsed or yet unparsed
+      # --auto-gen-config.
+      return if @options[:auto_gen_config] || args.include?('--auto-gen-config')
+
+      raise ArgumentError,
+            '--exclude-limit can only be used with --auto-gen-config.'
+    end
+  end
+
+  # This module contains help texts for command line options.
+  module OptionsHelp
+    MAX_EXCL = RubbyCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
+    TEXT = {
+      only:                  'Run only the given cop(s).',
+      only_guide_cops:      ['Run only cops for rules that link to a',
+                             'style guide.'],
+      except:                'Disable the given cop(s).',
+      require:               'Require Ruby file.',
+      config:                'Specify configuration file.',
+      auto_gen_config:      ['Generate a configuration file acting as a',
+                             'TODO list.'],
+      no_offense_counts:    ['Do not include offense counts in configuration',
+                             'file generated by --auto-gen-config.'],
+      exclude_limit:        ['Used together with --auto-gen-config to',
+                             'set the limit for how many Exclude',
+                             "properties to generate. Default is #{MAX_EXCL}."],
+      force_exclusion:      ['Force excluding files specified in the',
+                             'configuration `Exclude` even if they are',
+                             'explicitly passed as arguments.'],
+      force_default_config: ['Use default configuration even if configuration',
+                             'files are present in the directory tree.'],
+      format:               ['Choose an output formatter. This option',
+                             'can be specified multiple times to enable',
+                             'multiple formatters at the same time.',
+                             '  [p]rogress (default)',
+                             '  [s]imple',
+                             '  [c]lang',
+                             '  [d]isabled cops via inline comments',
+                             '  [fu]ubar',
+                             '  [e]macs',
+                             '  [j]son',
+                             '  [h]tml',
+                             '  [fi]les',
+                             '  [o]ffenses',
+                             '  [w]orst',
+                             '  custom formatter class name'],
+      out:                  ['Write output to a file instead of STDOUT.',
+                             'This option applies to the previously',
+                             'specified --format, or the default format',
+                             'if no format is specified.'],
+      fail_level:           ['Minimum severity (A/R/C/W/E/F) for exit',
+                             'with error code.'],
+      show_cops:            ['Shows the given cops, or all cops by',
+                             'default, and their configurations for the',
+                             'current directory.'],
+      fail_fast:            ['Inspect files in order of modification',
+                             'time and stop after the first file',
+                             'containing offenses.'],
+      cache:                ["Use result caching (FLAG=true) or don't",
+                             '(FLAG=false), default determined by',
+                             'configuration parameter AllCops: UseCache.'],
+      debug:                 'Display debug info.',
+      display_cop_names:     'Display cop names in offense messages.',
+      display_style_guide:   'Display style guide URLs in offense messages.',
+      extra_details:         'Display extra details in offense messages.',
+      rails:                 'Run extra Rails cops.',
+      lint:                  'Run only lint cops.',
+      list_target_files:     'List all files RubbyCop will inspect.',
+      auto_correct:          'Auto-correct offenses.',
+      no_color:              'Force color output on or off.',
+      version:               'Display version.',
+      verbose_version:       'Display verbose version.',
+      parallel:             ['Use available CPUs to execute inspection in',
+                             'parallel.'],
+      stdin:                ['Pipe source from STDIN, using FILE in offense',
+                             'reports. This is useful for editor integration.']
+    }.freeze
+  end
+end

data/lib/rubbycop/path_util.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # Common methods and behaviors for dealing with paths.
+  module PathUtil
+    module_function
+
+    def relative_path(path, base_dir = Dir.pwd)
+      # Optimization for the common case where path begins with the base
+      # dir. Just cut off the first part.
+      return path[(base_dir.length + 1)..-1] if path.start_with?(base_dir)
+
+      path_name = Pathname.new(File.expand_path(path))
+      path_name.relative_path_from(Pathname.new(base_dir)).to_s
+    end
+
+    def match_path?(pattern, path)
+      case pattern
+      when String
+        File.fnmatch?(pattern, path, File::FNM_PATHNAME)
+      when Regexp
+        begin
+          path =~ pattern
+        rescue ArgumentError => e
+          return false if e.message.start_with?('invalid byte sequence')
+          raise e
+        end
+      end
+    end
+
+    # Returns true for an absolute Unix or Windows path.
+    def absolute?(path)
+      path =~ %r{\A([A-Z]:)?/}
+    end
+  end
+end

data/lib/rubbycop/platform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # This module provides information on the platform that RubbyCop is being run
+  # on.
+  module Platform
+    def self.windows?
+      RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+    end
+  end
+end

data/lib/rubbycop/processed_source.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+module RubbyCop
+  # ProcessedSource contains objects which are generated by Parser
+  # and other information such as disabled lines for cops.
+  # It also provides a convenient way to access source lines.
+  class ProcessedSource
+    STRING_SOURCE_NAME = '(string)'.freeze
+
+    attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
+                :parser_error, :raw_source, :ruby_version
+
+    def self.from_file(path, ruby_version)
+      file = File.read(path, mode: 'rb')
+      new(file, ruby_version, path)
+    rescue Errno::ENOENT
+      raise RubbyCop::Error, "No such file or directory: #{path}"
+    end
+
+    def initialize(source, ruby_version, path = nil)
+      # Defaults source encoding to UTF-8, regardless of the encoding it has
+      # been read with, which could be non-utf8 depending on the default
+      # external encoding.
+      unless source.encoding == Encoding::UTF_8
+        source.force_encoding(Encoding::UTF_8)
+      end
+
+      @raw_source = source
+      @path = path
+      @diagnostics = []
+      @ruby_version = ruby_version
+      @parser_error = nil
+
+      parse(source, ruby_version)
+    end
+
+    def comment_config
+      @comment_config ||= CommentConfig.new(self)
+    end
+
+    def disabled_line_ranges
+      comment_config.cop_disabled_line_ranges
+    end
+
+    def ast_with_comments
+      return if !ast || !comments
+      @ast_with_comments ||= Parser::Source::Comment.associate(ast, comments)
+    end
+
+    # Returns the source lines, line break characters removed, excluding a
+    # possible __END__ and everything that comes after.
+    def lines
+      @lines ||= begin
+        all_lines = @buffer.source_lines
+        last_token_line = tokens.any? ? tokens.last.pos.line : all_lines.size
+        result = []
+        all_lines.each_with_index do |line, ix|
+          break if ix >= last_token_line && line == '__END__'
+          result << line
+        end
+        result
+      end
+    end
+
+    def [](*args)
+      lines[*args]
+    end
+
+    def valid_syntax?
+      return false if @parser_error
+      @diagnostics.none? { |d| %i[error fatal].include?(d.level) }
+    end
+
+    # Raw source checksum for tracking infinite loops.
+    def checksum
+      Digest::MD5.hexdigest(@raw_source)
+    end
+
+    private
+
+    def parse(source, ruby_version)
+      buffer_name = @path || STRING_SOURCE_NAME
+      @buffer = Parser::Source::Buffer.new(buffer_name, 1)
+
+      begin
+        @buffer.source = source
+      rescue EncodingError => error
+        @parser_error = error
+        return
+      end
+
+      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
+    end
+
+    def tokenize(parser)
+      begin
+        ast, comments, tokens = parser.tokenize(@buffer)
+        ast.complete! if ast
+      rescue Parser::SyntaxError # rubbycop:disable Lint/HandleExceptions
+        # All errors are in diagnostics. No need to handle exception.
+      end
+
+      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+
+      [ast, comments, tokens]
+    end
+
+    def parser_class(ruby_version) # rubbycop:disable Metrics/MethodLength
+      case ruby_version
+      when 1.9
+        require 'parser/ruby19'
+        Parser::Ruby19
+      when 2.0
+        require 'parser/ruby20'
+        Parser::Ruby20
+      when 2.1
+        require 'parser/ruby21'
+        Parser::Ruby21
+      when 2.2
+        require 'parser/ruby22'
+        Parser::Ruby22
+      when 2.3
+        require 'parser/ruby23'
+        Parser::Ruby23
+      when 2.4
+        require 'parser/ruby24'
+        Parser::Ruby24
+      else
+        raise ArgumentError, "Unknown Ruby version: #{ruby_version.inspect}"
+      end
+    end
+
+    def create_parser(ruby_version)
+      builder = RubbyCop::AST::Builder.new
+
+      parser_class(ruby_version).new(builder).tap do |parser|
+        # On JRuby and Rubinius, there's a risk that we hang in tokenize() if we
+        # don't set the all errors as fatal flag. The problem is caused by a bug
+        # in Racc that is discussed in issue #93 of the whitequark/parser
+        # project on GitHub.
+        parser.diagnostics.all_errors_are_fatal = (RUBY_ENGINE != 'ruby')
+        parser.diagnostics.ignore_warnings = false
+        parser.diagnostics.consumer = lambda do |diagnostic|
+          @diagnostics << diagnostic
+        end
+      end
+    end
+  end
+end