rubocop 0.18.1 → 0.19.0

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -13,7 +13,7 @@ module Rubocop
 
         def check(node, *_)
           on_node(:postexe, node) do |end_node|
-            add_offence(end_node, :keyword)
+            add_offense(end_node, :keyword)
           end
         end
       end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -13,7 +13,7 @@ module Rubocop
           return unless ensure_body
 
           on_node(:return, ensure_body) do |e|
-            add_offence(e, :expression)
+            add_offense(e, :expression)
           end
         end
       end

data/lib/rubocop/cop/lint/eval.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_send(node)
           receiver, method_name, = *node
 
-          add_offence(node, :selector) if receiver.nil? && method_name == :eval
+          add_offense(node, :selector) if receiver.nil? && method_name == :eval
         end
       end
     end

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_resbody(node)
           _exc_list_node, _exc_var_node, body_node = *node
 
-          add_offence(node, :expression) unless body_node
+          add_offense(node, :expression) unless body_node
         end
       end
     end

data/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -43,6 +43,17 @@ module Rubocop
           check_for_literal(node)
         end
 
+        def on_case(node)
+          cond, *whens, _else = *node
+          if cond
+            handle_node(cond)
+          else
+            whens.each do |when_node|
+              check_for_literal(when_node)
+            end
+          end
+        end
+
         def message(node)
           MSG.format(node.loc.expression.source)
         end
@@ -54,7 +65,7 @@ module Rubocop
 
           # if the cond node is literal we obviously have a problem
           if literal?(cond)
-            add_offence(cond, :expression)
+            add_offense(cond, :expression)
           else
             # alternatively we have to consider a logical node with a
             # literal argument
@@ -94,7 +105,7 @@ module Rubocop
 
         def handle_node(node)
           if literal?(node)
-            add_offence(node, :expression)
+            add_offense(node, :expression)
           elsif [:send, :and, :or, :begin].include?(node.type)
             check_node(node)
           end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for interpolated literals.
+      #
+      # @example
+      #
+      #   "result is #{10}"
+      class LiteralInInterpolation < Cop
+        LITERALS = [:str, :dstr, :int, :float, :array,
+                    :hash, :regexp, :nil, :true, :false]
+
+        MSG = 'Literal interpolation detected.'
+
+        def on_dstr(node)
+          node.children.select { |n| n.type == :begin }.each do |begin_node|
+            final_node = begin_node.children.last
+            next unless LITERALS.include?(final_node.type)
+
+            add_offense(final_node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/loop.rb

@@ -9,17 +9,17 @@ module Rubocop
               'begin/end/until(or while).'
 
         def on_while_post(node)
-          register_offence(node)
+          register_offense(node)
         end
 
         def on_until_post(node)
-          register_offence(node)
+          register_offense(node)
         end
 
         private
 
-        def register_offence(node)
-          add_offence(node, :keyword)
+        def register_offense(node)
+          add_offense(node, :keyword)
         end
       end
     end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -24,7 +24,7 @@ module Rubocop
                 Parser::Source::Range.new(expr.source_buffer,
                                           expr.begin_pos - space_length,
                                           expr.begin_pos)
-              add_offence(nil, space_range)
+              add_offense(nil, space_range)
             end
           end
         end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -21,7 +21,7 @@ module Rubocop
         include IfNode
 
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
-          'precedence.'
+              'precedence.'
 
         def on_send(node)
           _receiver, method_name, *args = *node
@@ -42,17 +42,17 @@ module Rubocop
 
         def check_ternary(arg, node)
           condition, _, _ = *arg
-          if offence?(condition)
+          if offense?(condition)
             expr = node.loc.expression
             range = Parser::Source::Range.new(expr.source_buffer,
                                               expr.begin_pos,
                                               condition.loc.expression.end_pos)
-            add_offence(range, range)
+            add_offense(range, range)
           end
         end
 
         def check_send(arg, node)
-          add_offence(node, :expression) if offence?(arg)
+          add_offense(node, :expression) if offense?(arg)
         end
 
         def predicate?(method_name)
@@ -60,10 +60,10 @@ module Rubocop
         end
 
         def parentheses?(node)
-          node.loc.respond_to?(:end) && !!node.loc.end
+          node.loc.respond_to?(:end) && node.loc.end
         end
 
-        def offence?(node)
+        def offense?(node)
           [:and, :or].include?(node.type)
         end
       end

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -11,7 +11,7 @@ module Rubocop
           return unless node.children.first
           rescue_args = node.children.first.children
           if rescue_args.any? { |a| targets_exception?(a) }
-            add_offence(node, :expression)
+            add_offense(node, :expression)
           end
         end
 

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -22,8 +22,8 @@ module Rubocop
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
 
-          message = sprintf(MSG, variable.name)
-          add_offence(variable.declaration_node, :expression, message)
+          message = format(MSG, variable.name)
+          add_offense(variable.declaration_node, :expression, message)
         end
       end
     end

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for string conversion in string interpolation,
+      # which is redundant.
+      #
+      # @example
+      #
+      #   "result is #{something.to_s}"
+      class StringConversionInInterpolation < Cop
+        MSG = 'Redundant use of Object#to_s in interpolation.'
+
+        def on_dstr(node)
+          node.children.select { |n| n.type == :begin }.each do |begin_node|
+            final_node = begin_node.children.last
+            next unless final_node.type == :send
+
+            _receiver, method_name, *args = *final_node
+
+            if method_name == :to_s && args.empty?
+              add_offense(final_node, :selector)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/syntax.rb

@@ -4,18 +4,18 @@ module Rubocop
   module Cop
     module Lint
       # This is actually not a cop and inspects nothing. It just provides
-      # methods to repack Parser's diagnostics into RuboCop's offences.
+      # methods to repack Parser's diagnostics into RuboCop's offenses.
       module Syntax
         COP_NAME = 'Syntax'.freeze
 
-        def self.offences_from_diagnostics(diagnostics)
+        def self.offenses_from_diagnostics(diagnostics)
           diagnostics.map do |diagnostic|
-            offence_from_diagnostic(diagnostic)
+            offense_from_diagnostic(diagnostic)
           end
         end
 
-        def self.offence_from_diagnostic(diagnostic)
-          Offence.new(
+        def self.offense_from_diagnostic(diagnostic)
+          Offense.new(
             diagnostic.level,
             diagnostic.location,
             diagnostic.message,

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -17,7 +17,7 @@ module Rubocop
 
           expressions.each_cons(2) do |e1, e2|
             if NODE_TYPES.include?(e1.type) || flow_command?(e1)
-              add_offence(e2, :expression)
+              add_offense(e2, :expression)
             end
           end
         end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -42,17 +42,17 @@ module Rubocop
                          assignment.node.loc.name
                        end
 
-            add_offence(nil, location, message)
+            add_offense(nil, location, message)
           end
         end
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          message = sprintf(MSG, variable.name)
+          message = format(MSG, variable.name)
 
           if assignment.multiple_assignment?
-            message << ". Use _ or _#{variable.name} as a variable name " +
+            message << ". Use _ or _#{variable.name} as a variable name " \
                        "to indicate that it won't be used."
           elsif assignment.operator_assignment?
             return_value_node = return_value_node_of_scope(variable.scope)
@@ -79,8 +79,8 @@ module Rubocop
         def check_for_unused_block_local_variable(variable)
           return unless variable.block_local_variable?
           return unless variable.assignments.empty?
-          message = sprintf(MSG, variable.name)
-          add_offence(variable.declaration_node, :expression, message)
+          message = format(MSG, variable.name)
+          add_offense(variable.declaration_node, :expression, message)
         end
       end
     end

data/lib/rubocop/cop/lint/useless_comparison.rb

@@ -21,7 +21,7 @@ module Rubocop
           if OPS.include?(op)
             receiver, _method, args = *node
 
-            add_offence(node, :selector) if receiver == args
+            add_offense(node, :selector) if receiver == args
           end
         end
       end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -38,7 +38,7 @@ module Rubocop
           var_name, = *receiver
           return if tracker.contain_object_passed_as_argument?(var_name)
 
-          add_offence(receiver,
+          add_offense(receiver,
                       :name,
                       MSG.format(receiver.loc.name.source))
         end

data/lib/rubocop/cop/lint/void.rb

@@ -32,20 +32,20 @@ module Rubocop
 
           op = node.loc.selector.source
 
-          add_offence(node, :selector, sprintf(OP_MSG, op)) if OPS.include?(op)
+          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
         end
 
         def check_for_var(node)
           if VARS.include?(node.type)
-            add_offence(node, :name,
-                        sprintf(VAR_MSG, node.loc.name.source))
+            add_offense(node, :name,
+                        format(VAR_MSG, node.loc.name.source))
           end
         end
 
         def check_for_literal(node)
           if LITERALS.include?(node.type)
-            add_offence(node, :expression,
-                        sprintf(LIT_MSG, node.loc.expression.source))
+            add_offense(node, :expression,
+                        format(LIT_MSG, node.loc.expression.source))
           end
         end
       end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -6,11 +6,12 @@ module Rubocop
     # the left or to the right, amount being determined by the instance
     # variable @column_delta.
     module AutocorrectAlignment
-      def check_alignment(items)
+      def check_alignment(items, base_column = nil)
+        base_column ||= items.first.loc.column unless items.empty?
         items.each_cons(2) do |prev, current|
           if current.loc.line > prev.loc.line && start_of_line?(current.loc)
-            @column_delta = items.first.loc.column - current.loc.column
-            add_offence(current, :expression) if @column_delta != 0
+            @column_delta = base_column - current.loc.column
+            add_offense(current, :expression) if @column_delta != 0
           end
         end
       end
@@ -31,9 +32,11 @@ module Rubocop
           each_line(expr) do |line_begin_pos, line|
             range = calculate_range(expr, line_begin_pos, column_delta)
             if column_delta > 0
-              corrector.insert_before(range, ' ' * column_delta)
+              unless range.source == "\n"
+                corrector.insert_before(range, ' ' * column_delta)
+              end
             else
-              remove(range, corrector)
+              remove(range, corrector) if range.source =~ /^[ \t]+$/
             end
           end
         end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -17,8 +17,8 @@ module Rubocop
       def check(node, *_)
         length = code_length(node)
         if length > max_length
-          add_offence(node, :keyword, sprintf(message, length,
-                                              max_length)) do
+          add_offense(node, :keyword, format(message, length,
+                                             max_length)) do
             self.max = length
           end
         end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -5,26 +5,26 @@ module Rubocop
     # Handles `EnforcedStyle` configuration parameters.
     module ConfigurableEnforcedStyle
       def opposite_style_detected
-        self.config_to_allow_offences ||=
+        self.config_to_allow_offenses ||=
           { parameter_name => alternative_style.to_s }
-        both_styles_detected if config_to_allow_offences['Enabled']
+        both_styles_detected if config_to_allow_offenses['Enabled']
       end
 
       def correct_style_detected
         # Enabled:true indicates, later when the opposite style is detected,
         # that the correct style is used somewhere.
-        self.config_to_allow_offences ||= { 'Enabled' => true }
-        both_styles_detected if config_to_allow_offences[parameter_name]
+        self.config_to_allow_offenses ||= { 'Enabled' => true }
+        both_styles_detected if config_to_allow_offenses[parameter_name]
       end
 
       def both_styles_detected
         # Both correct and opposite styles exist.
-        self.config_to_allow_offences = { 'Enabled' => false }
+        self.config_to_allow_offenses = { 'Enabled' => false }
       end
 
       def unrecognized_style_detected
         # All we can do is to disable.
-        self.config_to_allow_offences = { 'Enabled' => false }
+        self.config_to_allow_offenses = { 'Enabled' => false }
       end
 
       def style
@@ -40,7 +40,7 @@ module Rubocop
         a = cop_config['SupportedStyles'].map(&:to_sym)
         if a.size != 2
           fail 'alternative_style can only be used when there are exactly ' \
-            '2 SupportedStyles'
+               '2 SupportedStyles'
         end
         style == a.first ? a.last : a.first
       end

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -6,7 +6,7 @@ module Rubocop
     # appropriate value with --auto-gen-config.
     module ConfigurableMax
       def max=(value)
-        cfg = self.config_to_allow_offences ||= {}
+        cfg = self.config_to_allow_offenses ||= {}
         value = [cfg[parameter_name], value].max if cfg[parameter_name]
         cfg[parameter_name] = value
       end

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -19,7 +19,7 @@ module Rubocop
         if matches_config?(name)
           correct_style_detected
         else
-          add_offence(node, range, message(style)) do
+          add_offense(node, range, message(style)) do
             opposite_style_detected
           end
         end