rubocop 0.15.0 → 0.16.0

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

@@ -12,7 +12,7 @@ module Rubocop
           if @prev_def_end && (def_start(node) - @prev_def_end) == 1
             unless @prev_was_single_line && singe_line_def?(node) &&
                 cop_config['AllowAdjacentOneLineDefs']
-              convention(node, :keyword)
+              add_offence(node, :keyword)
             end
           end
 

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

@@ -28,7 +28,7 @@ module Rubocop
                                        processed_source[0...(line - 1)],
                                        0,
                                        1)
-                  convention(nil, range)
+                  add_offence(range, range)
                 end
               end
             end
@@ -36,6 +36,10 @@ module Rubocop
             prev_line = cur_line
           end
         end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) }
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module Rubocop
 
           return if empty_lines_around?(node)
 
-          convention(node, :expression)
+          add_offence(node, :expression)
         end
 
         private

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

@@ -3,34 +3,49 @@
 module Rubocop
   module Cop
     module Style
-      # This cops checks for two or more consecutive blank lines.
+      # This cops checks redundant blanks lines around the bodies of classes,
+      # modules & methods.
+      #
+      # @example
+      #
+      #   class Test
+      #
+      #      def something
+      #        ...
+      #      end
+      #
+      #   end
+      #
+      #   def something(arg)
+      #
+      #     ...
+      #   end
+      #
       class EmptyLinesAroundBody < Cop
+        include CheckMethods
+
         MSG_BEG = 'Extra blank line detected at body beginning.'
         MSG_END = 'Extra blank line detected at body end.'
 
         def on_class(node)
-          check_node(node)
+          check(node)
         end
 
         def on_module(node)
-          check_node(node)
+          check(node)
         end
 
         def on_sclass(node)
-          check_node(node)
-        end
-
-        def on_def(node)
-          check_node(node)
+          check(node)
         end
 
-        def on_defs(node)
-          check_node(node)
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) }
         end
 
         private
 
-        def check_node(node)
+        def check(node, *_)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 
@@ -45,7 +60,7 @@ module Rubocop
                                  processed_source[0...start_line],
                                  0,
                                  1)
-            convention(nil, range, MSG_BEG)
+            add_offence(range, range, MSG_BEG)
           end
 
           if processed_source.lines[end_line - 2].blank?
@@ -53,7 +68,7 @@ module Rubocop
                                  processed_source[0...(end_line - 2)],
                                  0,
                                  1)
-            convention(nil, range, MSG_END)
+            add_offence(range, range, MSG_END)
           end
         end
       end

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

@@ -33,11 +33,11 @@ module Rubocop
 
           case node
           when ARRAY_NODE
-            convention(node, :expression, ARR_MSG)
+            add_offence(node, :expression, ARR_MSG)
           when HASH_NODE
-            convention(node, :expression, HASH_MSG)
+            add_offence(node, :expression, HASH_MSG)
           when STR_NODE
-            convention(node, :expression, STR_MSG)
+            add_offence(node, :expression, STR_MSG)
           end
         end
 

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

@@ -16,11 +16,11 @@ module Rubocop
             line_number += 1 if processed_source[line_number] =~ /^#!/
             line = processed_source[line_number]
             unless line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
-              convention(nil,
-                         source_range(processed_source.buffer,
-                                      processed_source[0...line_number],
-                                      0, 1),
-                         MSG)
+              add_offence(nil,
+                          source_range(processed_source.buffer,
+                                       processed_source[0...line_number],
+                                       0, 1),
+                          MSG)
             end
           end
         end

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

@@ -8,7 +8,7 @@ module Rubocop
         MSG = 'Avoid the use of END blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
-          convention(node, :keyword)
+          add_offence(node, :keyword)
         end
       end
     end

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

@@ -8,14 +8,16 @@ module Rubocop
         MSG = 'Carriage return character detected.'
 
         def investigate(processed_source)
-          original_source = IO.read(processed_source.buffer.name)
+          buffer = processed_source.buffer
+          original_source = IO.read(buffer.name,
+                                    encoding: buffer.source.encoding)
           original_source.lines.each_with_index do |line, index|
             if line =~ /\r$/
-              convention(nil,
-                         source_range(processed_source.buffer,
-                                      processed_source[0...index],
-                                      0, line.length),
-                         MSG)
+              add_offence(nil,
+                          source_range(buffer,
+                                       processed_source[0...index],
+                                       0, line.length),
+                          MSG)
               # Usually there will be carriage return characters on all or none
               # of the lines in a file, so we report only one offence.
               break

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

@@ -28,13 +28,13 @@ module Rubocop
           return unless div_by_2?(receiver)
 
           if args == ZERO
-            convention(node,
-                       :expression,
-                       method == :== ? MSG_EVEN : MSG_ODD)
+            add_offence(node,
+                        :expression,
+                        method == :== ? MSG_EVEN : MSG_ODD)
           elsif args == ONE
-            convention(node,
-                       :expression,
-                       method == :== ? MSG_ODD : MSG_EVEN)
+            add_offence(node,
+                        :expression,
+                        method == :== ? MSG_ODD : MSG_EVEN)
           end
         end
 

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

@@ -16,7 +16,7 @@ module Rubocop
 
           if receiver_node && receiver_node.type == :array &&
               method_name == :* && arg_nodes[0].type == :str
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
       end

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

@@ -5,6 +5,8 @@ module Rubocop
     module Style
       # Common functionality for modifier cops.
       module FavorModifier
+        include IfNode
+
         # TODO: Extremely ugly solution that needs lots of polish.
         def check(sexp, comments)
           case sexp.loc.keyword.source
@@ -13,23 +15,23 @@ module Rubocop
           else               cond, body = *sexp
           end
 
-          if length(sexp) > 3
-            false
-          else
-            body_length = body_length(body)
-
-            if body_length == 0
-              false
-            else
-              indentation = sexp.loc.keyword.column
-              kw_length = sexp.loc.keyword.size
-              cond_length = conditional_length(cond)
-              space = 1
-              total = indentation + body_length + space + kw_length + space +
-                cond_length
-              total <= max_line_length && !body_has_comment?(body, comments)
-            end
+          return false if length(sexp) > 3
+
+          body_length = body_length(body)
+
+          return false if body_length == 0
+
+          on_node(:lvasgn, cond) do
+            return false
           end
+
+          indentation = sexp.loc.keyword.column
+          kw_length = sexp.loc.keyword.size
+          cond_length = conditional_length(cond)
+          space = 1
+          total = indentation + body_length + space + kw_length + space +
+            cond_length
+          total <= max_line_length && !body_has_comment?(body, comments)
         end
 
         def max_line_length
@@ -85,26 +87,10 @@ module Rubocop
             next if if_else?(node)
 
             if check(node, processed_source.comments)
-              convention(node, :keyword, error_message)
+              add_offence(node, :keyword, error_message)
             end
           end
         end
-
-        def ternary_op?(node)
-          node.loc.respond_to?(:question)
-        end
-
-        def modifier_if?(node)
-          node.loc.end.nil?
-        end
-
-        def elsif?(node)
-          node.loc.keyword.is?('elsif')
-        end
-
-        def if_else?(node)
-          node.loc.respond_to?(:else) && node.loc.else
-        end
       end
 
       # Checks for while and until statements that would fit on one line
@@ -122,7 +108,7 @@ module Rubocop
             next unless node.loc.end
 
             if check(node, processed_source.comments)
-              convention(node, :keyword)
+              add_offence(node, :keyword)
             end
           end
         end

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

@@ -17,7 +17,7 @@ module Rubocop
           if method_name == :% &&
               ([:str, :dstr].include?(receiver_node.type) ||
                arg_nodes[0].type == :array)
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
       end

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

@@ -15,7 +15,7 @@ module Rubocop
           if condition.type == :send
             _object, method = *condition
             if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
-              convention(node, :expression, error_message)
+              add_offence(node, :expression, error_message)
             end
           end
         end

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

@@ -14,7 +14,7 @@ module Rubocop
             range = source_range(processed_source.buffer,
                                  processed_source[0...-1],
                                  final_line.length - 1, 1)
-            convention(range, range)
+            add_offence(range, range)
           end
         end
 

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of flip flop operator
+      class FlipFlop < Cop
+        MSG = 'Avoid the use of flip flop operators.'
+
+        def on_iflipflop(node)
+          add_offence(node, :expression)
+        end
+
+        def on_eflipflop(node)
+          add_offence(node, :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,43 @@
 module Rubocop
   module Cop
     module Style
-      # This cop looks for uses of the *for* keyword.
+      # This cop looks for uses of the *for* keyword, or *each* method. The
+      # preferred alternative is set in the EnforcedStyle configuration
+      # parameter. An *each* call with a block on a single line is always
+      # allowed, however.
       class For < Cop
-        MSG = 'Prefer *each* over *for*.'
+        include ConfigurableEnforcedStyle
 
         def on_for(node)
-          convention(node, :keyword)
+          if style == :each
+            add_offence(node, :keyword, 'Prefer *each* over *for*.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def on_block(node)
+          return if block_length(node) == 0
+
+          method, _args, _body = *node
+          return unless method.type == :send
+
+          _receiver, method_name, *args = *method
+          return unless method_name == :each && args.empty?
+
+          if style == :for
+            end_pos = method.loc.expression.end_pos
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              end_pos - 'each'.length,
+                                              end_pos)
+            add_offence(range, range, 'Prefer *for* over *each*.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
         end
       end
     end

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

@@ -66,7 +66,7 @@ module Rubocop
         def check(node)
           global_var, = *node
 
-          convention(node, :name) unless allowed_var?(global_var)
+          add_offence(node, :name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -14,9 +14,9 @@ module Rubocop
           _receiver, method_name, *args = *node
 
           if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
-            convention(node, :selector,
-                       MSG.format(method_name,
-                                  proper_method_name(method_name)))
+            add_offence(node, :selector,
+                        MSG.format(method_name,
+                                   proper_method_name(method_name)))
           end
         end
 

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

@@ -10,15 +10,13 @@ module Rubocop
       #
       # A separate offence is registered for each problematic pair.
       class HashSyntax < Cop
+        include ConfigurableEnforcedStyle
+
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_HASH_ROCKETS = 'Always use hash rockets in hashes.'
 
         def on_hash(node)
-          case cop_config['EnforcedStyle']
-          when 'ruby19' then ruby19_check(node)
-          when 'hash_rockets' then hash_rockets_check(node)
-          else fail 'Unknown HashSyntax style'
-          end
+          style == :ruby19 ? ruby19_check(node) : hash_rockets_check(node)
         end
 
         def ruby19_check(node)
@@ -38,8 +36,7 @@ module Rubocop
         def autocorrect(node)
           key = node.children.first.loc.expression
           op = node.loc.operator
-          if cop_config['EnforcedStyle'] == 'ruby19' &&
-              !space_before_operator?(op, key) &&
+          if style == :ruby19 && !space_before_operator?(op, key) &&
               config.for_cop('SpaceAroundOperators')['Enabled']
             # Don't do the correction if there is no space before '=>'. The
             # combined corrections of this cop and SpaceAroundOperators could
@@ -48,7 +45,7 @@ module Rubocop
           end
 
           @corrections << lambda do |corrector|
-            if cop_config['EnforcedStyle'] == 'ruby19'
+            if style == :ruby19
               corrector.insert_after(key, ' ')
               corrector.replace(key, key.source.sub(/^:(.*)/, '\1:'))
             else
@@ -68,9 +65,9 @@ module Rubocop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.loc.operator && pair.loc.operator.is?(delim)
-              convention(pair,
-                         pair.loc.expression.begin.join(pair.loc.operator),
-                         msg)
+              add_offence(pair,
+                          pair.loc.expression.begin.join(pair.loc.operator),
+                          msg)
             end
           end
         end