rubocop 0.78.0

data/lib/rubocop/path_util.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Common methods and behaviors for dealing with paths.
+  module PathUtil
+    module_function
+
+    def relative_path(path, base_dir = PathUtil.pwd)
+      # Optimization for the common case where path begins with the base
+      # dir. Just cut off the first part.
+      if path.start_with?(base_dir)
+        base_dir_length = base_dir.length
+        result_length = path.length - base_dir_length - 1
+        return path[base_dir_length + 1, result_length]
+      end
+
+      path_name = Pathname.new(File.expand_path(path))
+      begin
+        path_name.relative_path_from(Pathname.new(base_dir)).to_s
+      rescue ArgumentError
+        path
+      end
+    end
+
+    def smart_path(path)
+      # Ideally, we calculate this relative to the project root.
+      base_dir = PathUtil.pwd
+
+      if path.start_with? base_dir
+        relative_path(path, base_dir)
+      else
+        path
+      end
+    end
+
+    def match_path?(pattern, path)
+      case pattern
+      when String
+        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
+          hidden_file_in_not_hidden_dir?(pattern, path)
+      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]:)?/}i
+    end
+
+    def self.pwd
+      @pwd ||= Dir.pwd
+    end
+
+    def self.reset_pwd
+      @pwd = nil
+    end
+
+    def self.chdir(dir, &block)
+      reset_pwd
+      Dir.chdir(dir, &block)
+    ensure
+      reset_pwd
+    end
+
+    def hidden_file_in_not_hidden_dir?(pattern, path)
+      File.fnmatch?(
+        pattern, path,
+        File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+      ) && File.basename(path).start_with?('.') && !hidden_dir?(path)
+    end
+
+    def hidden_dir?(path)
+      File.dirname(path).split(File::SEPARATOR).any? do |dir|
+        dir.start_with?('.')
+      end
+    end
+  end
+end

data/lib/rubocop/platform.rb

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

data/lib/rubocop/processed_source.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+module RuboCop
+  # 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)'
+
+    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 RuboCop::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.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::SHA1.hexdigest(@raw_source)
+    end
+
+    def each_comment
+      comments.each { |comment| yield comment }
+    end
+
+    def find_comment
+      comments.find { |comment| yield comment }
+    end
+
+    def each_token
+      tokens.each { |token| yield token }
+    end
+
+    def find_token
+      tokens.find { |token| yield token }
+    end
+
+    def file_path
+      buffer.name
+    end
+
+    def blank?
+      ast.nil?
+    end
+
+    def commented?(source_range)
+      comment_lines.include?(source_range.line)
+    end
+
+    def comments_before_line(line)
+      comments.select { |c| c.location.line <= line }
+    end
+
+    def start_with?(string)
+      return false if self[0].nil?
+
+      self[0].start_with?(string)
+    end
+
+    def preceding_line(token)
+      lines[token.line - 2]
+    end
+
+    def current_line(token)
+      lines[token.line - 1]
+    end
+
+    def following_line(token)
+      lines[token.line]
+    end
+
+    def line_indentation(line_number)
+      lines[line_number - 1]
+        .match(/^(\s*)/)[1]
+        .to_s
+        .length
+    end
+
+    private
+
+    def comment_lines
+      @comment_lines ||= comments.map { |c| c.location.line }
+    end
+
+    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 => e
+        @parser_error = e
+        return
+      end
+
+      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
+    end
+
+    def tokenize(parser)
+      begin
+        ast, comments, tokens = parser.tokenize(@buffer)
+
+        ast.respond_to?(:complete!) && ast.complete!
+      rescue Parser::SyntaxError # rubocop:disable Lint/SuppressedException
+        # 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
+
+    # rubocop:disable Metrics/MethodLength
+    def parser_class(ruby_version)
+      case ruby_version
+      when 2.3
+        require 'parser/ruby23'
+        Parser::Ruby23
+      when 2.4
+        require 'parser/ruby24'
+        Parser::Ruby24
+      when 2.5
+        require 'parser/ruby25'
+        Parser::Ruby25
+      when 2.6
+        require 'parser/ruby26'
+        Parser::Ruby26
+      when 2.7
+        require 'parser/ruby27'
+        Parser::Ruby27
+      else
+        raise ArgumentError,
+              "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def create_parser(ruby_version)
+      builder = RuboCop::AST::Builder.new
+
+      parser_class(ruby_version).new(builder).tap do |parser|
+        # On JRuby 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

data/lib/rubocop/rake_task.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+
+module RuboCop
+  # Provides a custom rake task.
+  #
+  # require 'rubocop/rake_task'
+  # RuboCop::RakeTask.new
+  class RakeTask < Rake::TaskLib
+    attr_accessor :name
+    attr_accessor :verbose
+    attr_accessor :fail_on_error
+    attr_accessor :patterns
+    attr_accessor :formatters
+    attr_accessor :requires
+    attr_accessor :options
+
+    def initialize(name = :rubocop, *args, &task_block)
+      setup_ivars(name)
+
+      desc 'Run RuboCop' unless ::Rake.application.last_description
+
+      task(name, *args) do |_, task_args|
+        RakeFileUtils.verbose(verbose) do
+          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+          run_cli(verbose, full_options)
+        end
+      end
+
+      setup_subtasks(name, *args, &task_block)
+    end
+
+    private
+
+    def run_cli(verbose, options)
+      # We lazy-load rubocop so that the task doesn't dramatically impact the
+      # load time of your Rakefile.
+      require 'rubocop'
+
+      cli = CLI.new
+      puts 'Running RuboCop...' if verbose
+      result = cli.run(options)
+      abort('RuboCop failed!') if result.nonzero? && fail_on_error
+    end
+
+    def full_options
+      formatters.map { |f| ['--format', f] }.flatten
+                .concat(requires.map { |r| ['--require', r] }.flatten)
+                .concat(options.flatten)
+                .concat(patterns)
+    end
+
+    def setup_ivars(name)
+      @name = name
+      @verbose = true
+      @fail_on_error = true
+      @patterns = []
+      @requires = []
+      @options = []
+      @formatters = []
+    end
+
+    def setup_subtasks(name, *args, &task_block)
+      namespace(name) do
+        desc 'Auto-correct RuboCop offenses'
+
+        task(:auto_correct, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+            options = full_options.unshift('--auto-correct')
+            options.delete('--parallel')
+            run_cli(verbose, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/remote_config.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'time'
+
+module RuboCop
+  # Common methods and behaviors for dealing with remote config files.
+  class RemoteConfig
+    attr_reader :uri
+
+    CACHE_LIFETIME = 24 * 60 * 60
+
+    def initialize(url, base_dir)
+      @uri = URI.parse(url)
+      @base_dir = base_dir
+    end
+
+    def file
+      return cache_path unless cache_path_expired?
+
+      request do |response|
+        next if response.is_a?(Net::HTTPNotModified)
+        next if response.is_a?(SocketError)
+
+        File.open cache_path, 'w' do |io|
+          io.write response.body
+        end
+      end
+
+      cache_path
+    end
+
+    def inherit_from_remote(file, path)
+      new_uri = @uri.dup
+      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file}")
+      RemoteConfig.new(new_uri.to_s, File.dirname(path))
+    end
+
+    private
+
+    def request(uri = @uri, limit = 10, &block)
+      raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = uri.instance_of?(URI::HTTPS)
+
+      generate_request(uri) do |request|
+        begin
+          handle_response(http.request(request), limit, &block)
+        rescue SocketError => e
+          handle_response(e, limit, &block)
+        end
+      end
+    end
+
+    def generate_request(uri)
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      if cache_path_exists?
+        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
+      end
+
+      yield request
+    end
+
+    def handle_response(response, limit, &block)
+      case response
+      when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
+        yield response
+      when Net::HTTPRedirection
+        request(URI.parse(response['location']), limit - 1, &block)
+      else
+        begin
+          response.error!
+        rescue StandardError => e
+          message = "#{e.message} while downloading remote config"\
+            " file #{uri}"
+          raise e, message
+        end
+      end
+    end
+
+    def cache_path
+      File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)
+    end
+
+    def cache_path_exists?
+      @cache_path_exists ||= File.exist?(cache_path)
+    end
+
+    def cache_path_expired?
+      return true unless cache_path_exists?
+
+      @cache_path_expired ||= begin
+        file_age = (Time.now - File.stat(cache_path).mtime).to_f
+        (file_age / CACHE_LIFETIME) > 1
+      end
+    end
+
+    def cache_name_from_uri
+      uri = @uri.clone
+      uri.query = nil
+      uri.to_s.gsub!(/[^0-9A-Za-z]/, '-')
+    end
+  end
+end