rubocop 0.18.1 → 0.19.0

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

@@ -45,7 +45,7 @@ module Rubocop
         def on_gvar(node)
           global_var, = *node
 
-          add_offence(node, :expression) if PREFERRED_VARS[global_var]
+          add_offense(node, :expression) if PREFERRED_VARS[global_var]
         end
 
         def message(node)

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

@@ -20,7 +20,7 @@ module Rubocop
           end
         end
 
-        def offence?(node)
+        def offense?(node)
           src = node.loc.expression.source
           return false if src =~ /^(%[qQ]?|\?|<<-)/i
           src !~ if style == :single_quotes

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

@@ -15,7 +15,7 @@ module Rubocop
         def on_array(node)
           # %i and %I were introduced in Ruby 2.0
           unless RUBY_VERSION < '2.0.0'
-            add_offence(node, :expression) if array_of?(:sym, node)
+            add_offense(node, :expression) if array_of?(:sym, node)
           end
         end
       end

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

@@ -12,7 +12,7 @@ module Rubocop
             match = line.match(/^( *)\t/)
             if match
               spaces = match.captures[0]
-              add_offence(nil,
+              add_offense(nil,
                           source_range(processed_source.buffer,
                                        processed_source[0...index],
                                        spaces.length, 1),

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

@@ -24,7 +24,7 @@ module Rubocop
             range = source_range(processed_source.buffer,
                                  processed_source[0...-blank_lines],
                                  0, range_size)
-            add_offence(range, range, format(MSG, blank_lines))
+            add_offense(range, range, format(MSG, blank_lines))
           end
         end
 
@@ -33,7 +33,7 @@ module Rubocop
           # auto-correction in the two cops would result in clobbering.
           if range.source =~ / / &&
               config.for_cop('TrailingWhitespace')['Enabled']
-            fail CorrectionNotPossible
+            return
           end
 
           @corrections << ->(corrector) { corrector.remove(range) }

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

@@ -83,8 +83,8 @@ module Rubocop
           range = Parser::Source::Range.new(sb, comma_begin_pos,
                                             comma_begin_pos + 1)
           article = kind =~ /array/ ? 'an' : 'a'
-          add_offence(nil, range,
-                      sprintf(MSG, 'Avoid', sprintf(kind, article)))
+          add_offense(nil, range,
+                      format(MSG, 'Avoid', format(kind, article)))
         end
 
         def put_comma(items, kind, sb)
@@ -93,8 +93,8 @@ module Rubocop
           ix += last_expr.source[ix..-1] =~ /\S/
           range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
                                             last_expr.end_pos)
-          add_offence(nil, range,
-                      sprintf(MSG, 'Put a', sprintf(kind, 'a multiline')))
+          add_offense(nil, range,
+                      format(MSG, 'Put a', format(kind, 'a multiline')))
         end
       end
     end

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

@@ -14,7 +14,7 @@ module Rubocop
                                    processed_source[0...index],
                                    line.rstrip.length,
                                    line.length - line.rstrip.length)
-              add_offence(range, range)
+              add_offense(range, range)
             end
           end
         end

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

@@ -19,8 +19,8 @@ module Rubocop
                    'writer'
                  end
           if kind
-            add_offence(node, :keyword,
-                        sprintf(MSG, kind, kind))
+            add_offense(node, :keyword,
+                        format(MSG, kind, kind))
           end
         end
 

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

@@ -15,7 +15,7 @@ module Rubocop
           return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
 
           if loc.keyword.is?('unless') && loc.else
-            add_offence(node, :expression)
+            add_offense(node, :expression)
           end
         end
       end

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

@@ -12,7 +12,7 @@ module Rubocop
             var = (v.type == :nth_ref ? '$' : '') + v.to_a[0].to_s
 
             if node.loc.expression.source.include?("##{var}")
-              add_offence(v, :expression, sprintf(MSG, var, var))
+              add_offense(v, :expression, format(MSG, var, var))
             end
           end
         end

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

@@ -9,7 +9,7 @@ module Rubocop
 
         def on_when(node)
           if node.loc.begin && node.loc.begin.is?(';')
-            add_offence(node, :begin)
+            add_offense(node, :begin)
           end
         end
 

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

@@ -18,7 +18,7 @@ module Rubocop
 
           if length > 1
             if node.loc.begin && node.loc.begin.is?('do')
-              add_offence(node, :begin,
+              add_offense(node, :begin,
                           error_message(node.type))
             end
           end

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

@@ -5,6 +5,7 @@ module Rubocop
     module Style
       # Checks for while and until statements that would fit on one line
       # if written as a modifier while/until.
+      # The maximum line length is configurable.
       class WhileUntilModifier < Cop
         include StatementModifier
 
@@ -15,7 +16,7 @@ module Rubocop
             next unless node.loc.end
 
             if check(node, processed_source.comments)
-              add_offence(node, :keyword,
+              add_offense(node, :keyword,
                           message(node.loc.keyword.source))
             end
           end

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

@@ -8,7 +8,7 @@ module Rubocop
       class WordArray < Cop
         include ArraySyntax
         # The parameter is called MinSize (meaning the minimum array size for
-        # which an offence can be registered), but essentially it's a Max
+        # which an offense can be registered), but essentially it's a Max
         # parameter (the maximum number of something that's allowed).
         include ConfigurableMax
 
@@ -18,7 +18,7 @@ module Rubocop
           array_elems = node.children
           if array_of?(:str, node) && !complex_content?(array_elems) &&
             array_elems.size > min_size && !comments_in_array?(node)
-            add_offence(node, :expression) { self.max = array_elems.size }
+            add_offense(node, :expression) { self.max = array_elems.size }
           end
         end
 

data/lib/rubocop/cop/team.rb

@@ -4,7 +4,9 @@ module Rubocop
   module Cop
     # FIXME
     class Team
-      attr_reader :errors
+      attr_reader :errors, :updated_source_file
+
+      alias_method :updated_source_file?, :updated_source_file
 
       def initialize(cop_classes, config, options = nil)
         @cop_classes = cop_classes
@@ -26,23 +28,23 @@ module Rubocop
           processed_source = SourceParser.parse_file(file)
         rescue Encoding::UndefinedConversionError, ArgumentError => e
           range = Struct.new(:line, :column, :source_line).new(1, 0, '')
-          return [Offence.new(:fatal, range, e.message.capitalize + '.',
+          return [Offense.new(:fatal, range, e.message.capitalize + '.',
                               'Parser')]
         end
 
-        # If we got any syntax errors, return only the syntax offences.
+        # 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
         unless processed_source.valid_syntax?
           diagnostics = processed_source.diagnostics
-          return Lint::Syntax.offences_from_diagnostics(diagnostics)
+          return Lint::Syntax.offenses_from_diagnostics(diagnostics)
         end
 
         commissioner = Commissioner.new(cops)
-        offences = commissioner.investigate(processed_source)
+        offenses = commissioner.investigate(processed_source)
         process_commissioner_errors(file, commissioner.errors)
         autocorrect(processed_source.buffer, cops)
-        offences.sort
+        offenses
       end
 
       def cops
@@ -57,6 +59,7 @@ module Rubocop
       private
 
       def autocorrect(buffer, cops)
+        @updated_source_file = false
         return unless autocorrect?
 
         corrections = cops.reduce([]) do |array, cop|
@@ -65,14 +68,28 @@ module Rubocop
         end
 
         corrector = Corrector.new(buffer, corrections)
-        new_source = corrector.rewrite
+        new_source = begin
+                       corrector.rewrite
+                     rescue RangeError, RuntimeError
+                       autocorrect_one_cop(buffer, cops)
+                     end
 
         unless new_source == buffer.source
           filename = buffer.name
           File.open(filename, 'w') { |f| f.write(new_source) }
+          @updated_source_file = true
         end
       end
 
+      # Does a slower but safer auto-correction run by correcting for just one
+      # cop. The re-running of auto-corrections will make sure that the full
+      # set of auto-corrections is tried again after this method has finished.
+      def autocorrect_one_cop(buffer, cops)
+        cop_with_corrections = cops.find { |cop| cop.corrections.any? }
+        corrector = Corrector.new(buffer, cop_with_corrections.corrections)
+        corrector.rewrite
+      end
+
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
           errors.each do |e|

data/lib/rubocop/cop/util.rb

@@ -15,9 +15,9 @@ module Rubocop
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
       OPERATOR_METHODS = %w(
-          | ^ & <=> == === =~ > >= < <= << >>
-          + - * / % ** ~ +@ -@ [] []= ! != !~
-        ).map(&:to_sym) + [:'`']
+        | ^ & <=> == === =~ > >= < <= << >>
+        + - * / % ** ~ +@ -@ [] []= ! != !~
+      ).map(&:to_sym) + [:'`']
 
       module_function
 

data/lib/rubocop/cop/variable_inspector.rb

@@ -278,19 +278,8 @@ module Rubocop
       # as referenced by ignoring AST order since they would be referenced
       # in next iteration.
       def mark_assignments_as_referenced_in_loop(node)
-        referenced_variable_names_in_loop = []
-        assignment_nodes_in_loop = []
-
-        # #scan does not consider scope,
-        # but we don't need to care about it here.
-        scan(node) do |scanning_node|
-          case scanning_node.type
-          when :lvar
-            referenced_variable_names_in_loop << scanning_node.children.first
-          when :lvasgn
-            assignment_nodes_in_loop << scanning_node
-          end
-        end
+        referenced_variable_names_in_loop, assignment_nodes_in_loop =
+          find_variables_in_loop(node)
 
         referenced_variable_names_in_loop.each do |name|
           variable = variable_table.find_variable(name)
@@ -306,6 +295,29 @@ module Rubocop
         end
       end
 
+      def find_variables_in_loop(loop_node)
+        referenced_variable_names_in_loop = []
+        assignment_nodes_in_loop = []
+
+        # #scan does not consider scope,
+        # but we don't need to care about it here.
+        scan(loop_node) do |node|
+          case node.type
+          when :lvar
+            referenced_variable_names_in_loop << node.children.first
+          when *OPERATOR_ASSIGNMENT_TYPES
+            asgn_node = node.children.first
+            if asgn_node.type == :lvasgn
+              referenced_variable_names_in_loop << asgn_node.children.first
+            end
+          when :lvasgn
+            assignment_nodes_in_loop << node
+          end
+        end
+
+        [referenced_variable_names_in_loop, assignment_nodes_in_loop]
+      end
+
       # Simple recursive scan
       def scan(node, &block)
         node.children.each do |child|

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

@@ -16,7 +16,7 @@ module Rubocop
         def initialize(node, variable)
           unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
             fail ArgumentError,
-                 "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " +
+                 "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " \
                  "passed #{node.type}"
           end
 

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

@@ -18,7 +18,7 @@ module Rubocop
         def initialize(node, scope)
           unless VARIABLE_REFERENCE_TYPES.include?(node.type)
             fail ArgumentError,
-                 "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " +
+                 "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " \
                  "passed #{node.type}"
           end
 

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

@@ -13,7 +13,7 @@ module Rubocop
           # Accept begin node for top level scope.
           unless SCOPE_TYPES.include?(node.type) || node.type == :begin
             fail ArgumentError,
-                 "Node type must be any of #{SCOPE_TYPES}, " +
+                 "Node type must be any of #{SCOPE_TYPES}, " \
                  "passed #{node.type}"
           end
           @node = node

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

@@ -17,7 +17,7 @@ module Rubocop
         def initialize(name, declaration_node, scope)
           unless VARIABLE_DECLARATION_TYPES.include?(declaration_node.type)
             fail ArgumentError,
-                 "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " +
+                 "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " \
                  "passed #{declaration_node.type}"
           end
 
@@ -69,7 +69,7 @@ module Rubocop
         # Once the variable is captured by a block, we have no idea
         # when, where and how many times the block would be invoked
         # and it means we cannot track the usage of the variable.
-        # So we consider it's used to suppress false positive offences.
+        # So we consider it's used to suppress false positive offenses.
         def used?
           @captured_by_block || referenced?
         end

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

@@ -57,7 +57,7 @@ module Rubocop
           variable = find_variable(name)
 
           unless variable
-            fail "Assigning to undeclared local variable \"#{name}\" " +
+            fail "Assigning to undeclared local variable \"#{name}\" " \
                  "at #{node.loc.expression}, #{node.inspect}"
           end
 

data/lib/rubocop/file_inspector.rb

@@ -20,9 +20,9 @@ module Rubocop
 
       target_files.each do |file|
         break if yield
-        offences = process_file(file, config_store)
+        offenses = process_file(file, config_store)
 
-        any_failed = true unless offences.empty?
+        any_failed = true unless offenses.empty?
         inspected_files << file
       end
 
@@ -46,31 +46,30 @@ module Rubocop
 
     def process_file(file, config_store)
       puts "Scanning #{file}" if @options[:debug]
-      offences = []
+      offenses = []
       formatter_set.file_started(file, {})
 
       # 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
-      # offences. In the normal case the loop is only executed once.
+      # offenses. In the normal case the loop is only executed once.
       loop do
-        new_offences = inspect_file(file, config_store)
-        unique_new = new_offences.reject { |n| offences.include?(n) }
-
-        offences += unique_new
-        break unless unique_new.any?(&:corrected?)
+        new_offenses, updated_source_file = inspect_file(file, config_store)
+        unique_new = new_offenses.reject { |n| offenses.include?(n) }
+        offenses += unique_new
+        break unless updated_source_file
       end
 
-      formatter_set.file_finished(file, offences.freeze)
-      offences
+      formatter_set.file_finished(file, offenses.sort.freeze)
+      offenses
     end
 
     def inspect_file(file, config_store)
       config = config_store.for(file)
       team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
-      offences = team.inspect_file(file)
+      offenses = team.inspect_file(file)
       @errors.concat(team.errors)
-      offences
+      [offenses, team.updated_source_file?]
     end
 
     def mobilized_cop_classes(config)

data/lib/rubocop/formatter/base_formatter.rb

@@ -93,13 +93,13 @@ module Rubocop
       # @param file [String]
       #   the file path
       #
-      # @param offences [Array(Rubocop::Cop::Offence)]
-      #   all detected offences for the file
+      # @param offenses [Array(Rubocop::Cop::Offense)]
+      #   all detected offenses for the file
       #
       # @return [void]
       #
-      # @see Rubocop::Cop::Offence
-      def file_finished(file, offences)
+      # @see Rubocop::Cop::Offense
+      def file_finished(file, offenses)
       end
 
       # @api public