rubocop 0.15.0 → 0.16.0

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

@@ -5,6 +5,8 @@ module Rubocop
     module Style
       # This cop checks for uses of `fail` and `raise`.
       class SignalException < Cop
+        include ConfigurableEnforcedStyle
+
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
         RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
@@ -22,9 +24,9 @@ module Rubocop
           case style
           when :semantic
             check_for(:raise, node) unless ignored_node?(node)
-          when :raise
+          when :only_raise
             check_for(:raise, node)
-          when :fail
+          when :only_fail
             check_for(:fail, node)
           end
         end
@@ -34,8 +36,8 @@ module Rubocop
             name =
               case style
               when :semantic then command?(:raise, node) ? 'fail' : 'raise'
-              when :raise then 'raise'
-              when :fail then 'fail'
+              when :only_raise then 'raise'
+              when :only_fail then 'fail'
               end
 
             corrector.replace(node.loc.selector, name)
@@ -44,22 +46,13 @@ module Rubocop
 
         private
 
-        def style
-          case cop_config['EnforcedStyle']
-          when 'only_raise' then :raise
-          when 'only_fail' then :fail
-          when 'semantic' then :semantic
-          else fail 'Unknown style selected!'
-          end
-        end
-
         def message(method_name)
           case style
           when :semantic
             method_name == :fail ? RAISE_MSG : FAIL_MSG
-          when :raise
+          when :only_raise
             'Always use `raise` to signal exceptions.'
-          when :fail
+          when :only_fail
             'Always use `fail` to signal exceptions.'
           end
         end
@@ -70,7 +63,7 @@ module Rubocop
           if style == :semantic
             each_command(method_name, node) do |send_node|
               unless ignored_node?(send_node)
-                convention(send_node, :selector, message(method_name))
+                add_offence(send_node, :selector, message(method_name))
                 ignore_node(send_node)
               end
             end
@@ -78,7 +71,7 @@ module Rubocop
             _receiver, selector, _args = *node
 
             if [:raise, :fail].include?(selector) && selector != method_name
-              convention(node, :selector, message(method_name))
+              add_offence(node, :selector, message(method_name))
             end
           end
         end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the block parameters of a single-line
+      # method accepting a block match the names specified via configuration.
+      #
+      # For instance one can configure `reduce`(`inject`) to use |a, e| as
+      # parameters.
+      class SingleLineBlockParams < Cop
+        def on_block(node)
+          # we care only for single line blocks
+          return unless Util.block_length(node) == 0
+
+          method_node, args_node, _body_node = *node
+          receiver, method_name, _method_args = *method_node
+
+          # discard other scenarios
+          return unless receiver
+          return unless method_names.include?(method_name)
+
+          # discard cases with argument destructuring
+          args = *args_node
+
+          return true unless args.all? { |n| n.type == :arg }
+
+          unless args_match?(method_name, args)
+            add_offence(args_node, :expression, message(method_name))
+          end
+        end
+
+        private
+
+        def message(method_name)
+          args = target_args(method_name).join(', ')
+          "Name `#{method_name}` block params |#{args}|."
+        end
+
+        def methods
+          cop_config['Methods']
+        end
+
+        def method_names
+          methods.map { |e| e.keys.first.to_sym }
+        end
+
+        def target_args(method_name)
+          method_name = method_name.to_s
+          method_hash = methods.find { |m| m.keys.first == method_name }
+          method_hash[method_name]
+        end
+
+        def args_match?(method_name, args)
+          actual_args = args.flat_map { |a| a.to_a }
+
+          actual_args == target_args(method_name).map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -6,34 +6,24 @@ module Rubocop
       # This cop checks for single-line method definitions.
       # It can optionally accept single-line methods with no body.
       class SingleLineMethods < Cop
+        include CheckMethods
+
         MSG = 'Avoid single-line method definitions.'
 
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']
         end
 
-        def on_def(node)
-          check(node)
-        end
-
-        def on_defs(node)
-          check(node)
-        end
-
         private
 
-        def check(node)
+        def check(node, _method_name, _args, body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 
-          if node.type == :def
-            empty_body = node.children[2].nil?
-          else
-            empty_body = node.children[3].nil?
-          end
+          empty_body = body.nil?
 
           if start_line == end_line && !(allow_empty? && empty_body)
-            convention(node, :expression)
+            add_offence(node, :expression)
           end
         end
       end

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style
@@ -14,7 +12,7 @@ module Rubocop
           processed_source.tokens.each_cons(2) do |t1, t2|
             if kind(t1) && t1.pos.line == t2.pos.line &&
                 t2.pos.column == t1.pos.column + offset(t1)
-              convention(t1, t1.pos, sprintf(MSG, kind(t1)))
+              add_offence(t1, t1.pos, sprintf(MSG, kind(t1)))
             end
           end
         end

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 + '(')
-            convention(node, kw)
+            add_offence(node, kw)
           end
         end
 

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

@@ -5,27 +5,19 @@ module Rubocop
     module Style
       # Checks for space between a method name and a left parenthesis.
       class SpaceAfterMethodName < Cop
+        include CheckMethods
+
         MSG = 'Never put a space between a method name and the opening ' +
           'parenthesis.'
 
-        def on_def(node)
-          _method_name, args, _body = *node
-          check(args)
-        end
-
-        def on_defs(node)
-          _scope, _method_name, args, _body = *node
-          check(args)
-        end
-
-        def check(args)
+        def check(_node, _method_name, args, body)
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.loc.expression
           pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,
                                                             expr.begin_pos - 1,
                                                             expr.begin_pos)
           if pos_before_left_paren.source =~ /\s/
-            convention(pos_before_left_paren, pos_before_left_paren)
+            add_offence(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.
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
 

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

@@ -1,145 +1,156 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 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
+        include ConfigurableEnforcedStyle
         include SurroundingSpace
 
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
+        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, 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
 
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
+        def check_inside(node, left_brace, right_brace)
+          sb = node.loc.expression.source_buffer
 
-            type1, type2 = t1.type, t2.type
-            if [:tLCURLY, :tRCURLY].include?(type2)
-              check(t1, t2)
-            elsif type1 == :tLCURLY
-              if type2 == :tPIPE
-                check_pipe(t1, t2)
+          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.')
+          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
-                check(t1, t2)
+                space(style_for_empty_braces, sb, range.begin_pos,
+                      range.end_pos, 'Space inside empty braces detected.')
               end
             end
           end
         end
 
-        def positions_not_to_check
-          @positions_not_to_check ||= begin
-            positions = []
-            ast = @processed_source.ast
-            tokens = @processed_source.tokens
-
-            on_node(:hash, ast) do |hash|
-              b_ix = index_of_first_token(hash)
-              e_ix = index_of_last_token(hash)
-              positions << tokens[b_ix].pos << tokens[e_ix].pos
-            end
+        def braces_with_contents_inside(node, inner)
+          _method, args, _body = *node
+          left_brace, right_brace = node.loc.begin, node.loc.end
+          pipe = args.loc.begin
+          sb = node.loc.expression.source_buffer
 
-            # TODO: Check braces inside string/symbol/regexp/xstr
-            #   interpolation.
-            on_node([:dstr, :dsym, :regexp, :xstr], ast) do |s|
-              b_ix = index_of_first_token(s)
-              e_ix = index_of_last_token(s)
-              tokens[b_ix..e_ix].each do |t|
-                positions << t.pos if t.type == :tRCURLY
-              end
-            end
+          if inner =~ /^\S/
+            no_space_inside_left_brace(left_brace, pipe, sb)
+          else
+            space_inside_left_brace(left_brace, pipe, sb)
+          end
 
-            positions
+          if inner =~ /\S$/
+            no_space(style_for_inside_braces, sb, right_brace.begin_pos,
+                     right_brace.end_pos, 'Space missing inside }.')
+          else
+            space_inside_right_brace(right_brace, sb)
           end
         end
 
-        def check(t1, t2)
-          if t2.text == '{'
-            check_space_outside_left_brace(t1, t2)
-          elsif t1.text == '{' && t2.text == '}'
-            check_empty_braces(t1, t2)
-          elsif cop_config['EnforcedStyle'] == 'space_inside_braces'
-            check_space_inside_braces(t1, t2)
+        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.')
+            end
           else
-            check_no_space_inside_braces(t1, t2)
+            # 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 {.')
           end
         end
 
-        def check_empty_braces(t1, t2)
-          if cop_config['EnforcedStyleForEmptyBraces'] == 'space'
-            check_space_inside_braces(t1, t2)
+        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.')
           else
-            check_no_space_inside_braces(t1, t2)
+            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.')
           end
         end
 
-        def check_space_inside_braces(t1, t2)
-          unless space_between?(t1, t2)
-            token, what = problem_details(t1, t2)
-            convention(token.pos, token.pos, "Space missing inside #{what}.")
-          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.')
         end
 
-        def check_no_space_inside_braces(t1, t2)
-          if space_between?(t1, t2)
-            token, what = problem_details(t1, t2)
-            s = space_range(token)
-            convention(s, s, "Space inside #{what} detected.")
-          end
+        def no_space(specific_style, sb, begin_pos, end_pos, msg)
+          offence(sb, begin_pos, end_pos, msg) if specific_style == :space
         end
 
-        def problem_details(t1, t2)
-          if t1.text == '{'
-            token = t1
-            what = t2.text == '}' ? 'empty braces' : '{'
-          else
-            token = t2
-            what = '}'
-          end
-          [token, what]
+        def space(specific_style, sb, begin_pos, end_pos, msg)
+          offence(sb, begin_pos, end_pos, msg) if specific_style == :no_space
         end
 
-        def check_space_outside_left_brace(t1, t2)
-          if t2.text == '{' && !space_between?(t1, t2)
-            convention(t1.pos, t2.pos, 'Space missing to the left of {.')
-          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 check_pipe(t1, t2)
-          if cop_config['SpaceBeforeBlockParameters']
-            unless space_between?(t1, t2)
-              convention(t2.pos, t1.pos, 'Space between { and | missing.')
-            end
-          elsif space_between?(t1, t2)
-            s = space_range(t1)
-            convention(s, s, 'Space between { and | detected.')
-          end
+        def available_styles
+          %w(space_inside_braces no_space_inside_braces)
         end
 
-        def space_range(token)
-          src = @processed_source.buffer.source
-          if token.text == '{'
-            b = token.pos.begin_pos + 1
-            e = b + 1
-            e += 1 while src[e] =~ /\s/
-          else
-            e = token.pos.begin_pos
-            b = e - 1
-            b -= 1 while src[b - 1] =~ /\s/
+        def style_for_inside_braces
+          style == :space_inside_braces ? :space : :no_space
+        end
+
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          else fail 'Unknown EnforcedStyleForEmptyBraces selected!'
           end
-          Parser::Source::Range.new(@processed_source.buffer, b, e)
+        end
+
+        def style_for_block_parameters
+          cop_config['SpaceBeforeBlockParameters'] ? :space : :no_space
         end
 
         def autocorrect(range)
           @corrections << lambda do |corrector|
             case range.source
-            when '}', '|' then corrector.insert_before(range, ' ')
-            when ' '      then corrector.remove(range)
-            else               corrector.insert_after(range, ' ')
+            when /\s/ then corrector.remove(range)
+            when '{}' then corrector.replace(range, '{ }')
+            when '{|' then corrector.replace(range, '{ |')
+            else           corrector.insert_before(range, ' ')
             end
           end
         end