rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cli.rb

@@ -1,159 +1,314 @@
 # encoding: utf-8
-
+require 'pathname'
 require 'optparse'
-require 'yaml'
-require_relative 'cop/grammar'
 
 module Rubocop
   # The CLI is a class responsible of handling all the command line interface
   # logic.
   class CLI
+    # If set true while running,
+    # RuboCop will abort processing and exit gracefully.
+    attr_accessor :wants_to_quit
+    attr_accessor :options
+
+    alias_method :wants_to_quit?, :wants_to_quit
+
+    def initialize
+      @cops = Cop::Cop.all
+      @processed_file_count = 0
+      @total_offences = 0
+      @errors = []
+      @options = { mode: :default }
+      ConfigStore.prepare
+    end
+
     # Entry point for the application logic. Here we
     # do the command line arguments processing and inspect
     # the target files
     # @return [Fixnum] UNIX exit code
     def run(args = ARGV)
-      $options = { mode: :default }
+      trap_interrupt
+
+      parse_options(args)
+
+      begin
+        validate_only_option if @options[:only]
+      rescue ArgumentError => e
+        puts e.message
+        return 1
+      end
+
+      target_files(args).each do |file|
+        break if wants_to_quit?
+
+        config = ConfigStore.for(file)
+        report = Report.create(file, @options[:mode])
+
+        puts "Scanning #{file}" if @options[:debug]
+
+        syntax_cop = Rubocop::Cop::Syntax.new
+        syntax_cop.debug = @options[:debug]
+        syntax_cop.inspect_file(file)
+
+        if syntax_cop.offences.map(&:severity).include?(:error)
+          # In case of a syntax error we just report that error and do
+          # no more checking in the file.
+          report << syntax_cop
+          @total_offences += syntax_cop.offences.count
+        else
+          inspect_file(file, config, report)
+        end
+
+        @processed_file_count += 1
+        report.display unless report.empty?
+      end
+
+      unless @options[:silent]
+        display_summary(@processed_file_count, @total_offences, @errors)
+      end
+
+      (@total_offences == 0) && !wants_to_quit ? 0 : 1
+    end
+
+    def validate_only_option
+      if @cops.none? { |c| c.cop_name == @options[:only] }
+        fail ArgumentError, "Unrecognized cop name: #{@options[:only]}."
+      end
+    end
+
+    def inspect_file(file, config, report)
+      begin
+        ast, comments, tokens, source = CLI.parse(file) do |source_buffer|
+          source_buffer.read
+        end
+      rescue Parser::SyntaxError, Encoding::UndefinedConversionError,
+        ArgumentError => e
+        handle_error(e, "An error occurred while parsing #{file}.".color(:red))
+        return
+      end
+
+      disabled_lines = disabled_lines_in(source)
 
+      @cops.each do |cop_class|
+        cop_name = cop_class.cop_name
+        if config.cop_enabled?(cop_name)
+          cop = setup_cop(cop_class,
+                          config.for_cop(cop_name),
+                          disabled_lines)
+          if !@options[:only] || @options[:only] == cop_name
+            begin
+              cop.inspect(source, tokens, ast, comments)
+            rescue => e
+              handle_error(e,
+                           "An error occurred while #{cop.name}".color(:red) +
+                           " cop was inspecting #{file}.".color(:red))
+            end
+          end
+          @total_offences += cop.offences.count
+          report << cop if cop.has_report?
+        end
+      end
+    end
+
+    def setup_cop(cop_class, cop_config, disabled_lines)
+      cop_class.config = cop_config
+      cop = cop_class.new
+      cop.debug = @options[:debug]
+      cop.disabled_lines = disabled_lines[cop_class.cop_name]
+      cop
+    end
+
+    def handle_error(e, message)
+      @errors << message
+      warn message
+      if @options[:debug]
+        puts e.message, e.backtrace
+      else
+        warn 'To see the complete backtrace run rubocop -d.'
+      end
+    end
+
+    def parse_options(args)
       OptionParser.new do |opts|
         opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
 
-        opts.on('-d', '--[no-]debug', 'Display debug info') do |d|
-          $options[:debug] = d
+        opts.on('-d', '--debug', 'Display debug info') do |d|
+          @options[:debug] = d
         end
         opts.on('-e', '--emacs', 'Emacs style output') do
-          $options[:mode] = :emacs_style
+          @options[:mode] = :emacs_style
         end
         opts.on('-c FILE', '--config FILE', 'Configuration file') do |f|
-          $options[:config] = YAML.load_file(f)
+          @options[:config] = f
+          ConfigStore.set_options_config(@options[:config])
+        end
+        opts.on('--only COP', 'Run just one cop') do |s|
+          @options[:only] = s
         end
         opts.on('-s', '--silent', 'Silence summary') do |s|
-          $options[:silent] = s
+          @options[:silent] = s
+        end
+        opts.on('-n', '--no-color', 'Disable color output') do |s|
+          Sickill::Rainbow.enabled = false
         end
         opts.on('-v', '--version', 'Display version') do
-          puts Rubocop::VERSION
+          puts Rubocop::Version::STRING
           exit(0)
         end
       end.parse!(args)
+    end
 
-      total_offences = 0
-      @configs = {}
-
-      target_files = target_files(args)
-      config = $options[:config] || config_from_dotfile(target_files[0])
+    def trap_interrupt
+      Signal.trap('INT') do
+        exit!(1) if wants_to_quit?
+        self.wants_to_quit = true
+        $stderr.puts
+        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
+      end
+    end
 
-      cops = cops_on_duty(config)
-      show_cops_on_duty(cops) if $options[:debug]
+    def display_summary(num_files, total_offences, errors)
+      plural = num_files == 0 || num_files > 1 ? 's' : ''
+      print "\n#{num_files} file#{plural} inspected, "
+      offences_string = if total_offences.zero?
+                          'no offences'
+                        elsif total_offences == 1
+                          '1 offence'
+                        else
+                          "#{total_offences} offences"
+                        end
+      puts "#{offences_string} detected"
+        .color(total_offences.zero? ? :green : :red)
 
-      target_files(args).each do |file|
-        report = Report.create(file, $options[:mode])
-        source = File.readlines(file).map do |line|
-          get_rid_of_invalid_byte_sequences(line)
-          line.chomp
-        end
+      if errors.count > 0
+        plural = errors.count > 1 ? 's' : ''
+        puts "\n#{errors.count} error#{plural} occurred:".color(:red)
+        errors.each { |error| puts error }
+        puts 'Errors are usually caused by RuboCop bugs.'
+        puts 'Please, report your problems to RuboCop\'s issue tracker.'
+      end
+    end
 
-        tokens, sexp, correlations = CLI.rip_source(source)
+    def disabled_lines_in(source)
+      disabled_lines = Hash.new([])
+      disabled_section = {}
+      regexp = '# rubocop : (%s)\b ((?:\w+,? )+)'.gsub(' ', '\s*')
+      section_regexp = '^\s*' + sprintf(regexp, '(?:dis|en)able')
+      single_line_regexp = '\S.*' + sprintf(regexp, 'disable')
 
-        cops.each do |cop_klass|
-          cop_config = config[cop_klass.name.split('::').last] if config
-          cop_klass.config = cop_config
-          cop = cop_klass.new
-          cop.correlations = correlations
-          cop.inspect(file, source, tokens, sexp)
-          total_offences += cop.offences.count
-          report << cop if cop.has_report?
+      source.each_with_index do |line, ix|
+        each_mentioned_cop(/#{section_regexp}/, line) do |cop_name, kind|
+          disabled_section[cop_name] = (kind == 'disable')
+        end
+        disabled_section.keys.each do |cop_name|
+          disabled_lines[cop_name] += [ix + 1] if disabled_section[cop_name]
         end
 
-        report.display unless report.empty?
+        each_mentioned_cop(/#{single_line_regexp}/, line) do |cop_name, kind|
+          disabled_lines[cop_name] += [ix + 1] if kind == 'disable'
+        end
       end
+      disabled_lines
+    end
 
-      unless $options[:silent]
-        print "\n#{target_files(args).count} files inspected, "
-        puts "#{total_offences} offences detected"
-          .send(total_offences.zero? ? :green : :red)
+    def each_mentioned_cop(regexp, line)
+      match = line.match(regexp)
+      if match
+        kind, cops = match.captures
+        cops = Cop::Cop.all.map(&:cop_name).join(',') if cops.include?('all')
+        cops.split(/,\s*/).each { |cop_name| yield cop_name, kind }
       end
-
-      return total_offences == 0 ? 0 : 1
     end
 
-    def get_rid_of_invalid_byte_sequences(line)
-      enc = line.encoding.name
-      # UTF-16 works better in this algorithm but is not supported in 1.9.2.
-      temporary_encoding = (RUBY_VERSION == '1.9.2') ? 'UTF-8' : 'UTF-16'
-      line.encode!(temporary_encoding, enc, invalid: :replace, replace: '')
-      line.encode!(enc, temporary_encoding)
-    end
+    def self.parse(file)
+      parser = Parser::CurrentRuby.new
 
-    def self.rip_source(source)
-      tokens = Ripper.lex(source.join("\n")).map { |t| Cop::Token.new(*t) }
-      sexp = Ripper.sexp(source.join("\n"))
-      Cop::Position.make_position_objects(sexp)
-      correlations = Cop::Grammar.new(tokens).correlate(sexp)
-      [tokens, sexp, correlations]
-    end
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.diagnostics.ignore_warnings      = true
 
-    # Returns the configuration hash from .rubocop.yml searching
-    # upwards in the directory structure starting at the given
-    # directory where the inspected file is. If no .rubocop.yml is
-    # found there, the user's home directory is checked.
-    def config_from_dotfile(target_file_dir)
-      return unless target_file_dir
-      # @configs is a cache that maps directories to
-      # configurations. We search for .rubocop.yml only if we haven't
-      # already found it for the given directory.
-      unless @configs[target_file_dir]
-        dir = target_file_dir
-        while dir != '/'
-          path = File.join(dir, '.rubocop.yml')
-          if File.exist?(path)
-            @configs[target_file_dir] = YAML.load_file(path)
-            break
-          end
-          dir = File.expand_path('..', dir)
-        end
-        path = File.join(Dir.home, '.rubocop.yml')
-        @configs[target_file_dir] = YAML.load_file(path) if File.exist?(path)
+      parser.diagnostics.consumer = lambda do |diagnostic|
+        $stderr.puts(diagnostic.render)
       end
-      @configs[target_file_dir]
-    end
 
-    def cops_on_duty(config)
-      cops_on_duty = []
+      source_buffer = Parser::Source::Buffer.new(file, 1)
+      yield source_buffer
 
-      Cop::Cop.all.each do |cop_klass|
-        cop_config = config[cop_klass.name.split('::').last] if config
-        cops_on_duty << cop_klass if cop_config.nil? || cop_config['Enabled']
-      end
+      ast, comments, tokens = parser.tokenize(source_buffer)
 
-      cops_on_duty
-    end
+      tokens = tokens.map do |t|
+        type, details = *t
+        text, range = *details
+        Rubocop::Cop::Token.new(range, type, text)
+      end
 
-    def show_cops_on_duty(cops)
-      puts '== Reporting for duty =='
-      cops.each { |c| puts ' * '.yellow + c.to_s.green }
-      puts '========================'
+      [ast, comments, tokens, source_buffer.source.split($RS)]
     end
 
     # Generate a list of target files by expanding globing patterns
     # (if any). If args is empty recursively finds all Ruby source
-    # files in the current directory
+    # files under the current directory
     # @return [Array] array of filenames
     def target_files(args)
-      return Dir['**/*.rb'] if args.empty?
+      return ruby_files if args.empty?
 
       files = []
 
       args.each do |target|
         if File.directory?(target)
-          files << Dir["#{target}/**/*.rb"]
+          files += ruby_files(target.chomp(File::SEPARATOR))
         elsif target =~ /\*/
-          files << Dir[target]
+          files += Dir[target]
         else
           files << target
         end
       end
 
-      files.flatten
+      files.uniq
+    end
+
+    # Finds all Ruby source files under the current or other supplied
+    # directory.  A Ruby source file is defined as a file with the `.rb`
+    # extension or a file with no extension that has a ruby shebang line
+    # as its first line.
+    # It is possible to specify includes and excludes using the config file,
+    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # @param root Root directory under which to search for ruby source files
+    # @return [Array] Array of filenames
+    def ruby_files(root = Dir.pwd)
+      files = Dir["#{root}/**/*"].reject { |file| FileTest.directory? file }
+
+      rb = []
+
+      rb += files.select { |file| File.extname(file) == '.rb' }
+      rb += files.select do |file|
+        if File.extname(file) == ''
+          begin
+            File.open(file) { |f| f.readline } =~ /#!.*ruby/
+          rescue EOFError, ArgumentError => e
+            log_error(e, "Unprocessable file #{file.inspect}: ")
+            false
+          end
+        end
+      end
+
+      rb += files.select do |file|
+        config = ConfigStore.for(file)
+        config.file_to_include?(file)
+      end
+
+      rb.reject do |file|
+        config = ConfigStore.for(file)
+        config.file_to_exclude?(file)
+      end.uniq
+    end
+
+    private
+
+    def log_error(e, msg = '')
+      if @options[:debug]
+        error_message = "#{e.class}, #{e.message}"
+        STDERR.puts "#{msg}\t#{error_message}"
+      end
     end
   end
 end

data/lib/rubocop/config.rb

@@ -0,0 +1,205 @@
+# encoding: utf-8
+
+require 'delegate'
+require 'yaml'
+require 'pathname'
+
+module Rubocop
+  class Config < DelegateClass(Hash)
+    class ValidationError < StandardError; end
+
+    DOTFILE = '.rubocop.yml'
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+
+    attr_reader :loaded_path
+
+    class << self
+      def load_file(path)
+        hash = YAML.load_file(path)
+
+        base_configs(path, hash['inherit_from']).reverse.each do |base_config|
+          base_config.each do |key, value|
+            if value.is_a?(Hash)
+              hash[key] = hash.has_key?(key) ? merge(value, hash[key]) : value
+            end
+          end
+        end
+
+        hash.delete('inherit_from')
+        config = new(hash, File.realpath(path))
+        config.warn_unless_valid
+        config
+      end
+
+      # Return a recursive merge of two hashes. That is, a normal hash
+      # merge, with the addition that any value that is a hash, and
+      # occurs in both arguments, will also be merged. And so on.
+      def merge(base_hash, derived_hash)
+        result = {}
+        base_hash.each do |key, value|
+          result[key] = if derived_hash.has_key?(key)
+                          if value.is_a?(Hash)
+                            merge(value, derived_hash[key])
+                          else
+                            derived_hash[key]
+                          end
+                        else
+                          base_hash[key]
+                        end
+        end
+        derived_hash.each do |key, value|
+          result[key] = value unless base_hash.has_key?(key)
+        end
+        result
+      end
+
+      def base_configs(path, inherit_from)
+        base_files = case inherit_from
+                     when nil then []
+                     when String then [inherit_from]
+                     when Array then inherit_from
+                     end
+        base_files.map do |f|
+          f = File.join(File.dirname(path), f) unless f.start_with?('/')
+          load_file(f)
+        end
+      end
+
+      # Returns the path of .rubocop.yml searching upwards in the
+      # directory structure starting at the given directory where the
+      # inspected file is. If no .rubocop.yml is found there, the
+      # user's home directory is checked. If there's no .rubocop.yml
+      # there either, the path to the default file is returned.
+      def configuration_file_for(target_dir)
+        possible_config_files = dirs_to_search(target_dir).map do |dir|
+          File.join(dir, DOTFILE)
+        end
+
+        found_file = possible_config_files.find do |config_file|
+          File.exist?(config_file)
+        end
+        found_file || DEFAULT_FILE
+      end
+
+      def configuration_from_file(config_file)
+        config = load_file(config_file)
+        merge_with_default(config, config_file)
+      end
+
+      def default_configuration
+        @default_configuration ||= load_file(DEFAULT_FILE)
+      end
+
+      def merge_with_default(config, config_file)
+        new(merge(default_configuration, config), config_file)
+      end
+
+      private
+
+      def dirs_to_search(target_dir)
+        dirs_to_search = []
+        target_dir_pathname = Pathname.new(File.expand_path(target_dir))
+        target_dir_pathname.ascend do |dir_pathname|
+          dirs_to_search << dir_pathname.to_s
+        end
+        dirs_to_search << Dir.home
+        dirs_to_search
+      end
+    end
+
+    def initialize(hash = {}, loaded_path = nil)
+      @hash = hash
+      @loaded_path = loaded_path
+      super(@hash)
+    end
+
+    def for_cop(cop)
+      self[cop]
+    end
+
+    def cop_enabled?(cop)
+      self[cop].nil? || self[cop]['Enabled']
+    end
+
+    def warn_unless_valid
+      validate
+    rescue Config::ValidationError => e
+      puts "Warning: #{e.message}".color(:red)
+    end
+
+    # TODO: This should be a private method
+    def validate
+      # Don't validate RuboCop's own files. Avoids inifinite recursion.
+      return if @loaded_path.start_with?(RUBOCOP_HOME)
+
+      default_config = self.class.default_configuration
+
+      valid_cop_names, invalid_cop_names = @hash.keys.partition do |key|
+        default_config.has_key?(key)
+      end
+
+      invalid_cop_names.each do |name|
+        fail ValidationError,
+             "unrecognized cop #{name} found in #{loaded_path || self}"
+      end
+
+      valid_cop_names.each do |name|
+        @hash[name].each_key do |param|
+          unless default_config[name].has_key?(param)
+            fail ValidationError,
+                 "unrecognized parameter #{name}:#{param} found " +
+                 "in #{loaded_path || self}"
+          end
+        end
+      end
+    end
+
+    def file_to_include?(file)
+      relative_file_path = relative_path_to_loaded_dir(file)
+      patterns_to_include.any? do |pattern|
+        match_path?(pattern, relative_file_path)
+      end
+    end
+
+    def file_to_exclude?(file)
+      relative_file_path = relative_path_to_loaded_dir(file)
+      patterns_to_exclude.any? do |pattern|
+        match_path?(pattern, relative_file_path)
+      end
+    end
+
+    def patterns_to_include
+      @hash['AllCops']['Includes']
+    end
+
+    def patterns_to_exclude
+      @hash['AllCops']['Excludes']
+    end
+
+    private
+
+    def relative_path_to_loaded_dir(file)
+      return file unless loaded_path
+      file_pathname = Pathname.new(File.expand_path(file))
+      file_pathname.relative_path_from(loaded_dir_pathname).to_s
+    end
+
+    def loaded_dir_pathname
+      return nil unless loaded_path
+      @loaded_dir ||= begin
+        loaded_dir = File.expand_path(File.dirname(loaded_path))
+        Pathname.new(loaded_dir)
+      end
+    end
+
+    def match_path?(pattern, path)
+      case pattern
+      when String
+        File.basename(path) == pattern || File.fnmatch(pattern, path)
+      when Regexp
+        path =~ pattern
+      end
+    end
+  end
+end

data/lib/rubocop/config_store.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module ConfigStore
+    module_function
+
+    def prepare
+      # @options_config stores a config that is specified in the command line.
+      # This takes precedence over configs located in any directories
+      @options_config = nil
+
+      # @path_cache maps directories to configuration paths. We search
+      # for .rubocop.yml only if we haven't already found it for the
+      # given directory.
+      @path_cache = {}
+
+      # @object_cache maps configuration file paths to
+      # configuration objects so we only need to load them once.
+      @object_cache = {}
+    end
+
+    def set_options_config(options_config)
+      loaded_config = Config.load_file(options_config)
+      @options_config = Config.merge_with_default(loaded_config,
+                                                  options_config)
+    end
+
+    def for(file)
+      return @options_config if @options_config
+
+      dir = File.dirname(file)
+      @path_cache[dir] ||= Config.configuration_file_for(dir)
+      path = @path_cache[dir]
+      @object_cache[path] ||= Config.configuration_from_file(path)
+    end
+  end
+end

data/lib/rubocop/cop/access_control.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AccessControl < Cop
+      INDENT_MSG = 'Indent private and protected as deep as method defs.'
+      BLANK_MSG = 'Keep a blank line before and after private/protected.'
+
+      PRIVATE_NODE = s(:send, nil, :private)
+      PROTECTED_NODE = s(:send, nil, :protected)
+
+      def inspect(source, tokens, ast, comments)
+        on_node([:class, :module, :sclass], ast) do |class_node|
+          class_start_col = class_node.loc.expression.column
+
+          # we'll have to walk all class children nodes
+          # except other class/module nodes
+          class_node.children.compact.each do |node|
+            on_node(:send, node, [:class, :module, :sclass]) do |send_node|
+              if [PRIVATE_NODE, PROTECTED_NODE].include?(send_node)
+                send_start_col = send_node.loc.expression.column
+
+                if send_start_col - 2 != class_start_col
+                  add_offence(:convention,
+                              send_node.loc.line,
+                              INDENT_MSG)
+                end
+
+                send_line = send_node.loc.line
+
+                unless source[send_line].empty? && source[send_line - 2].empty?
+                  add_offence(:convention, send_line, BLANK_MSG)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end