rubbycop 0.49.0

data/lib/rubbycop/rake_task.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+
+module RubbyCop
+  # Provides a custom rake task.
+  #
+  # require 'rubbycop/rake_task'
+  # RubbyCop::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(*args, &task_block)
+      setup_ivars(args)
+
+      desc 'Run RubbyCop' unless ::Rake.application.last_description
+
+      task(name, *args) do |_, task_args|
+        RakeFileUtils.send(:verbose, verbose) do
+          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+          run_main_task(verbose)
+        end
+      end
+
+      setup_subtasks(name, *args, &task_block)
+    end
+
+    def run_main_task(verbose)
+      run_cli(verbose, full_options)
+    end
+
+    private
+
+    def run_cli(verbose, options)
+      # We lazy-load rubbycop so that the task doesn't dramatically impact the
+      # load time of your Rakefile.
+      require 'rubbycop'
+
+      cli = CLI.new
+      puts 'Running RubbyCop...' if verbose
+      result = cli.run(options)
+      abort('RubbyCop failed!') if result.nonzero? && fail_on_error
+    end
+
+    def full_options
+      [].tap do |result|
+        result.concat(formatters.map { |f| ['--format', f] }.flatten)
+        result.concat(requires.map { |r| ['--require', r] }.flatten)
+        result.concat(options.flatten)
+        result.concat(patterns)
+      end
+    end
+
+    def setup_ivars(args)
+      # More lazy-loading to keep load time down.
+      require 'rubbycop/options'
+
+      @name = args.shift || :rubbycop
+      @verbose = true
+      @fail_on_error = true
+      @patterns = []
+      @requires = []
+      @options = []
+      @formatters = []
+    end
+
+    def setup_subtasks(name, *args, &task_block)
+      namespace name do
+        desc 'Auto-correct RubbyCop offenses'
+
+        task(:auto_correct, *args) do |_, task_args|
+          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+          options = full_options.unshift('--auto-correct')
+          run_cli(verbose, options)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/remote_config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'time'
+
+module RubbyCop
+  # Common methods and behaviors for dealing with remote config files.
+  class RemoteConfig
+    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|
+        open cache_path, 'w' do |io|
+          io.write response.body
+        end
+      end
+
+      cache_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 = true if uri.instance_of? URI::HTTPS
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      if cache_path_exists?
+        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
+      end
+
+      handle_response(http.request(request), limit, &block)
+    end
+
+    def handle_response(response, limit, &block)
+      case response
+      when Net::HTTPSuccess
+        yield response
+      when Net::HTTPRedirection
+        request(URI.parse(response['location']), limit - 1, &block)
+      else
+        response.error!
+      end
+    end
+
+    def cache_path
+      File.expand_path(".rubbycop-#{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

data/lib/rubbycop/result_cache.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'find'
+require 'tmpdir'
+require 'etc'
+
+module RubbyCop
+  # Provides functionality for caching rubbycop runs.
+  class ResultCache
+    NON_CHANGING = %i[color format formatters out debug fail_level
+                      cache fail_fast stdin parallel].freeze
+
+    # Remove old files so that the cache doesn't grow too big. When the
+    # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
+    # files in the cache are removed. The reason for removing so much is that
+    # cleaning should be done relatively seldom, since there is a slight risk
+    # that some other RubbyCop process was just about to read the file, when
+    # there's parallel execution and the cache is shared.
+    def self.cleanup(config_store, verbose, cache_root = nil)
+      return if inhibit_cleanup # OPTIMIZE: For faster testing
+      cache_root ||= cache_root(config_store)
+      return unless File.exist?(cache_root)
+
+      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      return unless requires_file_removal?(files.length, config_store)
+
+      remove_oldest_files(files, dirs, cache_root, verbose)
+    end
+
+    class << self
+      private
+
+      def requires_file_removal?(file_count, config_store)
+        file_count > 1 &&
+          file_count > config_store.for('.').for_all_cops['MaxFilesInCache']
+      end
+
+      def remove_oldest_files(files, dirs, cache_root, verbose)
+        # Add 1 to half the number of files, so that we remove the file if
+        # there's only 1 left.
+        remove_count = 1 + files.length / 2
+        if verbose
+          puts "Removing the #{remove_count} oldest files from #{cache_root}"
+        end
+        sorted = files.sort_by { |path| File.mtime(path) }
+        remove_files(sorted, dirs, remove_count)
+      rescue Errno::ENOENT
+        # This can happen if parallel RubbyCop invocations try to remove the
+        # same files. No problem.
+        puts $ERROR_INFO if verbose
+      end
+
+      def remove_files(files, dirs, remove_count)
+        # Batch file deletions, deleting over 130,000+ files will crash
+        # File.delete.
+        files[0, remove_count].each_slice(10_000).each do |files_slice|
+          File.delete(*files_slice)
+        end
+        dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
+      end
+    end
+
+    def self.cache_root(config_store)
+      root = config_store.for('.').for_all_cops['CacheRootDirectory']
+      if root == '/tmp'
+        tmpdir = File.realpath(Dir.tmpdir)
+        # Include user ID in the path to make sure the user has write access.
+        root = File.join(tmpdir, Process.uid.to_s)
+      end
+      File.join(root, 'rubbycop_cache')
+    end
+
+    def self.allow_symlinks_in_cache_location?(config_store)
+      config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+    end
+
+    def initialize(file, options, config_store, cache_root = nil)
+      cache_root ||= ResultCache.cache_root(config_store)
+      @allow_symlinks_in_cache_location =
+        ResultCache.allow_symlinks_in_cache_location?(config_store)
+      @path = File.join(cache_root, rubbycop_checksum,
+                        relevant_options_digest(options),
+                        file_checksum(file, config_store))
+      @cached_data = CachedData.new(file)
+    end
+
+    def valid?
+      File.exist?(@path)
+    end
+
+    def load
+      @cached_data.from_json(IO.read(@path, encoding: Encoding::UTF_8))
+    end
+
+    def save(offenses)
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir)
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      # RubbyCop must be in control of where its cached data is stored. A
+      # symbolic link anywhere in the cache directory tree can be an
+      # indication that a symlink attack is being waged.
+      return if symlink_protection_triggered?(dir)
+
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RubbyCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    end
+
+    private
+
+    def symlink_protection_triggered?(path)
+      !@allow_symlinks_in_cache_location && any_symlink?(path)
+    end
+
+    def any_symlink?(path)
+      while path != File.dirname(path)
+        if File.symlink?(path)
+          warn "Warning: #{path} is a symlink, which is not allowed."
+          return true
+        end
+        path = File.dirname(path)
+      end
+      false
+    end
+
+    def file_checksum(file, config_store)
+      Digest::MD5.hexdigest(Dir.pwd + file + IO.read(file) +
+                            config_store.for(file).to_s)
+    rescue Errno::ENOENT
+      # Spurious files that come and go should not cause a crash, at least not
+      # here.
+      '_'
+    end
+
+    class << self
+      attr_accessor :source_checksum, :inhibit_cleanup
+    end
+
+    # The checksum of the rubbycop program running the inspection.
+    def rubbycop_checksum
+      ResultCache.source_checksum ||=
+        begin
+          lib_root = File.join(File.dirname(__FILE__), '..')
+          bin_root = File.join(lib_root, '..', 'bin')
+
+          # These are all the files we have `require`d plus everything in the
+          # bin directory. A change to any of them could affect the cop output
+          # so we include them in the cache hash.
+          source_files = $LOADED_FEATURES + Find.find(bin_root).to_a
+          sources = source_files
+                    .select { |path| File.file?(path) }
+                    .sort
+                    .map { |path| IO.read(path, encoding: Encoding::UTF_8) }
+          Digest::MD5.hexdigest(sources.join)
+        end
+    end
+
+    # Return a hash of the options given at invocation, minus the ones that have
+    # no effect on which offenses and disabled line ranges are found, and thus
+    # don't affect caching.
+    def relevant_options_digest(options)
+      options = options.reject { |key, _| NON_CHANGING.include?(key) }
+      options = options.to_s.gsub(/[^a-z]+/i, '_')
+      # We must avoid making file names too long for some filesystems to handle
+      # If they are short, we can leave them human-readable
+      options.length <= 32 ? options : Digest::MD5.hexdigest(options)
+    end
+  end
+end

data/lib/rubbycop/rspec/cop_helper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+# This module provides methods that make it easier to test Cops.
+module CopHelper
+  extend RSpec::SharedContext
+
+  let(:ruby_version) { 2.2 }
+  let(:enabled_rails) { false }
+  let(:rails_version) { false }
+
+  def inspect_source_file(cop, source)
+    Tempfile.open('tmp') { |f| inspect_source(cop, source, f) }
+  end
+
+  def inspect_gemfile(cop, source)
+    inspect_source(cop, source, 'Gemfile')
+  end
+
+  def inspect_source(cop, source, file = nil)
+    if source.is_a?(Array) && source.size == 1
+      raise "Don't use an array for a single line of code: #{source}"
+    end
+    RubbyCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RubbyCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    processed_source = parse_source(source, file)
+    raise 'Error parsing example code' unless processed_source.valid_syntax?
+    _investigate(cop, processed_source)
+  end
+
+  def parse_source(source, file = nil)
+    source = source.join($RS) if source.is_a?(Array)
+
+    if file && file.respond_to?(:write)
+      file.write(source)
+      file.rewind
+      file = file.path
+    end
+
+    RubbyCop::ProcessedSource.new(source, ruby_version, file)
+  end
+
+  def autocorrect_source_file(cop, source)
+    Tempfile.open('tmp') { |f| autocorrect_source(cop, source, f) }
+  end
+
+  def autocorrect_source(cop, source, file = nil)
+    cop.instance_variable_get(:@options)[:auto_correct] = true
+    processed_source = parse_source(source, file)
+    _investigate(cop, processed_source)
+
+    corrector =
+      RubbyCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector.rewrite
+  end
+
+  def autocorrect_source_with_loop(cop, source, file = nil)
+    loop do
+      cop.instance_variable_set(:@corrections, [])
+      new_source = autocorrect_source(cop, source, file)
+      return new_source if new_source == source
+      source = new_source
+    end
+  end
+
+  def _investigate(cop, processed_source)
+    forces = RubbyCop::Cop::Force.all.each_with_object([]) do |klass, instances|
+      next unless cop.join_force?(klass)
+      instances << klass.new([cop])
+    end
+
+    commissioner =
+      RubbyCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+    commissioner.investigate(processed_source)
+    commissioner
+  end
+end
+
+module RubbyCop
+  module Cop
+    # Monkey-patch Cop for tests to provide easy access to messages and
+    # highlights.
+    class Cop
+      def messages
+        offenses.sort.map(&:message)
+      end
+
+      def highlights
+        offenses.sort.map { |o| o.location.source }
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CopHelper
+end

data/lib/rubbycop/rspec/host_environment_simulation_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# RubbyCop can be run in contexts where unexpected other libraries are included,
+# which may interfere with its normal behavior. In order to test those
+# situations, it may be necessary to require another library for the duration
+# of one spec
+module HostEnvironmentSimulatorHelper
+  def in_its_own_process_with(*files)
+    if ::Process.respond_to?(:fork)
+      pid = ::Process.fork do
+        # Need to write coverage result under different name
+        if defined?(SimpleCov)
+          SimpleCov.coverage_dir "coverage/ignored_results_#{Process.pid}"
+          SimpleCov.pid = Process.pid
+        end
+
+        files.each { |file| require file }
+        yield
+      end
+      ::Process.wait(pid)
+
+      # assert that the block did not fail
+      expect($CHILD_STATUS).to be_success
+    else
+      warn 'Process.fork is not available.'
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include HostEnvironmentSimulatorHelper
+end