rubocop 0.31.0 → 0.35.0

data/lib/rubocop/options.rb

@@ -3,86 +3,30 @@
 require 'optparse'
 
 module RuboCop
-  # This module contains help texts for command line options.
-  module OptionsHelp
-    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.'],
-      force_exclusion:     ['Force excluding files specified in the',
-                            'configuration `Exclude` even if they are',
-                            'explicitly passed as arguments.'],
-      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',
-                            '  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.'],
-      debug:                'Display debug info.',
-      display_cop_names:    'Display cop names in offense messages.',
-      display_style_guide:  'Display style guide URLs in offense messages.',
-      rails:                'Run extra Rails cops.',
-      lint:                 'Run only lint cops.',
-      auto_correct:         'Auto-correct offenses.',
-      no_color:             'Disable color output.',
-      version:              'Display version.',
-      verbose_version:      'Display verbose version.'
-    }
-  end
-
   # This class handles command line options.
   class Options
     DEFAULT_FORMATTER = 'progress'
     EXITING_OPTIONS = [:version, :verbose_version, :show_cops]
+    DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
       @options = {}
+      @validator = OptionsValidator.new(@options)
     end
 
     def parse(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)
 
-      validate_compatibility
-
-      [@options, args]
-    end
-
-    # Cop name validation must be done later than option parsing, so it's not
-    # called from within this class.
-    def self.validate_cop_list(names)
-      return unless names
+      @validator.validate_compatibility
 
-      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
-      names.each do |name|
-        next if Cop::Cop.all.any? { |c| c.cop_name == name } ||
-                namespaces.include?(name)
-        fail ArgumentError, "Unrecognized cop or namespace: #{name}."
+      if @options[:stdin] && !args.one?
+        fail ArgumentError, '-s/--stdin requires exactly one path.'
       end
+
+      [@options, args]
     end
 
     private
@@ -91,6 +35,7 @@ module RuboCop
       OptionParser.new do |opts|
         opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
 
+        add_list_options(opts)
         add_only_options(opts)
         add_configuration_options(opts, args)
         add_formatting_options(opts)
@@ -103,11 +48,6 @@ module RuboCop
       end
     end
 
-    def validate_compatibility
-      return unless (incompat = @options.keys & EXITING_OPTIONS).size > 1
-      fail ArgumentError, "Incompatible cli options: #{incompat.inspect}"
-    end
-
     def add_only_options(opts)
       add_cop_selection_csv_option('except', opts)
       add_cop_selection_csv_option('only', opts)
@@ -116,9 +56,14 @@ module RuboCop
 
     def add_cop_selection_csv_option(option, opts)
       option(opts, "--#{option} [COP1,COP2,...]") do |list|
-        @options[:"#{option}"] = list.split(',').map do |c|
-          Cop::Cop.qualified_cop_name(c, "--#{option} option")
-        end
+        @options[:"#{option}"] =
+          if list.empty?
+            ['']
+          else
+            list.split(',').map do |c|
+              Cop::Cop.qualified_cop_name(c, "--#{option} option")
+            end
+          end
       end
     end
 
@@ -126,12 +71,15 @@ module RuboCop
       option(opts, '-c', '--config FILE')
 
       option(opts, '--auto-gen-config') do
-        validate_auto_gen_config_option(args)
         @options[:formatters] = [[DEFAULT_FORMATTER],
                                  [Formatter::DisabledConfigFormatter,
                                   ConfigLoader::AUTO_GENERATED_FILE]]
       end
 
+      option(opts, '--exclude-limit COUNT') do
+        @validator.validate_exclude_limit_option(args)
+      end
+
       option(opts, '--force-exclusion')
     end
 
@@ -164,11 +112,16 @@ module RuboCop
 
     def add_boolean_flags(opts)
       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')
+      option(opts, '-l', '--lint') do
+        @options[:only] ||= []
+        @options[:only] << 'Lint'
+      end
       option(opts, '-a', '--auto-correct')
 
       @options[:color] = true
@@ -176,6 +129,11 @@ module RuboCop
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
+      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.read }
+    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
@@ -193,14 +151,123 @@ module RuboCop
     # 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(/ .*/, '').gsub(/-/, '_').to_sym
+      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').to_sym
+    end
+  end
+
+  # Validates option arguments and the options' compatibilty with each other.
+  class OptionsValidator
+    def initialize(options)
+      @options = options
     end
 
-    def validate_auto_gen_config_option(args)
-      return unless args.any?
+    # 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
+
+      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
+      names.each do |name|
+        next if Cop::Cop.all.any? { |c| c.cop_name == name }
+        next if namespaces.include?(name)
+        next if %w(Syntax Lint/Syntax).include?(name)
 
-      warn '--auto-gen-config can not be combined with any other arguments.'
-      exit(1)
+        fail ArgumentError, "Unrecognized cop or namespace: #{name}."
+      end
     end
+
+    def validate_compatibility
+      if @options.key?(:only) &&
+         (@options[:only] & %w(Lint/UnneededDisable UnneededDisable)).any?
+        fail ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
+      end
+      if @options.key?(:except) &&
+         (@options[:except] & %w(Lint/Syntax Syntax)).any?
+        fail ArgumentError, 'Syntax checking can not be turned off.'
+      end
+      if @options.key?(:cache) && !%w(true false).include?(@options[:cache])
+        fail ArgumentError, '-C/--cache argument must be true or false'
+      end
+      return if (incompat = @options.keys & Options::EXITING_OPTIONS).size <= 1
+      fail ArgumentError, "Incompatible cli options: #{incompat.inspect}"
+    end
+
+    def validate_exclude_limit_option(args)
+      if @options[:exclude_limit] !~ /^\d+$/
+        # Emulate OptionParser's behavior to make failures consistent regardless
+        # of option order.
+        fail 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')
+
+      fail 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 = RuboCop::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.'],
+      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.'],
+      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',
+                            '  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 RuboCop will inspect.',
+      auto_correct:         'Auto-correct offenses.',
+      no_color:             'Disable color output.',
+      version:              'Display version.',
+      verbose_version:      'Display verbose version.',
+      stdin:                ['Pipe source from STDIN.',
+                             'This is useful for editor integration.']
+    }
   end
 end

data/lib/rubocop/processed_source.rb

@@ -13,7 +13,12 @@ module RuboCop
                 :parser_error, :raw_source
 
     def self.from_file(path)
-      new(File.read(path), path)
+      file = File.read(path)
+      new(file, path)
+    rescue Errno::ENOENT
+      abort("#{Rainbow('rubocop: No such file or directory').red} -- #{path}")
+    rescue => ex
+      abort("#{Rainbow("rubocop: #{ex.message}").red} -- #{path}")
     end
 
     def initialize(source, path = nil)
@@ -41,7 +46,7 @@ module RuboCop
     def lines
       @lines ||= begin
         all_lines = raw_source.lines.map(&:chomp)
-        last_token_line = tokens.any? ? tokens.last.pos.line : all_lines.count
+        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__'

data/lib/rubocop/rake_task.rb

@@ -48,7 +48,7 @@ module RuboCop
       cli = CLI.new
       puts 'Running RuboCop...' if verbose
       result = cli.run(options)
-      abort('RuboCop failed!') if fail_on_error unless result == 0
+      abort('RuboCop failed!') if result != 0 && fail_on_error
     end
 
     def full_options

data/lib/rubocop/remote_config.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'net/http'
+
+module RuboCop
+  # Common methods and behaviors for dealing with remote config files.
+  class RemoteConfig
+    CACHE_LIFETIME = 24 * 60 * 60
+
+    def initialize(url)
+      @uri = URI.parse(url)
+    end
+
+    def file
+      return cache_path unless cache_path_expired?
+
+      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
+      response = http.request(request)
+
+      cache_path.tap do |f|
+        if response.is_a?(Net::HTTPSuccess)
+          open f, 'w' do |io|
+            io.write response.body
+          end
+        end
+      end
+    end
+
+    private
+
+    def cache_path
+      ".rubocop-#{cache_name_from_uri}"
+    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/rubocop/result_cache.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'digest/md5'
+require 'find'
+require 'tmpdir'
+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
+
+    # 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
+    # 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.
+    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) }
+      if files.length > config_store.for('.')['AllCops']['MaxFilesInCache'] &&
+         files.length > 1
+        # 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) }
+        begin
+          sorted[0, remove_count].each { |path| File.delete(path) }
+          dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
+        rescue Errno::ENOENT
+          # This can happen if parallel RuboCop invocations try to remove the
+          # same files. No problem.
+          puts $ERROR_INFO if verbose
+        end
+      end
+    end
+
+    private
+
+    def self.cache_root(config_store)
+      root = config_store.for('.')['AllCops']['CacheRootDirectory']
+      root = File.join(Dir.tmpdir, Etc.getlogin) if root == '/tmp'
+      File.join(root, 'rubocop_cache')
+    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 rubocop program running the inspection.
+    def rubocop_checksum
+      ResultCache.source_checksum ||=
+        begin
+          lib_root = File.join(File.dirname(__FILE__), '..')
+          bin_root = File.join(lib_root, '..', 'bin')
+          source = Find.find(lib_root, bin_root).sort.map do |path|
+            IO.read(path) if File.file?(path)
+          end
+          Digest::MD5.hexdigest(source.join)
+        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.
+    def relevant_options(options)
+      options = options.reject { |key, _| NON_CHANGING.include?(key) }
+      options.to_s.gsub(/[^a-z]+/i, '_')
+    end
+  end
+end