rubocop 0.13.1 → 0.14.0

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

@@ -43,7 +43,7 @@ module Rubocop
           MSG.format(PREFERRED_VARS[global_var], global_var)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             global_var, = *node
 

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

@@ -3,7 +3,10 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for uses of double quotes where single quotes would do.
+      # Classes that include this module just implement functions to determine
+      # what is an offence and how to do auto-correction. They get help with
+      # adding offences for the faulty string nodes, and with filtering out
+      # nodes.
       module StringHelp
         def on_str(node)
           # Constants like __FILE__ are handled as strings,

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

@@ -3,25 +3,48 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for uses of double quotes where single quotes would do.
+      # Checks if uses of quotes match the configured preference.
       class StringLiterals < Cop
         include StringHelp
 
-        MSG = "Prefer single-quoted strings when you don't need " +
-          'string interpolation or special symbols.'
+        private
+
+        def message(node)
+          if single_quotes_preferred?
+            "Prefer single-quoted strings when you don't need string " +
+              'interpolation or special symbols.'
+          else
+            'Prefer double-quoted strings unless you need single quotes to ' +
+              'avoid extra backslashes for escaping.'
+          end
+        end
 
         def offence?(node)
-          # regex matches IF there is a ' or there is a \\ in the string that
-          # is not preceeded/followed by another \\ (e.g. "\\x34") but not
-          # "\\\\"
-          node.loc.expression.source !~ /' | (?<! \\) \\{2}* \\ (?! \\)/x &&
-            node.loc.begin && node.loc.begin.is?('"')
+          src = node.loc.expression.source
+          return false if src =~ /^%q/i
+          src !~ if single_quotes_preferred?
+                   # regex matches IF there is a ' or there is a \\ in the
+                   # string that is not preceeded/followed by another \\
+                   # (e.g. "\\x34") but not "\\\\"
+                   /' | (?<! \\) \\{2}* \\ (?! \\)/x
+                 else
+                   /" | \\/x
+                 end
+        end
+
+        def single_quotes_preferred?
+          case cop_config['EnforcedStyle']
+          when 'single_quotes' then true
+          when 'double_quotes' then false
+          else fail 'Unknown StringLiterals style'
+          end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.begin, "'")
-            corrector.replace(node.loc.end, "'")
+            replacement = node.loc.begin.is?('"') ? "'" : '"'
+            corrector.replace(node.loc.begin, replacement)
+            corrector.replace(node.loc.end, replacement)
           end
         end
       end

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

@@ -174,14 +174,11 @@ module Rubocop
         end
       end
 
-      # Checks that block braces have surrounding space. For blocks taking
-      # parameters, it check that the left brace has or doesn't have trailing
-      # space depending on configuration.
+      # Checks that block braces have or don't have surrounding space depending
+      # on configuration. For blocks taking parameters, it checks that the left
+      # brace has or doesn't have trailing space depending on configuration.
       class SpaceAroundBlockBraces < Cop
         include SurroundingSpace
-        MSG_LEFT = "Surrounding space missing for '{'."
-        MSG_RIGHT = "Space missing to the left of '}'."
-        MSG_PIPE = 'Space between { and | detected.'
 
         def investigate(processed_source)
           return unless processed_source.ast
@@ -191,15 +188,15 @@ module Rubocop
             next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
 
             type1, type2 = t1.type, t2.type
-            check(t1, t2, MSG_LEFT) if type2 == :tLCURLY
-            if type1 == :tLCURLY
-              if type2 == :tPIPE && cop_config['NoSpaceBeforeBlockParameters']
-                check_pipe(t1, t2, MSG_PIPE)
+            if [:tLCURLY, :tRCURLY].include?(type2)
+              check(t1, t2)
+            elsif type1 == :tLCURLY
+              if type2 == :tPIPE
+                check_pipe(t1, t2)
               else
-                check(t1, t2, MSG_LEFT)
+                check(t1, t2)
               end
             end
-            check(t1, t2, MSG_RIGHT) if type2 == :tRCURLY
           end
         end
 
@@ -229,15 +226,65 @@ module Rubocop
           end
         end
 
-        def check(t1, t2, msg)
+        def check(t1, t2)
+          if cop_config['EnforcedStyle'] == 'space_inside_braces'
+            check_space_inside_braces(t1, t2)
+          else
+            check_no_space_inside_braces(t1, t2)
+          end
+          check_space_outside_left_brace(t1, t2)
+        end
+
+        def check_space_inside_braces(t1, t2)
           unless space_between?(t1, t2)
-            brace_token = t1.text == '{' ? t1 : t2
-            convention(nil, brace_token.pos, msg)
+            if t1.text == '{'
+              convention(nil, t1.pos, 'Space missing inside {.')
+            elsif t2.text == '}'
+              convention(nil, t2.pos, 'Space missing inside }.')
+            end
+          end
+        end
+
+        def check_no_space_inside_braces(t1, t2)
+          if t1.text == '{' || t2.text == '}'
+            if space_between?(t1, t2)
+              if t1.text == '{'
+                convention(nil, space_range(t1), 'Space inside { detected.')
+              elsif t2.text == '}'
+                convention(nil, space_range(t2), 'Space inside } detected.')
+              end
+            end
           end
         end
 
-        def check_pipe(t1, t2, msg)
-          convention(nil, t1.pos, msg) if space_between?(t1, t2)
+        def check_space_outside_left_brace(t1, t2)
+          if t2.text == '{' && !space_between?(t1, t2)
+            convention(nil, t2.pos, 'Space missing to the left of {.')
+          end
+        end
+
+        def check_pipe(t1, t2)
+          if cop_config['SpaceBeforeBlockParameters']
+            unless space_between?(t1, t2)
+              convention(nil, t1.pos, 'Space between { and | missing.')
+            end
+          elsif space_between?(t1, t2)
+            convention(nil, space_range(t1), 'Space between { and | detected.')
+          end
+        end
+
+        def space_range(token)
+          src = @processed_source.buffer.source
+          if token.text == '{'
+            b = token.pos.begin_pos + 1
+            e = b + 1
+            e += 1 while src[e] =~ /\s/
+          else
+            e = token.pos.begin_pos
+            b = e - 1
+            b -= 1 while src[b - 1] =~ /\s/
+          end
+          Parser::Source::Range.new(@processed_source.buffer, b, e)
         end
       end
 

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

@@ -15,7 +15,7 @@ module Rubocop
               convention(nil,
                          source_range(processed_source.buffer,
                                       processed_source[0...index],
-                                      spaces.length, 8),
+                                      spaces.length, 1),
                          MSG)
             end
           end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that all variables use the configured style,
+      # snake_case or camelCase, for their names.
+      class VariableName < Cop
+        include ConfigurableNaming
+
+        def on_lvasgn(node)
+          check(node, name_of_variable(node))
+        end
+
+        def on_ivasgn(node)
+          check(node, name_of_variable(node))
+        end
+
+        def on_send(node)
+          check(node, name_of_setter(node))
+        end
+
+        def name_of_variable(vasgn_node)
+          expr = vasgn_node.loc.expression
+          name = vasgn_node.children.first
+          Parser::Source::Range.new(expr.source_buffer, expr.begin_pos,
+                                    expr.begin_pos + name.length)
+        end
+
+        def name_of_setter(send_node)
+          receiver, method_name = *send_node
+          return unless receiver && receiver.type == :self
+          return unless method_name.to_s.end_with?('=')
+          after_dot(send_node, method_name.length - '='.length,
+                    Regexp.escape(receiver.loc.expression.source))
+        end
+
+        def message(style)
+          format('Use %s for variables.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Rubocop
           convention(node, :begin) if node.loc.begin && node.loc.begin.is?(';')
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.begin, ' then')
           end

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

@@ -30,7 +30,7 @@ module Rubocop
           format('Never use `do` with multi-line `%s`.', node_type)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             condition_node, = *node
             end_of_condition_range = condition_node.loc.expression.end

data/lib/rubocop/cop/team.rb

@@ -30,19 +30,16 @@ module Rubocop
           return []
         end
 
-        offences = processed_source.diagnostics.map do |diagnostic|
-          Offence.from_diagnostic(diagnostic)
-        end
-
         # If we got any syntax errors, return only the syntax offences.
         # Parser may return nil for AST even though there are no syntax errors.
         # e.g. sources which contain only comments
-        if offences.any? { |o| [:error, :fatal].include?(o.severity) }
-          return offences
+        unless processed_source.valid_syntax?
+          diagnostics = processed_source.diagnostics
+          return Lint::Syntax.offences_from_diagnostics(diagnostics)
         end
 
         commissioner = Commissioner.new(cops)
-        offences += commissioner.investigate(processed_source)
+        offences = commissioner.investigate(processed_source)
         process_commissioner_errors(file, commissioner.errors)
         autocorrect(processed_source.buffer, cops)
         offences.sort

data/lib/rubocop/cop/util.rb

@@ -23,6 +23,18 @@ module Rubocop
         block_node.loc.end.line - block_node.loc.begin.line
       end
 
+      def source_length(source, count_comments = nil)
+        lines = source.lines.to_a[1...-1]
+
+        return 0 unless lines
+
+        lines.reject!(&:blank?)
+
+        lines.reject! { |line| line =~ /^\s*#/ } unless count_comments
+
+        lines.size
+      end
+
       def const_name(node)
         return nil if node.nil? || node.type != :const
 

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -10,7 +10,7 @@ module Rubocop
         offences.each do |o|
           output.printf("%s:%d:%d: %s: %s\n",
                         smart_path(file).color(:cyan), o.line, o.real_column,
-                        o.clang_severity, o.message)
+                        colored_severity_code(o), message(o))
 
           source_line = o.location.source_line
 

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -7,9 +7,12 @@ module Rubocop
     class EmacsStyleFormatter < BaseFormatter
       def file_finished(file, offences)
         offences.each do |o|
+          message = o.corrected? ? '[Corrected] ' : ''
+          message << o.message
+
           output.printf("%s:%d:%d: %s: %s\n",
-                        file, o.line, o.real_column, o.encode_severity,
-                        o.message)
+                        file, o.line, o.real_column, o.severity_code,
+                        message)
         end
       end
     end

data/lib/rubocop/formatter/json_formatter.rb

@@ -54,6 +54,7 @@ module Rubocop
           severity: offence.severity,
           message:  offence.message,
           cop_name: offence.cop_name,
+          corrected: offence.corrected?,
           location: hash_for_location(offence)
         }
       end

data/lib/rubocop/formatter/progress_formatter.rb

@@ -6,14 +6,6 @@ module Rubocop
     # letters for files with problems in the them. In the end it
     # appends the regular report data in the clang style format.
     class ProgressFormatter < ClangStyleFormatter
-      COLOR_FOR_SEVERITY = {
-        refactor:   :yellow,
-        convention: :yellow,
-        warning:    :magenta,
-        error:      :red,
-        fatal:      :red
-      }
-
       def started(target_files)
         super
         @offences_for_files = {}
@@ -22,8 +14,11 @@ module Rubocop
       end
 
       def file_finished(file, offences)
-        @total_offence_count += offences.count
-        @offences_for_files[file] = offences unless offences.empty?
+        unless offences.empty?
+          count_stats(offences)
+          @offences_for_files[file] = offences
+        end
+
         report_file_as_mark(file, offences)
       end
 
@@ -40,7 +35,9 @@ module Rubocop
           end
         end
 
-        report_summary(inspected_files.count, @total_offence_count)
+        report_summary(inspected_files.count,
+                       @total_offence_count,
+                       @total_correction_count)
       end
 
       def report_file_as_mark(file, offences)
@@ -50,8 +47,7 @@ module Rubocop
                  highest_offence = offences.max do |a, b|
                    a.severity_level <=> b.severity_level
                  end
-                 color = COLOR_FOR_SEVERITY[highest_offence.severity]
-                 highest_offence.encode_severity.color(color)
+                 colored_severity_code(highest_offence)
                end
 
         output.write mark

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -6,44 +6,67 @@ module Rubocop
     # Offences are displayed at compact form - just the
     # location of the problem and the associated message.
     class SimpleTextFormatter < BaseFormatter
+      COLOR_FOR_SEVERITY = {
+        refactor:   :yellow,
+        convention: :yellow,
+        warning:    :magenta,
+        error:      :red,
+        fatal:      :red
+      }.freeze
+
       def started(target_files)
         @total_offence_count = 0
+        @total_correction_count = 0
       end
 
       def file_finished(file, offences)
         return if offences.empty?
-        @total_offence_count += offences.count
+        count_stats(offences)
         report_file(file, offences)
       end
 
       def finished(inspected_files)
-        report_summary(inspected_files.count, @total_offence_count)
+        report_summary(inspected_files.count,
+                       @total_offence_count,
+                       @total_correction_count)
       end
 
       def report_file(file, offences)
         output.puts "== #{smart_path(file)} ==".color(:yellow)
-        output.puts offences.join("\n")
+
+        offences.each do |o|
+          output.printf("%s:%3d:%3d: %s\n",
+                        colored_severity_code(o),
+                        o.line, o.real_column, message(o))
+        end
       end
 
-      def report_summary(file_count, offence_count)
-        summary = ''
+      def report_summary(file_count, offence_count, correction_count)
+        summary = pluralize(file_count, 'file')
+        summary << ' inspected, '
 
-        plural = file_count == 0 || file_count > 1 ? 's' : ''
-        summary << "#{file_count} file#{plural} inspected, "
+        offences_text = pluralize(offence_count, 'offence', no_for_zero: true)
+        offences_text << ' detected'
+        summary << offences_text.color(offence_count.zero? ? :green : :red)
 
-        offences_string = case offence_count
-                          when 0 then 'no offences'
-                          when 1 then '1 offence'
-                          else "#{offence_count} offences"
-                          end
-        summary << "#{offences_string} detected"
-          .color(offence_count.zero? ? :green : :red)
+        if correction_count > 0
+          summary << ', '
+          correction_text = pluralize(correction_count, 'offence')
+          correction_text << ' corrected'
+          color = correction_count == offence_count ? :green : :cyan
+          summary << correction_text.color(color)
+        end
 
         output.puts
         output.puts summary
       end
 
-      protected
+      private
+
+      def count_stats(offences)
+        @total_offence_count += offences.count
+        @total_correction_count += offences.select(&:corrected?).count
+      end
 
       def smart_path(path)
         if path.start_with?(Dir.pwd)
@@ -52,6 +75,31 @@ module Rubocop
           path
         end
       end
+
+      def colored_severity_code(offence)
+        color = COLOR_FOR_SEVERITY[offence.severity]
+        offence.severity_code.color(color)
+      end
+
+      def message(offence)
+        message = offence.corrected? ? '[Corrected] '.color(:green) : ''
+        message << offence.message
+      end
+
+      def pluralize(number, thing, options = {})
+        text = ''
+
+        if number == 0 && options[:no_for_zero]
+          text = 'no'
+        else
+          text << number.to_s
+        end
+
+        text << " #{thing}"
+        text << 's' unless number == 1
+
+        text
+      end
     end
   end
 end