rubocop 0.9.1 → 0.10.0

data/lib/rubocop/cop/style/tab.rb

@@ -7,13 +7,14 @@ module Rubocop
       class Tab < Cop
         MSG = 'Tab detected.'
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          source.each_with_index do |line, index|
+        def investigate(processed_source)
+          processed_source.lines.each_with_index do |line, index|
             match = line.match(/^( *)\t/)
             if match
               spaces = match.captures[0]
               add_offence(:convention,
-                          source_range(source_buffer, source[0...index],
+                          source_range(processed_source.buffer,
+                                       processed_source[0...index],
                                        spaces.length, 8),
                           MSG)
             end

data/lib/rubocop/cop/style/ternary_operator.rb

@@ -17,8 +17,6 @@ module Rubocop
           if loc.line != loc.colon.line
             add_offence(:convention, loc.expression, MSG)
           end
-
-          super
         end
       end
 
@@ -40,8 +38,6 @@ module Rubocop
               end
             end
           end
-
-          super
         end
       end
     end

data/lib/rubocop/cop/style/trailing_whitespace.rb

@@ -7,11 +7,12 @@ module Rubocop
       class TrailingWhitespace < Cop
         MSG = 'Trailing whitespace detected.'
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          source.each_with_index do |line, index|
+        def investigate(processed_source)
+          processed_source.lines.each_with_index do |line, index|
             if line =~ /.*[ \t]+$/
               add_offence(:convention,
-                          source_range(source_buffer, source[0...index],
+                          source_range(processed_source.buffer,
+                                       processed_source[0...index],
                                        line.rstrip.length,
                                        line.length - line.rstrip.length),
                           MSG)

data/lib/rubocop/cop/style/trivial_accessors.rb

@@ -11,12 +11,21 @@ module Rubocop
         def on_def(node)
           method_name, args, body = *node
 
-          kind = if body && body.type == :ivar
+          check(node, method_name, args, body)
+        end
+
+        def on_defs(node)
+          _scope, method_name, args, body = *node
+
+          check(node, method_name, args, body)
+        end
+
+        private
+
+        def check(node, method_name, args, body)
+          kind = if trivial_reader?(method_name, args, body)
                    'reader'
-                 elsif args.children.size == 1 &&
-                       body && body.type == :ivasgn &&
-                       body.children[1] && body.children[1].type == :lvar &&
-                       method_name != :initialize
+                 elsif trivial_writer?(method_name, args, body)
                    'writer'
                  end
           if kind
@@ -24,7 +33,43 @@ module Rubocop
                         sprintf(MSG, kind, kind))
           end
 
-          super
+        end
+
+        def exact_name_match?
+          TrivialAccessors.config['ExactNameMatch']
+        end
+
+        def allow_predicates?
+          TrivialAccessors.config['AllowPredicates']
+        end
+
+        def predicate?(method_name)
+          method_name[-1] == '?'
+        end
+
+        def trivial_reader?(method_name, args, body)
+          return false unless args.children.size == 0
+
+          return false unless body && body.type == :ivar
+
+          return false if allow_predicates? && predicate?(method_name)
+
+          exact_name_match? ? names_match?(method_name, body) : true
+        end
+
+        def trivial_writer?(method_name, args, body)
+          return false unless args.children.size == 1 &&
+            body && body.type == :ivasgn &&
+            body.children[1] && body.children[1].type == :lvar &&
+            method_name != :initialize
+
+          exact_name_match? ? names_match?(method_name, body) : true
+        end
+
+        def names_match?(method_name, body)
+          ivar_name, = *body
+
+          method_name.to_s.chomp('=') == ivar_name[1..-1]
         end
       end
     end

data/lib/rubocop/cop/style/unless_else.rb

@@ -17,8 +17,6 @@ module Rubocop
           if loc.keyword.is?('unless') && loc.else
             add_offence(:convention, loc.expression, MSG)
           end
-
-          super
         end
       end
     end

data/lib/rubocop/cop/style/variable_interpolation.rb

@@ -17,8 +17,6 @@ module Rubocop
                           sprintf(MSG, var, var))
             end
           end
-
-          super
         end
 
         private

data/lib/rubocop/cop/style/when_then.rb

@@ -12,12 +12,12 @@ module Rubocop
             add_offence(:convention, node.loc.begin, MSG)
             do_autocorrect(node)
           end
-
-          super
         end
 
         def autocorrect_action(node)
-          replace(node.loc.begin, ' then')
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
         end
       end
     end

data/lib/rubocop/cop/style/while_until_do.rb

@@ -7,14 +7,10 @@ module Rubocop
       class WhileUntilDo < Cop
         def on_while(node)
           handle(node)
-
-          super
         end
 
         def on_until(node)
           handle(node)
-
-          super
         end
 
         def handle(node)
@@ -37,7 +33,9 @@ module Rubocop
         end
 
         def autocorrect_action(node)
-          remove(node.loc.begin)
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.begin)
+          end
         end
       end
     end

data/lib/rubocop/cop/style/word_array.rb

@@ -21,8 +21,6 @@ module Rubocop
           if string_array && !complex_content?(array_elems)
             add_offence(:convention, node.loc.expression, MSG)
           end
-
-          super
         end
 
         private

data/lib/rubocop/cop/util.rb

@@ -22,10 +22,6 @@ module Rubocop
       def block_length(block_node)
         block_node.loc.end.line - block_node.loc.begin.line
       end
-
-      def symbolize_keys(hash)
-        Hash[hash.map { |(k, v)| [k.to_sym, v] }] if hash
-      end
     end
   end
 end

data/lib/rubocop/formatter/file_list_formatter.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # This formatter displays just a list of the files with offences in them,
+    # separated by newlines.
+    #
+    # Here's the format:
+    #
+    # /some/file
+    # /some/other/file
+    class FileListFormatter < SimpleTextFormatter
+      def report_file(file, offences)
+        output.printf("%s\n", file)
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/formatter_set.rb

@@ -11,7 +11,8 @@ module Rubocop
         'simple'   => SimpleTextFormatter,
         'clang'    => ClangStyleFormatter,
         'emacs'    => EmacsStyleFormatter,
-        'json'     => JSONFormatter
+        'json'     => JSONFormatter,
+        'files'    => FileListFormatter
       }
 
       FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]

data/lib/rubocop/processed_source.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+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
+    attr_reader :buffer, :ast, :comments, :tokens, :diagnostics
+    attr_accessor :disabled_lines_for_cops
+
+    def initialize(buffer, ast, comments, tokens, diagnostics)
+      @buffer = buffer
+      @ast = ast
+      @comments = comments
+      @tokens = tokens
+      @diagnostics = diagnostics
+    end
+
+    def lines
+      @lines ||= @buffer.source.split($RS)
+    end
+
+    def [](*args)
+      lines[*args]
+    end
+  end
+end

data/lib/rubocop/rake_task.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubocop'
+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
+
+    def initialize(*args, &task_block)
+      setup_ivars(args)
+
+      desc 'Run RuboCop' unless ::Rake.application.last_comment
+
+      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
+          run_task(verbose)
+        end
+      end
+    end
+
+    def run_task(verbose)
+      cli = CLI.new
+      puts 'Running RuboCop...' if verbose
+      result = cli.run(patterns)
+      abort('RuboCop failed!') if fail_on_error unless result == 0
+    end
+
+    private
+
+    def setup_ivars(args)
+      @name = args.shift || :rubocop
+      @verbose = true
+      @fail_on_error = true
+      @patterns = []
+    end
+  end
+end

data/lib/rubocop/source_parser.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+module Rubocop
+  # SourceParser provides a way to parse Ruby source with Parser gem
+  # and also parses comment directives which disable arbitrary cops.
+  module SourceParser
+    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+      '^.*?(\S)?.*# rubocop : ((?:dis|en)able)\b ((?:\w+,? )+)'
+        .gsub(' ', '\s*')
+    )
+
+    module_function
+
+    def parse(string, name = '(string)')
+      processed_source = parse_with_parser(string, name)
+      processed_source.disabled_lines_for_cops =
+        cop_disabled_lines_in(processed_source.lines)
+      processed_source
+    end
+
+    def parse_file(path)
+      parse(File.read(path), path)
+    end
+
+    def parse_with_parser(string, name)
+      source_buffer = Parser::Source::Buffer.new(name, 1)
+      source_buffer.source = string
+
+      parser = create_parser
+      diagnostics = []
+      parser.diagnostics.consumer = lambda do |diagnostic|
+        diagnostics << diagnostic
+      end
+
+      begin
+        ast, comments, tokens = parser.tokenize(source_buffer)
+      rescue Parser::SyntaxError # rubocop:disable HandleExceptions
+        # All errors are in diagnostics. No need to handle exception.
+      end
+
+      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+
+      ProcessedSource.new(source_buffer, ast, comments, tokens, diagnostics)
+    end
+
+    def create_parser
+      parser = Parser::CurrentRuby.new
+
+      # 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 project
+      # on GitHub.
+      parser.diagnostics.all_errors_are_fatal = RUBY_ENGINE != 'ruby'
+      parser.diagnostics.ignore_warnings      = false
+
+      parser
+    end
+
+    def cop_disabled_lines_in(source_lines)
+      disabled_lines_for_cops = {}
+      current_disabled_cops = {}
+
+      source_lines.each_with_index do |line, index|
+        line_number = index + 1
+
+        each_mentioned_cop(line) do |cop_name, disabled, single_line|
+          if single_line
+            next unless disabled
+            disabled_lines_for_cops[cop_name] ||= []
+            disabled_lines_for_cops[cop_name] << line_number
+          else
+            current_disabled_cops[cop_name] = disabled
+          end
+        end
+
+        current_disabled_cops.each do |cop_name, disabled|
+          next unless disabled
+          disabled_lines_for_cops[cop_name] ||= []
+          disabled_lines_for_cops[cop_name] << line_number
+        end
+      end
+
+      disabled_lines_for_cops
+    end
+
+    def each_mentioned_cop(line)
+      match = line.match(COMMENT_DIRECTIVE_REGEXP)
+
+      return unless match
+
+      non_whitespace_before_comment, switch, cops_string = match.captures
+
+      if cops_string.include?('all')
+        cop_names = Cop::Cop.all.map(&:cop_name)
+      else
+        cop_names = cops_string.split(/,\s*/)
+      end
+
+      disabled = (switch == 'disable')
+      single_line = !non_whitespace_before_comment.nil?
+
+      cop_names.each { |cop_name| yield cop_name, disabled, single_line }
+    end
+  end
+end

data/lib/rubocop/target_finder.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Rubocop
+  # This class finds target files to inspect by scanning directory tree
+  # and picking ruby files.
+  class TargetFinder
+    def initialize(config_store, debug = false)
+      @config_store = config_store
+      @debug = debug
+    end
+
+    # Generate a list of target files by expanding globing patterns
+    # (if any). If args is empty recursively finds all Ruby source
+    # files under the current directory
+    # @return [Array] array of file paths
+    def find(args)
+      return target_files_in_dir if args.empty?
+
+      files = []
+
+      args.uniq.each do |arg|
+        if File.directory?(arg)
+          files += target_files_in_dir(arg.chomp(File::SEPARATOR))
+        elsif arg.include?('*')
+          files += Dir[arg]
+        else
+          files << arg
+        end
+      end
+
+      files.map { |f| File.expand_path(f) }.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 target_files_in_dir(base_dir = Dir.pwd)
+      files = Dir["#{base_dir}/**/*"].select { |path| FileTest.file?(path) }
+
+      target_files = files.select do |file|
+        config = @config_store.for(file)
+        next false if config.file_to_exclude?(file)
+        next true if File.extname(file) == '.rb'
+        next true if ruby_executable?(file)
+        config.file_to_include?(file)
+      end
+
+      target_files.uniq
+    end
+
+    def ruby_executable?(file)
+      return false unless File.extname(file).empty?
+      first_line = File.open(file) { |f| f.readline }
+      first_line =~ /#!.*ruby/
+    rescue EOFError, ArgumentError => e
+      if @debug
+        warn "Unprocessable file #{file}: #{e.class}, #{e.message}"
+      end
+      false
+    end
+  end
+end