rubocop 0.16.0 → 0.17.0

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

@@ -18,23 +18,15 @@ module Rubocop
       #   # good
       #   def value? ...
       class PredicateName < Cop
-        def on_def(node)
-          method_name, args, _body = *node
-          check(node, method_name.to_s, args)
-        end
-
-        def on_defs(node)
-          _scope, method_name, args, _body = *node
-          check(node, method_name.to_s, args)
-        end
+        include CheckMethods
 
         private
 
-        def check(node, method_name, args)
+        def check(node, method_name, args, _body)
           prefix_blacklist.each do |prefix|
-            if method_name.start_with?(prefix)
+            if method_name.to_s.start_with?(prefix)
               add_offence(node, :name,
-                          message(method_name, prefix))
+                          message(method_name.to_s, prefix))
             end
           end
         end

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

@@ -23,25 +23,33 @@ module Rubocop
         def check_compact(node)
           _receiver, selector, *args = *node
 
-          return unless args.size > 1
-
-          add_offence(node, :expression, message(selector))
+          if args.size > 1
+            add_offence(node, :expression, message(selector)) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
         end
 
         def check_exploded(node)
           _receiver, selector, *args = *node
 
-          return unless args.size == 1
-
-          arg, = *args
+          if args.size == 1
+            arg, = *args
 
-          if arg.type == :send && arg.loc.selector.is?('new')
-            _receiver, _selector, *constructor_args = *arg
+            if arg.type == :send && arg.loc.selector.is?('new')
+              _receiver, _selector, *constructor_args = *arg
 
-            # Allow code like `raise Ex.new(arg1, arg2)`.
-            unless constructor_args.size > 1
-              add_offence(node, :expression, message(selector))
+              # Allow code like `raise Ex.new(arg1, arg2)`.
+              if constructor_args.size <= 1
+                add_offence(node, :expression, message(selector)) do
+                  opposite_style_detected
+                end
+              end
             end
+          else
+            correct_style_detected
           end
         end
 

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

@@ -7,16 +7,25 @@ module Rubocop
       # on how many escaped slashes there are in the regexp and on the
       # value of the configuration parameter MaxSlashes.
       class RegexpLiteral < Cop
+        include ConfigurableMax
+
         def on_regexp(node)
           string_parts = node.children.select { |child| child.type == :str }
           total_string = string_parts.map { |s| s.loc.expression.source }.join
           slashes = total_string.count('/')
-          msg = if node.loc.begin.is?('/')
-                  error_message('') if slashes > max_slashes
-                else
-                  error_message('only ') if slashes <= max_slashes
-                end
-          add_offence(node, :expression, msg) if msg
+          if node.loc.begin.is?('/')
+            if slashes > max_slashes
+              msg = error_message('')
+              safe_setting = slashes
+            end
+          elsif slashes <= max_slashes
+            msg = error_message('only ')
+            safe_setting = slashes + 1
+          end
+
+          if msg
+            add_offence(node, :expression, msg) { self.max = safe_setting }
+          end
         end
 
         def max_slashes
@@ -25,6 +34,10 @@ module Rubocop
 
         private
 
+        def parameter_name
+          'MaxSlashes'
+        end
+
         def error_message(word)
           sprintf('Use %%r %sfor regular expressions matching more ' +
                   "than %d '/' character%s.",

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for colon (:) not follwed by some kind of space.
+      class SpaceAfterColon < Cop
+        include IfNode
+
+        MSG = 'Space missing after colon.'
+
+        def on_pair(node)
+          oper = node.loc.operator
+          if oper.is?(':') && oper.source_buffer.source[oper.end_pos] =~ /\S/
+            add_offence(oper, oper)
+          end
+        end
+
+        def on_if(node)
+          if ternary_op?(node)
+            colon = node.loc.colon
+            if colon.source_buffer.source[colon.end_pos] =~ /\S/
+              add_offence(colon, colon)
+            end
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(range, ' ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for comma (,) not follwed by some kind of space.
+      class SpaceAfterComma < Cop
+        include SpaceAfterPunctuation
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for semicolon (;) not follwed by some kind of space.
+      class SpaceAfterSemicolon < Cop
+        include SpaceAfterPunctuation
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+    end
+  end
+end

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

@@ -42,28 +42,29 @@ module Rubocop
           sb = node.loc.expression.source_buffer
 
           if left_brace.end_pos == right_brace.begin_pos
-            no_space(style_for_empty_braces, sb, left_brace.begin_pos,
-                     right_brace.end_pos, 'Space missing inside empty braces.')
+            if style_for_empty_braces == :space
+              offence(sb, left_brace.begin_pos, right_brace.end_pos,
+                      'Space missing inside empty braces.')
+            end
           else
             range = Parser::Source::Range.new(sb, left_brace.end_pos,
                                               right_brace.begin_pos)
             inner = range.source
             unless inner =~ /\n/
               if inner =~ /\S/
-                braces_with_contents_inside(node, inner)
-              else
-                space(style_for_empty_braces, sb, range.begin_pos,
-                      range.end_pos, 'Space inside empty braces detected.')
+                braces_with_contents_inside(node, inner, sb)
+              elsif style_for_empty_braces == :no_space
+                offence(sb, range.begin_pos, range.end_pos,
+                        'Space inside empty braces detected.')
               end
             end
           end
         end
 
-        def braces_with_contents_inside(node, inner)
+        def braces_with_contents_inside(node, inner, sb)
           _method, args, _body = *node
           left_brace, right_brace = node.loc.begin, node.loc.end
           pipe = args.loc.begin
-          sb = node.loc.expression.source_buffer
 
           if inner =~ /^\S/
             no_space_inside_left_brace(left_brace, pipe, sb)
@@ -72,8 +73,8 @@ module Rubocop
           end
 
           if inner =~ /\S$/
-            no_space(style_for_inside_braces, sb, right_brace.begin_pos,
-                     right_brace.end_pos, 'Space missing inside }.')
+            no_space(sb, right_brace.begin_pos, right_brace.end_pos,
+                     'Space missing inside }.')
           else
             space_inside_right_brace(right_brace, sb)
           end
@@ -81,55 +82,58 @@ module Rubocop
 
         def no_space_inside_left_brace(left_brace, pipe, sb)
           if pipe
-            if left_brace.end_pos == pipe.begin_pos
-              no_space(style_for_block_parameters, sb, left_brace.begin_pos,
-                       pipe.end_pos, 'Space between { and | missing.')
+            if left_brace.end_pos == pipe.begin_pos &&
+                cop_config['SpaceBeforeBlockParameters']
+              offence(sb, left_brace.begin_pos, pipe.end_pos,
+                      'Space between { and | missing.')
             end
           else
             # We indicate the position after the left brace. Otherwise it's
             # difficult to distinguish between space missing to the left and to
             # the right of the brace in autocorrect.
-            no_space(style_for_inside_braces, sb, left_brace.end_pos,
-                     left_brace.end_pos + 1, 'Space missing inside {.')
+            no_space(sb, left_brace.end_pos, left_brace.end_pos + 1,
+                     'Space missing inside {.')
           end
         end
 
         def space_inside_left_brace(left_brace, pipe, sb)
           if pipe
-            space(style_for_block_parameters, sb, left_brace.end_pos,
-                  pipe.begin_pos, 'Space between { and | detected.')
+            unless cop_config['SpaceBeforeBlockParameters']
+              offence(sb, left_brace.end_pos, pipe.begin_pos,
+                      'Space between { and | detected.')
+            end
           else
             brace_with_space = range_with_surrounding_space(left_brace, :right)
-            space(style_for_inside_braces, sb, brace_with_space.begin_pos + 1,
-                  brace_with_space.end_pos, 'Space inside { detected.')
+            space(sb, brace_with_space.begin_pos + 1, brace_with_space.end_pos,
+                  'Space inside { detected.')
           end
         end
 
         def space_inside_right_brace(right_brace, sb)
           brace_with_space = range_with_surrounding_space(right_brace, :left)
-          space(style_for_inside_braces, sb, brace_with_space.begin_pos,
-                brace_with_space.end_pos - 1, 'Space inside } detected.')
+          space(sb, brace_with_space.begin_pos, brace_with_space.end_pos - 1,
+                'Space inside } detected.')
         end
 
-        def no_space(specific_style, sb, begin_pos, end_pos, msg)
-          offence(sb, begin_pos, end_pos, msg) if specific_style == :space
+        def no_space(sb, begin_pos, end_pos, msg)
+          if style == :space_inside_braces
+            offence(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
         end
 
-        def space(specific_style, sb, begin_pos, end_pos, msg)
-          offence(sb, begin_pos, end_pos, msg) if specific_style == :no_space
+        def space(sb, begin_pos, end_pos, msg)
+          if style == :no_space_inside_braces
+            offence(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
         end
 
         def offence(sb, begin_pos, end_pos, msg)
           range = Parser::Source::Range.new(sb, begin_pos, end_pos)
-          add_offence(range, range, msg)
-        end
-
-        def available_styles
-          %w(space_inside_braces no_space_inside_braces)
-        end
-
-        def style_for_inside_braces
-          style == :space_inside_braces ? :space : :no_space
+          add_offence(range, range, msg) { yield if block_given? }
         end
 
         def style_for_empty_braces
@@ -140,10 +144,6 @@ module Rubocop
           end
         end
 
-        def style_for_block_parameters
-          cop_config['SpaceBeforeBlockParameters'] ? :space : :no_space
-        end
-
         def autocorrect(range)
           @corrections << lambda do |corrector|
             case range.source

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

@@ -6,8 +6,7 @@ module Rubocop
       # Checks that operators have space around them, except for **
       # which should not have surrounding space.
       class SpaceAroundOperators < Cop
-        TYPES = %w(and or class
-                   op_asgn and_asgn or_asgn masgn casgn lvasgn ivasgn gvasgn)
+        TYPES = %w(and or class) + ASGN_NODES
 
         TYPES.each { |t| define_method(:"on_#{t}") { |node| check(node) } }
 

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

@@ -40,8 +40,12 @@ module Rubocop
           if offence?(t1, t2, expect_space)
             brace = (t1.text == '{' ? t1 : t2).pos
             range = expect_space ? brace : space_range(brace)
-            add_offence(range, range,
-                        message(brace, is_empty_braces, expect_space))
+            add_offence(range, range, message(brace, is_empty_braces,
+                                              expect_space)) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
           end
         end
 

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

@@ -12,17 +12,17 @@ module Rubocop
 
         def message(node)
           if style == :single_quotes
-            "Prefer single-quoted strings when you don't need string " +
-              'interpolation or special symbols.'
+            "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.'
+            'Prefer double-quoted strings unless you need single quotes to ' \
+            'avoid extra backslashes for escaping.'
           end
         end
 
         def offence?(node)
           src = node.loc.expression.source
-          return false if src =~ /^(%q|\?|<<-)/i
+          return false if src =~ /^(%[qQ]?|\?|<<-)/i
           src !~ if style == :single_quotes
                    # regex matches IF there is a ' or there is a \\ in the
                    # string that is not preceeded/followed by another \\

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

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in parameter lists and literals.
+      class TrailingComma < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = '%s comma after the last %s.'
+
+        def on_array(node)
+          check_literal(node, 'item of %s array')
+        end
+
+        def on_hash(node)
+          check_literal(node, 'item of %s hash')
+        end
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          return if args.empty?
+          # It's impossible for a method call without parentheses to have
+          # a trailing comma.
+          return unless brackets?(node)
+
+          check(node, args, 'parameter of %s method call',
+                args.last.loc.expression.end_pos, node.loc.expression.end_pos)
+        end
+
+        private
+
+        def parameter_name
+          'EnforcedStyleForMultiline'
+        end
+
+        def check_literal(node, kind)
+          return if node.children.empty?
+          # A braceless hash is the last parameter of a method call and will be
+          # checked as such.
+          return unless brackets?(node)
+
+          check(node, node.children, kind,
+                node.children.last.loc.expression.end_pos,
+                node.loc.end.begin_pos)
+        end
+
+        def check(node, items, kind, begin_pos, end_pos)
+          sb = items.first.loc.expression.source_buffer
+          after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
+          comma_offset = after_last_item.source =~ /,/
+          should_have_comma = style == :comma && multiline?(node)
+          if comma_offset
+            unless should_have_comma
+              avoid_comma(items, kind,
+                          after_last_item.begin_pos + comma_offset, sb)
+            end
+          elsif should_have_comma
+            put_comma(items, kind, sb)
+          end
+        end
+
+        # Returns true if the node has round/square/curly brackets.
+        def brackets?(node)
+          !node.loc.end.nil?
+        end
+
+        # Returns true if the round/square/curly brackets of the given node are
+        # on different lines.
+        def multiline?(node)
+          [node.loc.begin, node.loc.end].map(&:line).uniq.size > 1
+        end
+
+        def avoid_comma(items, kind, comma_begin_pos, sb)
+          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)))
+        end
+
+        def put_comma(items, kind, sb)
+          last_expr = items.last.loc.expression
+          ix = last_expr.source.rindex("\n") || 0
+          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')))
+        end
+      end
+    end
+  end
+end