rubocop 0.21.0 → 0.22.0

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

@@ -24,10 +24,8 @@ module Rubocop
 
         def check(node, method_name, _args, _body)
           prefix_blacklist.each do |prefix|
-            if method_name.to_s.start_with?(prefix)
-              add_offense(node, :name,
-                          message(method_name.to_s, prefix))
-            end
+            next unless method_name.to_s.start_with?(prefix)
+            add_offense(node, :name, message(method_name.to_s, prefix))
           end
         end
 

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

@@ -92,14 +92,13 @@ module Rubocop
 
         def on_send(node)
           receiver, method_name, *_args = *node
-          if receiver && receiver.type == :self
-            unless operator?(method_name) || keyword?(method_name) ||
-                constant_name?(method_name) ||
-                @allowed_send_nodes.include?(node) ||
-                @local_variables.include?(method_name)
-              add_offense(node, :expression)
-            end
-          end
+          return unless receiver && receiver.type == :self
+          return if operator?(method_name) || keyword?(method_name) ||
+            constant_name?(method_name) ||
+            @allowed_send_nodes.include?(node) ||
+            @local_variables.include?(method_name)
+
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)
@@ -134,10 +133,10 @@ module Rubocop
         end
 
         def allow_self(node)
-          if node.type == :send
-            receiver, _method_name, *_args = *node
-            @allowed_send_nodes << node if receiver && receiver.type == :self
-          end
+          return unless node.type == :send
+
+          receiver, _method_name, *_args = *node
+          @allowed_send_nodes << node if receiver && receiver.type == :self
         end
       end
     end

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

@@ -15,6 +15,7 @@ module Rubocop
       class SelfAssignment < Cop
         include AST::Sexp
 
+        MSG = 'Use self-assignment shorthand `%s=`.'
         OPS = [:+, :-, :*, :**, :/, :|, :&]
 
         def on_lvasgn(node)
@@ -29,9 +30,10 @@ module Rubocop
           check(node, :cvar)
         end
 
+        private
+
         def check(node, var_type)
           var_name, rhs = *node
-
           return unless rhs
 
           if rhs.type == :send
@@ -43,29 +45,22 @@ module Rubocop
 
         def check_send_node(node, rhs, var_name, var_type)
           receiver, method_name, *_args = *rhs
-
           return unless OPS.include?(method_name)
 
           target_node = s(var_type, var_name)
+          return unless receiver == target_node
 
-          if receiver == target_node
-            add_offense(node,
-                        :expression,
-                        "Use self-assignment shorthand `#{method_name}=`.")
-          end
+          add_offense(node, :expression, format(MSG, method_name))
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
           first_operand, _second_operand = *rhs
 
           target_node = s(var_type, var_name)
+          return unless first_operand == target_node
 
-          if first_operand == target_node
-            operator = rhs.loc.operator.source
-            add_offense(node,
-                        :expression,
-                        "Use self-assignment shorthand `#{operator}=`.")
-          end
+          operator = rhs.loc.operator.source
+          add_offense(node, :expression, format(MSG, operator))
         end
       end
     end

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

@@ -16,25 +16,23 @@ module Rubocop
         end
 
         def on_begin(node)
-          unless cop_config['AllowAsExpressionSeparator']
-            exprs = node.children
+          return if cop_config['AllowAsExpressionSeparator']
+          exprs = node.children
 
-            return if exprs.size < 2
+          return if exprs.size < 2
 
-            # create a map matching lines to the number of expressions on them
-            exprs_lines = exprs.map { |e| e.loc.expression.line }
-            lines = exprs_lines.group_by { |i| i }
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map { |e| e.loc.expression.line }
+          lines = exprs_lines.group_by { |i| i }
 
-            # every line with more than 1 expression on it is an offense
-            lines.each do |line, expr_on_line|
-              if expr_on_line.size > 1
-                # TODO: Find the correct position of the semicolon. We don't
-                # know if the first semicolon on the line is a separator of
-                # expressions. It's just a guess.
-                column = @processed_source[line - 1].index(';')
-                convention_on(line, column, !:last_on_line)
-              end
-            end
+          # every line with more than 1 expression on it is an offense
+          lines.each do |line, expr_on_line|
+            next unless expr_on_line.size > 1
+            # TODO: Find the correct position of the semicolon. We don't know
+            # if the first semicolon on the line is a separator of
+            # expressions. It's just a guess.
+            column = @processed_source[line - 1].index(';')
+            convention_on(line, column, !:last_on_line)
           end
         end
 
@@ -46,9 +44,8 @@ module Rubocop
           end
 
           tokens_for_lines.each do |line, tokens|
-            if tokens.last.type == :tSEMI
-              convention_on(line, tokens.last.pos.column, :last_on_line)
-            end
+            next unless tokens.last.type == :tSEMI
+            convention_on(line, tokens.last.pos.column, :last_on_line)
           end
         end
 

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

@@ -11,15 +11,14 @@ module Rubocop
         RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
         def on_rescue(node)
-          if style == :semantic
-            begin_node, *rescue_nodes, _else_node = *node
+          return unless style == :semantic
 
-            check_for(:raise, begin_node)
+          begin_node, *rescue_nodes, _else_node = *node
+          check_for(:raise, begin_node)
 
-            rescue_nodes.each do |rescue_node|
-              check_for(:fail, rescue_node)
-              allow(:raise, rescue_node)
-            end
+          rescue_nodes.each do |rescue_node|
+            check_for(:fail, rescue_node)
+            allow(:raise, rescue_node)
           end
         end
 
@@ -65,10 +64,10 @@ module Rubocop
 
           if style == :semantic
             each_command(method_name, node) do |send_node|
-              unless ignored_node?(send_node)
-                add_offense(send_node, :selector, message(method_name))
-                ignore_node(send_node)
-              end
+              next if ignored_node?(send_node)
+
+              add_offense(send_node, :selector, message(method_name))
+              ignore_node(send_node)
             end
           else
             _receiver, selector, _args = *node

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

@@ -24,10 +24,9 @@ module Rubocop
           args = *args_node
 
           return true unless args.all? { |n| n.type == :arg }
+          return if args_match?(method_name, args)
 
-          unless args_match?(method_name, args)
-            add_offense(args_node, :expression, message(method_name))
-          end
+          add_offense(args_node, :expression, message(method_name))
         end
 
         private

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

@@ -21,11 +21,10 @@ module Rubocop
           end_line = node.loc.end.line
 
           empty_body = body.nil?
+          return unless start_line == end_line && !(allow_empty? && empty_body)
 
-          if start_line == end_line && !(allow_empty? && empty_body)
-            @body = body
-            add_offense(node, :expression)
-          end
+          @body = body
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)

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

@@ -11,18 +11,18 @@ module Rubocop
 
         def on_pair(node)
           oper = node.loc.operator
-          if oper.is?(':') && oper.source_buffer.source[oper.end_pos] =~ /\S/
-            add_offense(oper, oper)
-          end
+          return unless oper.is?(':') &&
+            oper.source_buffer.source[oper.end_pos] =~ /\S/
+
+          add_offense(oper, oper)
         end
 
         def on_if(node)
-          if ternary_op?(node)
-            colon = node.loc.colon
-            if colon.source_buffer.source[colon.end_pos] =~ /\S/
-              add_offense(colon, colon)
-            end
-          end
+          return unless ternary_op?(node)
+          colon = node.loc.colon
+          return unless colon.source_buffer.source[colon.end_pos] =~ /\S/
+
+          add_offense(colon, colon)
         end
 
         def autocorrect(range)

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

@@ -15,9 +15,9 @@ module Rubocop
           exp = node.loc.expression
           kw = node.loc.keyword
           kw_offset = kw.begin_pos - exp.begin_pos
-          if exp.source[kw_offset..-1].start_with?(kw.source + '(')
-            add_offense(node, kw)
-          end
+          return unless exp.source[kw_offset..-1].start_with?(kw.source + '(')
+
+          add_offense(node, kw)
         end
 
         KEYWORDS.each do |keyword|

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

@@ -24,9 +24,9 @@ module Rubocop
           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/
-            add_offense(pos_before_left_paren, pos_before_left_paren)
-          end
+          return unless pos_before_left_paren.source =~ /\s/
+
+          add_offense(pos_before_left_paren, pos_before_left_paren)
         end
 
         def autocorrect(pos_before_left_paren)

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

@@ -18,11 +18,10 @@ module Rubocop
           _receiver, method_name, *_args = *node
 
           return unless method_name == :!
+          return unless node.loc.expression.source =~ /^!\s+\w+/
 
-          if node.loc.expression.source =~ /^!\s+\w+/
-            # TODO: Improve source range to highlight the redundant whitespace.
-            add_offense(node, :selector)
-          end
+          # TODO: Improve source range to highlight the redundant whitespace.
+          add_offense(node, :selector)
         end
 
         def autocorrect(node)

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

@@ -15,10 +15,10 @@ module Rubocop
         end
 
         def on_if(node)
-          if node.loc.respond_to?(:question)
-            check_operator(node.loc.question)
-            check_operator(node.loc.colon)
-          end
+          return unless node.loc.respond_to?(:question)
+
+          check_operator(node.loc.question)
+          check_operator(node.loc.colon)
         end
 
         def on_resbody(node)
@@ -42,6 +42,7 @@ module Rubocop
 
         def unary_operation?(node)
           whole, selector = node.loc.expression, node.loc.selector
+          return unless selector
           operator?(selector) && whole.begin_pos == selector.begin_pos
         end
 

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for missing space between a token and a comment on the
+      # same line.
+      class SpaceBeforeComment < Cop
+        MSG = 'Put a space before an end-of-line comment.'
+
+        def investigate(processed_source)
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            next unless t2.type == :tCOMMENT
+            next unless t1.pos.line == t2.pos.line
+            add_offense(t2.pos, t2.pos) if t1.pos.end == t2.pos.begin
+          end
+        end
+
+        private
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(range, ' ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,14 +8,13 @@ module Rubocop
         MSG = 'Put a space before the modifier keyword.'
 
         def on_if(node)
-          if modifier?(node)
-            kw = node.loc.keyword
-            b = kw.begin_pos
-            left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
-            add_offense(node, left_of_kw) unless left_of_kw.is?(' ')
-          end
-        end
+          return unless modifier?(node)
 
+          kw = node.loc.keyword
+          b = kw.begin_pos
+          left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
+          add_offense(node, left_of_kw) unless left_of_kw.is?(' ')
+        end
         alias_method :on_while, :on_if
         alias_method :on_until, :on_if
 

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

@@ -14,9 +14,8 @@ module Rubocop
 
         def on_array(node)
           # %i and %I were introduced in Ruby 2.0
-          unless RUBY_VERSION < '2.0.0'
-            add_offense(node, :expression) if array_of?(:sym, node)
-          end
+          return if RUBY_VERSION < '2.0.0'
+          add_offense(node, :expression) if array_of?(:sym, node)
         end
       end
     end

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

@@ -10,14 +10,14 @@ module Rubocop
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             match = line.match(/^( *)\t/)
-            if match
-              spaces = match.captures[0]
-              add_offense(nil,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index],
-                                       spaces.length, 1),
-                          MSG)
-            end
+            next unless match
+
+            spaces = match.captures[0]
+            add_offense(nil,
+                        source_range(processed_source.buffer,
+                                     processed_source[0...index],
+                                     spaces.length, 1),
+                        MSG)
           end
         end
       end

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

@@ -16,16 +16,16 @@ module Rubocop
           blank_lines = whitespace_at_end.count("\n") - 1
           wanted_blank_lines = style == :final_newline ? 0 : 1
 
-          if blank_lines != wanted_blank_lines
-            begin_pos = sb.source.length - whitespace_at_end.length
-            autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
-                                                          sb.source.length)
-            begin_pos += "\n".length unless whitespace_at_end.length == 0
-            report_range = Parser::Source::Range.new(sb, begin_pos,
-                                                     sb.source.length)
-            add_offense(autocorrect_range, report_range,
-                        message(wanted_blank_lines, blank_lines))
-          end
+          return unless blank_lines != wanted_blank_lines
+
+          begin_pos = sb.source.length - whitespace_at_end.length
+          autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
+                                                        sb.source.length)
+          begin_pos += "\n".length unless whitespace_at_end.length == 0
+          report_range = Parser::Source::Range.new(sb, begin_pos,
+                                                   sb.source.length)
+          add_offense(autocorrect_range, report_range,
+                      message(wanted_blank_lines, blank_lines))
         end
 
         private

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

@@ -9,13 +9,12 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
-            if line =~ /.*[ \t]+$/
-              range = source_range(processed_source.buffer,
-                                   processed_source[0...index],
-                                   line.rstrip.length,
-                                   line.length - line.rstrip.length)
-              add_offense(range, range)
-            end
+            next unless line =~ /.*[ \t]+$/
+            range = source_range(processed_source.buffer,
+                                 processed_source[0...index],
+                                 line.rstrip.length,
+                                 line.length - line.rstrip.length)
+            add_offense(range, range)
           end
         end