rubocop 0.12.0 → 0.13.0

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

@@ -8,10 +8,7 @@ module Rubocop
         MSG = 'Do not use `attr`. Use `attr_reader` instead.'
 
         def on_send(node)
-          if command?(:attr, node)
-            add_offence(:convention, node.loc.selector, MSG)
-            do_autocorrect(node)
-          end
+          convention(node, :selector) if command?(:attr, node)
         end
 
         def autocorrect_action(node)

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

@@ -8,7 +8,7 @@ module Rubocop
         MSG = 'Avoid the use of BEGIN blocks.'
 
         def on_preexe(node)
-          add_offence(:convention, node.loc.keyword, MSG)
+          convention(node, :keyword)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Rubocop
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             if comment.text.start_with?('=begin')
-              add_offence(:convention, comment.loc.expression, MSG)
+              convention(comment, :expression)
             end
           end
         end

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

@@ -14,7 +14,7 @@ module Rubocop
 
         def investigate(processed_source)
           return unless processed_source.ast
-          max = BlockNesting.config['Max']
+          max = cop_config['Max']
           check_nesting_level(processed_source.ast, max, 0)
         end
 
@@ -27,7 +27,7 @@ module Rubocop
               current_level += 1
             end
             if current_level == max + 1
-              add_offence(:convention, node.location.expression, message(max))
+              convention(node, :expression, message(max))
               return
             end
           end

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

@@ -29,9 +29,21 @@ module Rubocop
           block_begin = node.loc.begin.source
 
           if block_length > 0 && block_begin == '{'
-            add_offence(:convention, node.loc.begin, MULTI_LINE_MSG)
+            convention(node, :begin, MULTI_LINE_MSG)
           elsif block_length == 0 && block_begin != '{'
-            add_offence(:convention, node.loc.begin, SINGLE_LINE_MSG)
+            convention(node, :begin, SINGLE_LINE_MSG)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            if node.loc.begin.is?('{')
+              corrector.replace(node.loc.begin, 'do')
+              corrector.replace(node.loc.end, 'end')
+            else
+              corrector.replace(node.loc.begin, '{')
+              corrector.replace(node.loc.end, '}')
+            end
           end
         end
 

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

@@ -10,9 +10,7 @@ module Rubocop
         def on_send(node)
           _receiver, method_name, *_args = *node
 
-          if method_name == :===
-            add_offence(:convention, node.loc.selector, MSG)
-          end
+          convention(node, :selector) if method_name == :===
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Rubocop
 
           whens.each do |when_node|
             pos = when_node.loc.keyword
-            add_offence(:convention, pos, MSG) if pos.column != case_column
+            convention(when_node, pos) if pos.column != case_column
           end
         end
       end

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

@@ -16,8 +16,7 @@ module Rubocop
           # we don't register an offence for things like ?\C-\M-d
           if node.loc.begin.is?('?') &&
               node.loc.expression.source.size.between?(2, 3)
-            add_offence(:convention, node.loc.expression, MSG)
-            do_autocorrect(node)
+            convention(node, :expression)
           end
         end
 

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

@@ -21,7 +21,7 @@ module Rubocop
         def check_name(node)
           name = node.loc.name.source
 
-          add_offence(:convention, node.loc.name, MSG) if name =~ /_/
+          convention(node, :name) if name =~ /_/
         end
       end
     end

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

@@ -12,9 +12,7 @@ module Rubocop
         def on_defs(node)
           definee, _name, _args, _body = *node
 
-          if definee.type == :const
-            add_offence(:convention, definee.loc.name, MSG)
-          end
+          convention(definee, :name) if definee.type == :const
         end
       end
     end

data/lib/rubocop/cop/style/{avoid_class_vars.rb → class_vars.rb}

@@ -6,12 +6,16 @@ module Rubocop
       # This cop checks for uses of class variables. Offences
       # are signaled only on assignment to class variables to
       # reduced the number of offences that would be reported.
-      class AvoidClassVars < Cop
+      class ClassVars < Cop
         MSG = 'Replace class var %s with a class instance var.'
 
         def on_cvasgn(node)
+          convention(node, :name)
+        end
+
+        def message(node)
           class_var, = *node
-          add_offence(:convention, node.loc.name, sprintf(MSG, class_var))
+          MSG.format(class_var)
         end
       end
     end

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

@@ -12,9 +12,9 @@ module Rubocop
       class CollectionMethods < Cop
         MSG = 'Prefer %s over %s.'
 
-        def self.preferred_methods
-          if config['PreferredMethods']
-            config['PreferredMethods'].symbolize_keys
+        def preferred_methods
+          if cop_config['PreferredMethods']
+            cop_config['PreferredMethods'].symbolize_keys
           end
         end
 
@@ -44,20 +44,18 @@ module Rubocop
         def check_method_node(node)
           _receiver, method_name, *_args = *node
 
-          if self.class.preferred_methods[method_name]
-            add_offence(
-              :convention,
-              node.loc.selector,
+          if preferred_methods[method_name]
+            convention(
+              node, :selector,
               sprintf(MSG,
                       preferred_method(method_name),
                       method_name)
             )
-            do_autocorrect(node)
           end
         end
 
         def preferred_method(method)
-          self.class.preferred_methods[method.to_sym]
+          preferred_methods[method.to_sym]
         end
       end
     end

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

@@ -15,8 +15,7 @@ module Rubocop
           return unless receiver && node.loc.dot && node.loc.dot.is?('::')
           return if allowed_name(_method_name.to_s)
 
-          add_offence(:convention, node.loc.dot, MSG)
-          do_autocorrect(node)
+          convention(node, :dot)
         end
 
         def allowed_name(method_name)

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

@@ -6,8 +6,8 @@ module Rubocop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       class CommentAnnotation < Cop
-        MSG = 'Annotation keywords shall be all upper case, followed by a ' +
-          'colon and a space, then a note describing the problem.'
+        MSG = 'Annotation keywords should be all upper case, followed by a ' \
+              'colon and a space, then a note describing the problem.'
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
@@ -21,14 +21,14 @@ module Rubocop
                 range = Parser::Source::Range.new(processed_source.buffer,
                                                   start,
                                                   start + length)
-                add_offence(:convention, range, MSG)
+                convention(nil, range)
               end
             end
           end
         end
 
-        def self.keywords
-          CommentAnnotation.config['Keywords']
+        def keywords
+          cop_config['Keywords']
         end
 
         private
@@ -51,7 +51,7 @@ module Rubocop
         end
 
         def keyword?(word)
-          CommentAnnotation.keywords.include?(word)
+          keywords.include?(word)
         end
       end
     end

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

@@ -18,9 +18,7 @@ module Rubocop
           # We cannot know the result of method calls line
           # NewClass = something_that_returns_a_class
           unless value && [:send, :block].include?(value.type)
-            if const_name !~ SNAKE_CASE
-              add_offence(:convention, node.loc.name, MSG)
-            end
+            convention(node, :name) if const_name !~ SNAKE_CASE
           end
         end
       end

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

@@ -17,10 +17,7 @@ module Rubocop
           return if start_line == end_line
 
           _, args = *node
-          if args.children == [] && args.loc.begin
-            add_offence(:convention, args.loc.begin, MSG)
-            do_autocorrect(args)
-          end
+          convention(args, :begin) if args.children == [] && args.loc.begin
         end
 
         def on_defs(node)
@@ -30,10 +27,7 @@ module Rubocop
           return if start_line == end_line
 
           _, _, args = *node
-          if args.children == [] && args.loc.begin
-            add_offence(:convention, args.loc.begin, MSG)
-            do_autocorrect(args)
-          end
+          convention(args, :begin) if args.children == [] && args.loc.begin
         end
 
         def autocorrect_action(node)
@@ -54,8 +48,7 @@ module Rubocop
           _, args = *node
 
           if args.children.size > 0 && args.loc.begin.nil?
-            add_offence(:convention, args.loc.expression, MSG)
-            do_autocorrect(args)
+            convention(args, :expression)
           end
         end
 
@@ -63,8 +56,7 @@ module Rubocop
           _, _, args = *node
 
           if args.children.size > 0 && args.loc.begin.nil?
-            add_offence(:convention, args.loc.expression, MSG)
-            do_autocorrect(args)
+            convention(args, :expression)
           end
         end
 

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

@@ -30,7 +30,7 @@ module Rubocop
             _name, _superclass, body = *node
 
             if body && ast_with_comments[node].empty?
-              add_offence(:convention, node.loc.keyword, format(MSG, 'class'))
+              convention(node, :keyword, format(MSG, 'class'))
             end
           end
         end
@@ -52,7 +52,7 @@ module Rubocop
             end
 
             if !namespace && ast_with_comments[node].empty?
-              add_offence(:convention, node.loc.keyword, format(MSG, 'module'))
+              convention(node, :keyword, format(MSG, 'module'))
             end
           end
         end

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

@@ -10,9 +10,7 @@ module Rubocop
         def on_send(node)
           return unless node.loc.dot
 
-          unless proper_dot_position?(node)
-            add_offence(:convention, node.loc.dot, MSG)
-          end
+          convention(node, :dot) unless proper_dot_position?(node)
         end
 
         private
@@ -27,7 +25,7 @@ module Rubocop
             selector_line = node.loc.begin.line
           end
 
-          case DotPosition.config['Style'].downcase
+          case cop_config['Style'].downcase
           when 'leading' then dot_line == selector_line
           when 'trailing' then dot_line != selector_line
           else fail 'Unknown dot position style selected.'

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

@@ -9,14 +9,29 @@ module Rubocop
         MSG = 'Use empty lines between defs.'
 
         def on_def(node)
-          def_start = node.loc.keyword.line
-          def_end = node.loc.end.line
-
-          if @prev_def_end && (def_start - @prev_def_end) == 1
-            add_offence(:convention, node.loc.keyword, MSG)
+          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)
+            end
           end
 
-          @prev_def_end = def_end
+          @prev_def_end = def_end(node)
+          @prev_was_single_line = singe_line_def?(node)
+        end
+
+        private
+
+        def singe_line_def?(node)
+          def_start(node) == def_end(node)
+        end
+
+        def def_start(node)
+          node.loc.keyword.line
+        end
+
+        def def_end(node)
+          node.loc.end.line
         end
       end
     end

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

@@ -28,7 +28,7 @@ module Rubocop
                                        processed_source[0...(line - 1)],
                                        0,
                                        1)
-                  add_offence(:convention, range, MSG)
+                  convention(nil, range)
                 end
               end
             end

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

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

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

@@ -15,12 +15,12 @@ module Rubocop
             line_number = 0
             line_number += 1 if processed_source[line_number] =~ /^#!/
             line = processed_source[line_number]
-            unless line =~ /#.*coding\s?: (UTF|utf)-8/
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...line_number],
-                                       0, 1),
-                          MSG)
+            unless line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
+              convention(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)
-          add_offence(:convention, node.loc.keyword, MSG)
+          convention(node, :keyword)
         end
       end
     end

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

@@ -10,11 +10,11 @@ module Rubocop
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             if line =~ /\r$/
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index],
-                                       line.length - 1, 1),
-                          MSG)
+              convention(nil,
+                         source_range(processed_source.buffer,
+                                      processed_source[0...index],
+                                      line.length - 1, 1),
+                         MSG)
             end
           end
         end