rubocop 0.35.1 → 0.36.0

data/lib/rubocop/path_util.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # Common methods and behaviors for dealing with paths.

data/lib/rubocop/processed_source.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-require 'astrolabe/builder'
 require 'digest/md5'
 
 module RuboCop
@@ -8,29 +8,32 @@ module RuboCop
   # 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)'
+    STRING_SOURCE_NAME = '(string)'.freeze
+
     attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                :parser_error, :raw_source
+                :parser_error, :raw_source, :ruby_version
 
-    def self.from_file(path)
+    def self.from_file(path, ruby_version)
       file = File.read(path)
-      new(file, path)
+      new(file, ruby_version, path)
     rescue Errno::ENOENT
-      abort("#{Rainbow('rubocop: No such file or directory').red} -- #{path}")
-    rescue => ex
-      abort("#{Rainbow("rubocop: #{ex.message}").red} -- #{path}")
+      raise RuboCop::Error, "No such file or directory: #{path}"
     end
 
-    def initialize(source, path = nil)
+    def initialize(source, ruby_version, path = nil)
       # In Ruby 2, source code encoding defaults to UTF-8. We follow the same
       # principle regardless of which Ruby version we're running under.
       # Encoding comments will override this setting.
-      source.force_encoding(Encoding::UTF_8)
+      unless source.encoding == Encoding::UTF_8
+        source.force_encoding(Encoding::UTF_8)
+      end
 
       @raw_source = source
       @path = path
       @diagnostics = []
-      parse(source)
+      @ruby_version = ruby_version
+
+      parse(source, ruby_version)
     end
 
     def comment_config
@@ -72,7 +75,7 @@ module RuboCop
 
     private
 
-    def parse(source)
+    def parse(source, ruby_version)
       buffer_name = @path || STRING_SOURCE_NAME
       @buffer = Parser::Source::Buffer.new(buffer_name, 1)
 
@@ -83,7 +86,7 @@ module RuboCop
         return
       end
 
-      parser = create_parser
+      parser = create_parser(ruby_version)
 
       begin
         @ast, @comments, tokens = parser.tokenize(@buffer)
@@ -94,10 +97,32 @@ module RuboCop
       @tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
     end
 
-    def create_parser
-      builder = Astrolabe::Builder.new
+    def parser_class(ruby_version)
+      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
+      else
+        fail ArgumentError, "Unknown Ruby version: #{ruby_version.inspect}"
+      end
+    end
+
+    def create_parser(ruby_version)
+      builder = RuboCop::Node::Builder.new
 
-      Parser::CurrentRuby.new(builder).tap do |parser|
+      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

data/lib/rubocop/rake_task.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'rake'
 require 'rake/tasklib'
@@ -24,9 +25,7 @@ module RuboCop
 
       task(name, *args) do |_, task_args|
         RakeFileUtils.send(:verbose, verbose) do
-          if task_block
-            task_block.call(*[self, task_args].slice(0, task_block.arity))
-          end
+          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
           run_main_task(verbose)
         end
       end
@@ -53,8 +52,8 @@ module RuboCop
 
     def full_options
       [].tap do |result|
-        result.concat(formatters.map { |f| ['--format', f] }.flatten)
-        result.concat(requires.map { |r| ['--require', r] }.flatten)
+        result.concat(formatters.flat_map { |f| ['--format', f] })
+        result.concat(requires.flat_map { |r| ['--require', r] })
         result.concat(options)
         result.concat(patterns)
       end
@@ -70,7 +69,7 @@ module RuboCop
       @patterns = []
       @requires = []
       @options = []
-      @formatters = [RuboCop::Options::DEFAULT_FORMATTER]
+      @formatters = []
     end
 
     def setup_subtasks(name, *args, &task_block)
@@ -78,9 +77,7 @@ module RuboCop
         desc 'Auto-correct RuboCop offenses'
 
         task(:auto_correct, *args) do |_, task_args|
-          if task_block
-            task_block.call(*[self, task_args].slice(0, task_block.arity))
-          end
+          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
           options = full_options.unshift('--auto-correct')
           run_cli(verbose, options)
         end

data/lib/rubocop/remote_config.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'net/http'
 

data/lib/rubocop/result_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'digest/md5'
 require 'find'
@@ -8,44 +9,12 @@ require 'etc'
 module RuboCop
   # Provides functionality for caching rubocop runs.
   class ResultCache
-    # Include the user name in the path as a simple means of avoiding write
-    # collisions.
-    def initialize(file, options, config_store, cache_root = nil)
-      cache_root ||= ResultCache.cache_root(config_store)
-      @path = File.join(cache_root, rubocop_checksum, RUBY_VERSION,
-                        relevant_options(options),
-                        file_checksum(file, config_store))
-    end
-
-    def valid?
-      File.exist?(@path)
-    end
-
-    def load
-      Marshal.load(IO.binread(@path))
-    end
-
-    def save(offenses, disabled_line_ranges, comments)
-      FileUtils.mkdir_p(File.dirname(@path))
-      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
-      File.open(preliminary_path, 'wb') do |f|
-        # The Hash[x.sort] call is a trick that converts a Hash with a default
-        # block to a Hash without a default block. Thus making it possible to
-        # dump.
-        f.write(Marshal.dump([offenses, Hash[disabled_line_ranges.sort],
-                              comments]))
-      end
-      # The preliminary path is used so that if there are multiple RuboCop
-      # 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
+    NON_CHANGING = [:color, :format, :formatters, :out, :debug, :fail_level,
+                    :cache, :fail_fast, :stdin].freeze
 
     # Remove old files so that the cache doesn't grow too big. When the
-    # threshold MaxFilesInCache has been exceeded, the oldest 50% all the files
-    # in the cache are removed. The reason for removing so much is that
+    # 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 RuboCop process was just about to read the file, when
     # there's parallel execution and the cache is shared.
@@ -65,7 +34,7 @@ module RuboCop
         end
         sorted = files.sort_by { |path| File.mtime(path) }
         begin
-          sorted[0, remove_count].each { |path| File.delete(path) }
+          File.delete(*sorted[0, remove_count])
           dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
         rescue Errno::ENOENT
           # This can happen if parallel RuboCop invocations try to remove the
@@ -75,14 +44,65 @@ module RuboCop
       end
     end
 
-    private
-
     def self.cache_root(config_store)
       root = config_store.for('.')['AllCops']['CacheRootDirectory']
-      root = File.join(Dir.tmpdir, Process.uid.to_s) if root == '/tmp'
+      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, 'rubocop_cache')
     end
 
+    def initialize(file, options, config_store, cache_root = nil)
+      cache_root ||= ResultCache.cache_root(config_store)
+      @path = File.join(cache_root, rubocop_checksum, RUBY_VERSION,
+                        relevant_options(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.binread(@path))
+    end
+
+    def save(offenses)
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir)
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      # RuboCop must be in control of where its cached data is stored. A
+      # symbolic link anywhere in the cache directory tree is an indication
+      # that a symlink attack is being waged.
+      return if any_symlink?(dir)
+
+      File.open(preliminary_path, 'wb') do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # 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 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)
@@ -109,9 +129,6 @@ module RuboCop
         end
     end
 
-    NON_CHANGING = [:color, :format, :formatters, :out, :debug, :fail_level,
-                    :cache, :fail_fast, :stdin]
-
     # Return 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.

data/lib/rubocop/runner.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # This class handles the processing of files, which includes dealing with
@@ -16,7 +17,7 @@ module RuboCop
     end
 
     attr_reader :errors, :warnings, :aborting
-    alias_method :aborting?, :aborting
+    alias aborting? aborting
 
     def initialize(options, config_store)
       @options = options
@@ -76,37 +77,43 @@ module RuboCop
 
     def process_file(file)
       puts "Scanning #{file}" if @options[:debug]
+      file_started(file)
 
       cache = ResultCache.new(file, @options, @config_store) if cached_run?
       if cache && cache.valid?
-        offenses, disabled_line_ranges, comments = cache.load
-        file_started(file, disabled_line_ranges, comments)
+        offenses = cache.load
       else
-        processed_source = get_processed_source(file)
-        # Use delegators for objects sent to the formatters. These can be
-        # updated when the file is re-inspected.
-        disabled_line_ranges =
-          SimpleDelegator.new(processed_source.disabled_line_ranges)
-        comments = SimpleDelegator.new(processed_source.comments)
-
-        file_started(file, disabled_line_ranges, comments)
-        offenses = do_inspection_loop(file, processed_source,
-                                      disabled_line_ranges, comments)
-        save_in_cache(cache, offenses, processed_source)
+        source = get_processed_source(file)
+        source, offenses = do_inspection_loop(file, source)
+        offenses = add_unneeded_disables(file, offenses.compact.sort, source)
+        save_in_cache(cache, offenses)
       end
 
-      offenses = formatter_set.file_finished(file, offenses.compact.sort.freeze)
-
+      formatter_set.file_finished(file, offenses)
       offenses
     rescue InfiniteCorrectionLoop => e
       formatter_set.file_finished(file, e.offenses.compact.sort.freeze)
       raise
     end
 
-    def file_started(file, disabled_line_ranges, comments)
+    def add_unneeded_disables(file, offenses, source)
+      if source.disabled_line_ranges.any? &&
+         # Don't check unneeded disable if --only or --except option is
+         # given, because these options override configuration.
+         (@options[:except] || []).empty? && (@options[:only] || []).empty?
+        config = @config_store.for(file)
+        if config['Lint/UnneededDisable']['Enabled']
+          cop = Cop::Lint::UnneededDisable.new(config, @options)
+          cop.check(offenses, source.disabled_line_ranges, source.comments)
+          offenses += cop.offenses
+        end
+      end
+
+      offenses.sort.reject(&:disabled?).freeze
+    end
+
+    def file_started(file)
       formatter_set.file_started(file,
-                                 cop_disabled_line_ranges: disabled_line_ranges,
-                                 comments: comments,
                                  cli_options: @options,
                                  config_store: @config_store)
     end
@@ -121,22 +128,22 @@ module RuboCop
         # need to do that processing and can not use caching.
         !@options[:auto_gen_config] &&
         # Auto-correction needs a full run. It can not use cached results.
-        !@options[:auto_correct]
+        !@options[:auto_correct] &&
+        # We can't cache results from code which is piped in to stdin
+        !@options[:stdin]
     end
 
-    def save_in_cache(cache, offenses, processed_source)
+    def save_in_cache(cache, offenses)
       return unless cache
       # Caching results when a cop has crashed would prevent the crash in the
       # next run, since the cop would not be called then. We want crashes to
       # show up the same in each run.
       return if errors.any? || warnings.any?
 
-      cache.save(offenses, processed_source.disabled_line_ranges,
-                 processed_source.comments)
+      cache.save(offenses)
     end
 
-    def do_inspection_loop(file, processed_source, disabled_line_ranges,
-                           comments)
+    def do_inspection_loop(file, processed_source)
       offenses = []
 
       # Keep track of the state of the source. If a cop modifies the source
@@ -163,13 +170,9 @@ module RuboCop
         break unless updated_source_file
 
         processed_source = get_processed_source(file)
-
-        # Update delegators with new objects.
-        disabled_line_ranges.__setobj__(processed_source.disabled_line_ranges)
-        comments.__setobj__(processed_source.comments)
       end
 
-      offenses
+      [processed_source, offenses]
     end
 
     # Check whether a run created source identical to a previous run, which
@@ -186,6 +189,7 @@ module RuboCop
 
     def inspect_file(processed_source)
       config = @config_store.for(processed_source.path)
+      enable_rails_cops(config) if @options[:rails]
       team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
       offenses = team.inspect_file(processed_source)
       @errors.concat(team.errors)
@@ -193,6 +197,11 @@ module RuboCop
       [offenses, team.updated_source_file?]
     end
 
+    def enable_rails_cops(config)
+      config['Rails'] ||= {}
+      config['Rails']['Enabled'] = true
+    end
+
     def mobilized_cop_classes(config)
       @mobilized_cop_classes ||= {}
       @mobilized_cop_classes[config.object_id] ||= begin
@@ -219,13 +228,6 @@ module RuboCop
       if style_guide_cops_only?(config)
         cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
       end
-
-      # filter out Rails cops unless requested
-      cop_classes.reject!(&:rails?) unless run_rails_cops?(config)
-    end
-
-    def run_rails_cops?(config)
-      @options[:rails] || config['AllCops']['RunRailsCops']
     end
 
     def style_guide_cops_only?(config)
@@ -234,16 +236,12 @@ module RuboCop
 
     def formatter_set
       @formatter_set ||= begin
-        set = Formatter::FormatterSet.new
-        pairs = @options[:formatters] || [[Options::DEFAULT_FORMATTER]]
+        set = Formatter::FormatterSet.new(@options)
+        pairs = @options[:formatters] || [['progress']]
         pairs.each do |formatter_key, output_path|
           set.add_formatter(formatter_key, output_path)
         end
         set
-      rescue => error
-        warn error.message
-        $stderr.puts error.backtrace
-        exit(1)
       end
     end
 
@@ -264,8 +262,13 @@ module RuboCop
     end
 
     def get_processed_source(file)
-      return ProcessedSource.new(@options[:stdin], file) if @options[:stdin]
-      ProcessedSource.from_file(file)
+      ruby_version = @config_store.for(file)['AllCops']['TargetRubyVersion']
+
+      if @options[:stdin]
+        ProcessedSource.new(@options[:stdin], ruby_version, file)
+      else
+        ProcessedSource.from_file(file, ruby_version)
+      end
     end
   end
 end