rubocop 0.18.1 → 0.19.0

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

@@ -63,7 +63,7 @@ module Rubocop
           if style == :semantic
             each_command(method_name, node) do |send_node|
               unless ignored_node?(send_node)
-                add_offence(send_node, :selector, message(method_name))
+                add_offense(send_node, :selector, message(method_name))
                 ignore_node(send_node)
               end
             end
@@ -71,7 +71,7 @@ module Rubocop
             _receiver, selector, _args = *node
 
             if [:raise, :fail].include?(selector) && selector != method_name
-              add_offence(node, :selector, message(method_name))
+              add_offense(node, :selector, message(method_name))
             end
           end
         end

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

@@ -26,7 +26,7 @@ module Rubocop
           return true unless args.all? { |n| n.type == :arg }
 
           unless args_match?(method_name, args)
-            add_offence(args_node, :expression, message(method_name))
+            add_offense(args_node, :expression, message(method_name))
           end
         end
 

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

@@ -23,9 +23,46 @@ module Rubocop
           empty_body = body.nil?
 
           if start_line == end_line && !(allow_empty? && empty_body)
-            add_offence(node, :expression)
+            @body = body
+            add_offense(node, :expression)
           end
         end
+
+        def autocorrect(node)
+          body = @body
+          eol_comment = processed_source.comments.find do |c|
+            c.loc.line == node.loc.expression.line
+          end
+          @corrections << lambda do |corrector|
+            if body.type == :begin
+              body.children.each do |part|
+                break_line_before(part.loc.expression, node, corrector, 1)
+              end
+            else
+              break_line_before(body.loc.expression, node, corrector, 1)
+            end
+
+            break_line_before(node.loc.end, node, corrector, 0)
+
+            move_comment(eol_comment, node, corrector) if eol_comment
+          end
+        end
+
+        def break_line_before(range, node, corrector, indent_steps)
+          corrector.insert_before(range,
+                                  "\n" + ' ' * (node.loc.keyword.column +
+                                                indent_steps *
+                                                IndentationWidth::
+                                                CORRECT_INDENTATION))
+        end
+
+        def move_comment(eol_comment, node, corrector)
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node.loc.expression,
+                                  text + "\n" +
+                                  ' ' * node.loc.keyword.column)
+          corrector.remove(eol_comment.loc.expression)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for colon (:) not follwed by some kind of space.
+      # Checks for colon (:) not followed by some kind of space.
       class SpaceAfterColon < Cop
         include IfNode
 
@@ -12,7 +12,7 @@ module Rubocop
         def on_pair(node)
           oper = node.loc.operator
           if oper.is?(':') && oper.source_buffer.source[oper.end_pos] =~ /\S/
-            add_offence(oper, oper)
+            add_offense(oper, oper)
           end
         end
 
@@ -20,7 +20,7 @@ module Rubocop
           if ternary_op?(node)
             colon = node.loc.colon
             if colon.source_buffer.source[colon.end_pos] =~ /\S/
-              add_offence(colon, colon)
+              add_offense(colon, colon)
             end
           end
         end

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

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for comma (,) not follwed by some kind of space.
+      # Checks for comma (,) not followed by some kind of space.
       class SpaceAfterComma < Cop
         include SpaceAfterPunctuation
 

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

@@ -16,7 +16,7 @@ module Rubocop
           kw = node.loc.keyword
           kw_offset = kw.begin_pos - exp.begin_pos
           if exp.source[kw_offset..-1].start_with?(kw.source + '(')
-            add_offence(node, kw)
+            add_offense(node, kw)
           end
         end
 

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

@@ -3,12 +3,20 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for space between a method name and a left parenthesis.
+      # Checks for space between a method name and a left parenthesis in defs.
+      #
+      # @example
+      #
+      #   # bad
+      #   def func (x) ... end
+      #
+      #   # good
+      #   def func(x) ... end
       class SpaceAfterMethodName < Cop
         include CheckMethods
 
         MSG = 'Never put a space between a method name and the opening ' \
-          'parenthesis.'
+              'parenthesis.'
 
         def check(_node, _method_name, args, body)
           return unless args.loc.begin && args.loc.begin.is?('(')
@@ -17,7 +25,7 @@ module Rubocop
                                                             expr.begin_pos - 1,
                                                             expr.begin_pos)
           if pos_before_left_paren.source =~ /\s/
-            add_offence(pos_before_left_paren, pos_before_left_paren)
+            add_offense(pos_before_left_paren, pos_before_left_paren)
           end
         end
 

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

@@ -21,7 +21,7 @@ module Rubocop
 
           if node.loc.expression.source =~ /^!\s+\w+/
             # TODO: Improve source range to highlight the redundant whitespace.
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
 

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

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     module Style
-      # Checks for semicolon (;) not follwed by some kind of space.
+      # Checks for semicolon (;) not followed by some kind of space.
       class SpaceAfterSemicolon < Cop
         include SpaceAfterPunctuation
 

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

@@ -4,10 +4,10 @@ module Rubocop
   module Cop
     module Style
       # Checks that the equals signs in parameter default assignments
-      # have surrounding space.
+      # have or don't have surrounding space depending on configuration.
       class SpaceAroundEqualsInParameterDefault < Cop
         include SurroundingSpace
-        MSG = 'Surrounding space missing in default value assignment.'
+        include ConfigurableEnforcedStyle
 
         def investigate(processed_source)
           return unless processed_source.ast
@@ -15,16 +15,51 @@ module Rubocop
           on_node(:optarg, processed_source.ast) do |optarg|
             index = index_of_first_token(optarg)
             arg, equals, value = processed_source.tokens[index, 3]
-            unless space_between?(arg, equals) && space_between?(equals, value)
-              add_offence(equals.pos, equals.pos)
+            check_optarg(arg, equals, value)
+          end
+        end
+
+        private
+
+        def check_optarg(arg, equals, value)
+          space_on_both_sides = space_on_both_sides?(arg, equals, value)
+          no_surrounding_space = no_surrounding_space?(arg, equals, value)
+
+          if style == :space && space_on_both_sides ||
+              style == :no_space && no_surrounding_space
+            correct_style_detected
+          else
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              arg.pos.end_pos,
+                                              value.pos.begin_pos)
+            add_offense(range, range) do
+              if style == :space && no_surrounding_space ||
+                  style == :no_space && space_on_both_sides
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
             end
           end
         end
 
+        def space_on_both_sides?(arg, equals, value)
+          space_between?(arg, equals) && space_between?(equals, value)
+        end
+
+        def no_surrounding_space?(arg, equals, value)
+          !space_between?(arg, equals) && !space_between?(equals, value)
+        end
+
+        def message(_)
+          format('Surrounding space %s in default value assignment.',
+                 style == :space ? 'missing' : 'detected')
+        end
+
         def autocorrect(range)
+          replacement = style == :space ? ' = ' : '='
           @corrections << lambda do |corrector|
-            corrector.insert_before(range, ' ')
-            corrector.insert_after(range, ' ')
+            corrector.replace(range, replacement)
           end
         end
       end

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

@@ -46,7 +46,7 @@ module Rubocop
         end
 
         def called_with_dot?(node)
-          !!node.loc.dot
+          node.loc.dot
         end
 
         def check(node)
@@ -57,11 +57,11 @@ module Rubocop
           with_space = range_with_surrounding_space(op)
           if op.is?('**')
             unless with_space.is?('**')
-              add_offence(with_space, op, 'Space around operator ** detected.')
+              add_offense(with_space, op, 'Space around operator ** detected.')
             end
           elsif with_space.source !~ /^\s.*\s$/
-            add_offence(with_space, op,
-                        'Surrounding space missing for operator' +
+            add_offense(with_space, op,
+                        'Surrounding space missing for operator' \
                         " '#{op.source}'.")
           end
         end

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that block braces have or don't have a space before the opening
+      # brace depending on configuration.
+      class SpaceBeforeBlockBraces < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_block(node)
+          return if node.loc.begin.is?('do') # No braces.
+
+          # If braces are on separate lines, and the Blocks cop is enabled,
+          # those braces will be changed to do..end by the user or by
+          # auto-correct, so reporting space issues is not useful, and it
+          # creates auto-correct conflicts.
+          if config.for_cop('Blocks')['Enabled'] && Util.block_length(node) > 0
+            return
+          end
+
+          left_brace = node.loc.begin
+          space_plus_brace = range_with_surrounding_space(left_brace)
+          used_style =
+            space_plus_brace.source.start_with?('{') ? :no_space : :space
+
+          case used_style
+          when style  then correct_style_detected
+          when :space then space_detected(left_brace, space_plus_brace)
+          else             space_missing(left_brace)
+          end
+        end
+
+        private
+
+        def space_missing(left_brace)
+          add_offense(left_brace, left_brace,
+                      'Space missing to the left of {.') do
+            opposite_style_detected
+          end
+        end
+
+        def space_detected(left_brace, space_plus_brace)
+          space = Parser::Source::Range.new(left_brace.source_buffer,
+                                            space_plus_brace.begin_pos,
+                                            left_brace.begin_pos)
+          add_offense(space, space, 'Space detected to the left of {.') do
+            opposite_style_detected
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            else           corrector.insert_before(range, ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module Rubocop
             kw = node.loc.keyword
             b = kw.begin_pos
             left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
-            add_offence(node, left_of_kw) unless left_of_kw.is?(' ')
+            add_offense(node, left_of_kw) unless left_of_kw.is?(' ')
           end
         end
 

data/lib/rubocop/cop/style/{space_around_block_braces.rb → space_inside_block_braces.rb}

@@ -3,12 +3,11 @@
 module Rubocop
   module Cop
     module Style
-      # Checks that block braces have or don't have surrounding space depending
-      # on configuration. For blocks taking parameters, it checks that the left
-      # brace has or doesn't have trailing space depending on configuration.
-      # Also checks that the left brace is preceded by a space and this is not
-      # configurable.
-      class SpaceAroundBlockBraces < Cop
+      # Checks that block braces have or don't have surrounding space inside
+      # them on configuration. For blocks taking parameters, it checks that the
+      # left brace has or doesn't have trailing space depending on
+      # configuration.
+      class SpaceInsideBlockBraces < Cop
         include ConfigurableEnforcedStyle
         include SurroundingSpace
 
@@ -25,25 +24,17 @@ module Rubocop
 
           left_brace, right_brace = node.loc.begin, node.loc.end
 
-          check_outside(left_brace)
           check_inside(node, left_brace, right_brace)
         end
 
         private
 
-        def check_outside(left_brace)
-          if range_with_surrounding_space(left_brace).source.start_with?('{')
-            add_offence(left_brace, left_brace,
-                        'Space missing to the left of {.')
-          end
-        end
-
         def check_inside(node, left_brace, right_brace)
           sb = node.loc.expression.source_buffer
 
           if left_brace.end_pos == right_brace.begin_pos
             if style_for_empty_braces == :space
-              offence(sb, left_brace.begin_pos, right_brace.end_pos,
+              offense(sb, left_brace.begin_pos, right_brace.end_pos,
                       'Space missing inside empty braces.')
             end
           else
@@ -54,7 +45,7 @@ module Rubocop
               if inner =~ /\S/
                 braces_with_contents_inside(node, inner, sb)
               elsif style_for_empty_braces == :no_space
-                offence(sb, range.begin_pos, range.end_pos,
+                offense(sb, range.begin_pos, range.end_pos,
                         'Space inside empty braces detected.')
               end
             end
@@ -84,7 +75,7 @@ module Rubocop
           if pipe
             if left_brace.end_pos == pipe.begin_pos &&
                 cop_config['SpaceBeforeBlockParameters']
-              offence(sb, left_brace.begin_pos, pipe.end_pos,
+              offense(sb, left_brace.begin_pos, pipe.end_pos,
                       'Space between { and | missing.')
             end
           else
@@ -99,7 +90,7 @@ module Rubocop
         def space_inside_left_brace(left_brace, pipe, sb)
           if pipe
             unless cop_config['SpaceBeforeBlockParameters']
-              offence(sb, left_brace.end_pos, pipe.begin_pos,
+              offense(sb, left_brace.end_pos, pipe.begin_pos,
                       'Space between { and | detected.')
             end
           else
@@ -116,24 +107,24 @@ module Rubocop
         end
 
         def no_space(sb, begin_pos, end_pos, msg)
-          if style == :space_inside_braces
-            offence(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+          if style == :space
+            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
           else
             correct_style_detected
           end
         end
 
         def space(sb, begin_pos, end_pos, msg)
-          if style == :no_space_inside_braces
-            offence(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+          if style == :no_space
+            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
           else
             correct_style_detected
           end
         end
 
-        def offence(sb, begin_pos, end_pos, msg)
+        def offense(sb, begin_pos, end_pos, msg)
           range = Parser::Source::Range.new(sb, begin_pos, end_pos)
-          add_offence(range, range, msg) { yield if block_given? }
+          add_offense(range, range, msg) { yield if block_given? }
         end
 
         def style_for_empty_braces

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

@@ -28,7 +28,7 @@ module Rubocop
         private
 
         def check(t1, t2)
-          # No offence if line break inside.
+          # No offense if line break inside.
           return if t1.pos.line < t2.pos.line
 
           is_empty_braces = t1.text == '{' && t2.text == '}'
@@ -37,10 +37,10 @@ module Rubocop
                          else
                            style == :space
                          end
-          if offence?(t1, t2, expect_space)
+          if offense?(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,
+            add_offense(range, range, message(brace, is_empty_braces,
                                               expect_space)) do
               opposite_style_detected
             end
@@ -49,7 +49,7 @@ module Rubocop
           end
         end
 
-        def offence?(t1, t2, expect_space)
+        def offense?(t1, t2, expect_space)
           has_space = space_between?(t1, t2)
           expect_space ? !has_space : has_space
         end
@@ -61,15 +61,22 @@ module Rubocop
                           brace.source
                         end
           problem = expect_space ? 'missing' : 'detected'
-          sprintf(MSG, "#{inside_what} #{problem}")
+          format(MSG, "#{inside_what} #{problem}")
         end
 
         def autocorrect(range)
           @corrections << lambda do |corrector|
+            # It is possible that BracesAroundHashParameters will remove the
+            # braces while this cop inserts spaces. This can lead to unwanted
+            # changes to the inspected code.  If we replace the brace with a
+            # brace plus space (rather than just inserting a space), then any
+            # removal of the same brace will give us a clobbering error. This
+            # in turn will make RuboCop fall back on cop-by-cop
+            # auto-correction.  Problem solved.
             case range.source
             when /\s/ then corrector.remove(range)
-            when '{' then corrector.insert_after(range, ' ')
-            else corrector.insert_before(range, ' ')
+            when '{' then corrector.replace(range, '{ ')
+            else corrector.replace(range, ' }')
             end
           end
         end