rubocop 0.19.1 → 0.20.0

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that exactly one space is used between a method name and the
+      # first argument for method calls without parentheses.
+      #
+      # @example
+      #
+      #   something  x
+      #   something   y, z
+      #
+      class SingleSpaceBeforeFirstArg < Cop
+        MSG = 'Put one space between the method name and the first argument.'
+
+        def on_send(node)
+          return if parentheses?(node)
+
+          _receiver, method_name, *args = *node
+          return if args.empty?
+          return if operator?(method_name)
+          return if method_name.to_s.end_with?('=')
+
+          arg1 = args.first.loc.expression
+          return if arg1.line > node.loc.line
+
+          arg1_with_space = range_with_surrounding_space(arg1, :left)
+          space = Parser::Source::Range.new(arg1.source_buffer,
+                                            arg1_with_space.begin_pos,
+                                            arg1.begin_pos)
+          add_offense(space, space) if space.length > 1
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.replace(range, ' ') }
+        end
+      end
+    end
+  end
+end

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

@@ -72,8 +72,7 @@ module Rubocop
             when /\*\*/
               corrector.replace(range, '**')
             else
-              corrector.insert_before(range, ' ') unless range.source =~ /^\s/
-              corrector.insert_after(range, ' ') unless range.source =~ /\s$/
+              corrector.replace(range, " #{range.source.strip} ")
             end
           end
         end

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

@@ -5,9 +5,9 @@ module Rubocop
     module Style
       # This cop looks for uses of Perl-style global variables.
       class SpecialGlobalVars < Cop
-        MSG_BOTH = 'Prefer %s from the English library, or %s over %s.'
-        MSG_ENGLISH = 'Prefer %s from the English library over %s.'
-        MSG_REGULAR = 'Prefer %s over %s.'
+        MSG_BOTH = 'Prefer `%s` from the English library, or `%s` over `%s`.'
+        MSG_ENGLISH = 'Prefer `%s` from the English library over `%s`.'
+        MSG_REGULAR = 'Prefer `%s` over `%s`.'
 
         PREFERRED_VARS = {
           '$:' => ['$LOAD_PATH'],
@@ -56,15 +56,15 @@ module Rubocop
           end
 
           # For now, we assume that lists are 2 items or less.  Easy grammar!
-          regular_msg = regular.join(' or ')
-          english_msg = english.join(' or ')
+          regular_msg = regular.join('` or `')
+          english_msg = english.join('` or `')
 
           if regular.length > 0 && english.length > 0
-            MSG_BOTH.format(english_msg, regular_msg, global_var)
+            format(MSG_BOTH, english_msg, regular_msg, global_var)
           elsif regular.length > 0
-            MSG_REGULAR.format(regular_msg, global_var)
+            format(MSG_REGULAR, regular_msg, global_var)
           elsif english.length > 0
-            MSG_ENGLISH.format(english_msg, global_var)
+            format(MSG_ENGLISH, english_msg, global_var)
           else
             fail 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end

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

@@ -70,7 +70,7 @@ module Rubocop
 
         # Returns true if the node has round/square/curly brackets.
         def brackets?(node)
-          !node.loc.end.nil?
+          node.loc.end
         end
 
         # Returns true if the round/square/curly brackets of the given node are

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

@@ -8,7 +8,7 @@ module Rubocop
       class TrivialAccessors < Cop
         include CheckMethods
 
-        MSG = 'Use attr_%s to define trivial %s methods.'
+        MSG = 'Use `attr_%s` to define trivial %s methods.'
 
         private
 

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop looks for *unless* expressions with *else* clauses.
       class UnlessElse < Cop
-        MSG = 'Never use unless with else. Rewrite these with the ' \
+        MSG = 'Never use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'
 
         def on_if(node)

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

@@ -5,20 +5,25 @@ module Rubocop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
       class VariableInterpolation < Cop
-        MSG = 'Replace interpolated var %s with expression #{%s}.'
+        MSG = 'Replace interpolated variable `%s` with expression `#{%s}`.'
 
         def on_dstr(node)
           var_nodes(node.children).each do |v|
-            var = (v.type == :nth_ref ? '$' : '') + v.to_a[0].to_s
+            var = v.loc.expression.source
 
-            if node.loc.expression.source.include?("##{var}")
-              add_offense(v, :expression, format(MSG, var, var))
-            end
+            add_offense(v, :expression, format(MSG, var, var))
           end
         end
 
         private
 
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            corrector.replace(expr, "{#{expr.source}}")
+          end
+        end
+
         def var_nodes(nodes)
           nodes.select { |n| [:ivar, :cvar, :gvar, :nth_ref].include?(n.type) }
         end

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for *when;* uses in *case* expressions.
       class WhenThen < Cop
-        MSG = 'Never use "when x;". Use "when x then" instead.'
+        MSG = 'Never use `when x;`. Use `when x then` instead.'
 
         def on_when(node)
           if node.loc.begin && node.loc.begin.is?(';')

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

@@ -25,7 +25,7 @@ module Rubocop
         private
 
         def message(keyword)
-          "Favor modifier #{keyword} usage when you have a single-line body."
+          "Favor modifier `#{keyword}` usage when having a single-line body."
         end
       end
     end

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

@@ -12,7 +12,7 @@ module Rubocop
         # parameter (the maximum number of something that's allowed).
         include ConfigurableMax
 
-        MSG = 'Use %w or %W for array of words.'
+        MSG = 'Use `%w` or `%W` for array of words.'
 
         def on_array(node)
           array_elems = node.children

data/lib/rubocop/cop/team.rb

@@ -23,15 +23,7 @@ module Rubocop
         @options[:debug]
       end
 
-      def inspect_file(file)
-        begin
-          processed_source = SourceParser.parse_file(file)
-        rescue Encoding::UndefinedConversionError, ArgumentError => e
-          range = Struct.new(:line, :column, :source_line).new(1, 0, '')
-          return [Offense.new(:fatal, range, e.message.capitalize + '.',
-                              'Parser')]
-        end
-
+      def inspect_file(processed_source)
         # If we got any syntax errors, return only the syntax offenses.
         # Parser may return nil for AST even though there are no syntax errors.
         # e.g. sources which contain only comments
@@ -42,22 +34,29 @@ module Rubocop
 
         commissioner = Commissioner.new(cops)
         offenses = commissioner.investigate(processed_source)
-        process_commissioner_errors(file, commissioner.errors)
+        process_commissioner_errors(
+          processed_source.file_path, commissioner.errors)
         autocorrect(processed_source.buffer, cops)
         offenses
       end
 
       def cops
         @cops ||= begin
-          @cop_classes.reduce([]) do |instances, cop_class|
-            next instances unless @config.cop_enabled?(cop_class)
-            instances << cop_class.new(@config, @options)
+          @cop_classes.each_with_object([]) do |cop_class, instances|
+            if cop_enabled?(cop_class)
+              instances << cop_class.new(@config, @options)
+            end
           end
         end
       end
 
       private
 
+      def cop_enabled?(cop_class)
+        @config.cop_enabled?(cop_class) ||
+          cop_class.cop_name == @options[:only]
+      end
+
       def autocorrect(buffer, cops)
         @updated_source_file = false
         return unless autocorrect?

data/lib/rubocop/cop/util.rb

@@ -106,6 +106,10 @@ module Rubocop
         lambda?(node) || proc?(node)
       end
 
+      def parentheses?(node)
+        node.loc.respond_to?(:end) && node.loc.end
+      end
+
       def on_node(syms, sexp, excludes = [])
         yield sexp if Array(syms).include?(sexp.type)
 

data/lib/rubocop/cop/variable_inspector/locatable.rb

@@ -24,7 +24,7 @@ module Rubocop
         end
 
         def inside_of_branch?
-          !branch_point_node.nil?
+          branch_point_node
         end
 
         def branch_id

data/lib/rubocop/cop/variable_inspector/variable_table.rb

@@ -105,7 +105,7 @@ module Rubocop
         end
 
         def variable_exist?(name)
-          !find_variable(name).nil?
+          find_variable(name)
         end
 
         def accessible_variables

data/lib/rubocop/file_inspector.rb

@@ -22,11 +22,14 @@ module Rubocop
         break if yield
         offenses = process_file(file, config_store)
 
-        any_failed = true unless offenses.empty?
+        any_failed = true if offenses.any? do |o|
+          o.severity >= fail_level
+        end
         inspected_files << file
       end
 
       formatter_set.finished(inspected_files.freeze)
+
       formatter_set.close_output_files
       any_failed
     end
@@ -46,28 +49,56 @@ module Rubocop
 
     def process_file(file, config_store)
       puts "Scanning #{file}" if @options[:debug]
-      offenses = []
-      formatter_set.file_started(file, {})
+      processed_source, offenses = process_source(file)
+
+      if offenses.any?
+        formatter_set.file_started(file, offenses)
+        formatter_set.file_finished(file, offenses.compact.sort.freeze)
+        return offenses
+      end
+
+      formatter_set.file_started(
+        file, cop_disabled_line_ranges: processed_source.disabled_line_ranges)
 
       # When running with --auto-correct, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
       loop do
-        new_offenses, updated_source_file = inspect_file(file, config_store)
-        unique_new = new_offenses.reject { |n| offenses.include?(n) }
-        offenses += unique_new
+        new_offenses, updated_source_file =
+          inspect_file(processed_source, config_store)
+        offenses += new_offenses.reject { |n| offenses.include?(n) }
         break unless updated_source_file
+
+        # We have to reprocess the source to pickup the changes. Since the
+        # change could (theoretically) introduce parsing errors, we break the
+        # loop if we find any.
+        processed_source, parse_offenses = process_source(file)
+        offenses += parse_offenses if parse_offenses.any?
       end
 
-      formatter_set.file_finished(file, offenses.sort.freeze)
+      formatter_set.file_finished(file, offenses.compact.sort.freeze)
       offenses
     end
 
-    def inspect_file(file, config_store)
-      config = config_store.for(file)
+    def process_source(file)
+      begin
+        processed_source = SourceParser.parse_file(file)
+      rescue Encoding::UndefinedConversionError, ArgumentError => e
+        range = Struct.new(:line, :column, :source_line).new(1, 0, '')
+        return [
+          nil,
+          [Cop::Offense.new(:fatal, range, e.message.capitalize + '.',
+                            'Parser')]]
+      end
+
+      [processed_source, []]
+    end
+
+    def inspect_file(processed_source, config_store)
+      config = config_store.for(processed_source.file_path)
       team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
-      offenses = team.inspect_file(file)
+      offenses = team.inspect_file(processed_source)
       @errors.concat(team.errors)
       [offenses, team.updated_source_file?]
     end
@@ -109,5 +140,10 @@ module Rubocop
         exit(1)
       end
     end
+
+    def fail_level
+      @fail_level ||= Rubocop::Cop::Severity.new(
+        @options[:fail_level] || :refactor)
+    end
   end
 end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -38,7 +38,7 @@ module Rubocop
           cfg.each { |key, value| output.puts "  #{key}: #{value}" }
         end
         puts "Created #{output.path}."
-        puts "Run rubocop with --config #{output.path}, or"
+        puts "Run `rubocop --config #{output.path}`, or"
         puts "add inherit_from: #{output.path} in a .rubocop.yml file."
       end
 

data/lib/rubocop/formatter/disabled_lines_formatter.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Rubocop
+  module Formatter
+    # A basic formatter that displays the lines disabled
+    # inline comments.
+    class DisabledLinesFormatter < BaseFormatter
+      include PathUtil
+      include Colorizable
+
+      attr_reader :cop_disabled_line_ranges
+
+      def started(target_files)
+        @cop_disabled_line_ranges = {}
+      end
+
+      def file_started(file, options)
+        return unless options[:cop_disabled_line_ranges]
+
+        @cop_disabled_line_ranges[file] =
+          options[:cop_disabled_line_ranges]
+      end
+
+      def finished(inspected_files)
+        cops_disabled_in_comments_summary
+      end
+
+      private
+
+      def cops_disabled_in_comments_summary
+        summary = "\nCops disabled line ranges:\n\n"
+
+        @cop_disabled_line_ranges.each do |file, disabled_cops|
+          disabled_cops.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              file = cyan(smart_path(file))
+              summary << "#{file}:#{line_range}: #{cop}\n"
+            end
+          end
+        end
+
+        output.puts summary
+      end
+
+      def smart_path(path)
+        # Ideally, we calculate this relative to the project root.
+        base_dir = Dir.pwd
+
+        if path.start_with? base_dir
+          relative_path(path, base_dir)
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -12,7 +12,7 @@ module Rubocop
           message << o.message
 
           output.printf("%s:%d:%d: %s: %s\n",
-                        file, o.line, o.real_column, o.severity_code,
+                        file, o.line, o.real_column, o.severity.code,
                         message)
         end
       end

data/lib/rubocop/formatter/formatter_set.rb

@@ -14,7 +14,8 @@ module Rubocop
         'emacs'    => EmacsStyleFormatter,
         'json'     => JSONFormatter,
         'files'    => FileListFormatter,
-        'offenses' => OffenseCountFormatter
+        'offenses' => OffenseCountFormatter,
+        'disabled' => DisabledLinesFormatter
       }
 
       FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]

data/lib/rubocop/formatter/fuubar_style_formatter.rb

@@ -49,9 +49,7 @@ module Rubocop
         return if offenses.empty?
 
         offenses << @severest_offense if @severest_offense
-        @severest_offense = offenses.max do |a, b|
-          a.severity_level <=> b.severity_level
-        end
+        @severest_offense = offenses.max_by { |offense| offense.severity }
       end
 
       def with_color
@@ -66,7 +64,7 @@ module Rubocop
 
       def progressbar_color
         if @severest_offense
-          COLOR_FOR_SEVERITY[@severest_offense.severity]
+          COLOR_FOR_SEVERITY[@severest_offense.severity.name]
         else
           :green
         end