rubocop 0.21.0 → 0.22.0

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

@@ -19,15 +19,14 @@ module Rubocop
           #   ...)
           block_method, = *node
 
-          if block_method == TARGET
-            selector = block_method.loc.selector.source
-            lambda_length = lambda_length(node)
-
-            if selector != '->' && lambda_length == 0
-              add_offense(block_method, :expression, SINGLE_MSG)
-            elsif selector == '->' && lambda_length > 0
-              add_offense(block_method, :expression, MULTI_MSG)
-            end
+          return unless block_method == TARGET
+          selector = block_method.loc.selector.source
+          lambda_length = lambda_length(node)
+
+          if selector != '->' && lambda_length == 0
+            add_offense(block_method, :expression, SINGLE_MSG)
+          elsif selector == '->' && lambda_length > 0
+            add_offense(block_method, :expression, MULTI_MSG)
           end
         end
 

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

@@ -12,11 +12,10 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            if comment.text =~ /^#+[^#\s:+-]/
-              unless comment.text.start_with?('#!') && comment.loc.line == 1
-                add_offense(comment, :expression)
-              end
-            end
+            next unless comment.text =~ /^#+[^#\s:+-]/
+            next if comment.text.start_with?('#!') && comment.loc.line == 1
+
+            add_offense(comment, :expression)
           end
         end
 

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

@@ -20,7 +20,7 @@ module Rubocop
       #              'bala'
       #
       class LineEndConcatenation < Cop
-        MSG = 'Use \\ instead of + or << to concatenate those strings.'
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
 
         def on_send(node)
           add_offense(node, :selector) if offending_node?(node)
@@ -35,15 +35,18 @@ module Rubocop
 
         private
 
+        def concat?(method)
+          [:+, :<<].include?(method)
+        end
+
         def offending_node?(node)
-          receiver, method, arg = *node
+          receiver, method, first_arg = *node
 
-          # TODO: Report Emacs bug.
-          return false unless [:+, :<<].include?(method)
+          return false unless concat?(method)
 
-          return false unless string_type?(receiver)
+          return false unless final_node_is_string_type?(receiver)
 
-          return false unless string_type?(arg)
+          return false unless root_node_is_string_type?(first_arg)
 
           expression = node.loc.expression.source
           concatenator_at_line_end?(expression)
@@ -56,10 +59,30 @@ module Rubocop
 
         def string_type?(node)
           return false unless [:str, :dstr].include?(node.type)
+          # strings like __FILE__ are of no interest
+          return false unless node.loc.respond_to?(:begin)
 
           # we care only about quotes-delimited literals
           node.loc.begin && ["'", '"'].include?(node.loc.begin.source)
         end
+
+        def final_node_is_string_type?(node)
+          if node.type == :send
+            _, method, first_arg = *node
+            concat?(method) && final_node_is_string_type?(first_arg)
+          else
+            string_type?(node)
+          end
+        end
+
+        def root_node_is_string_type?(node)
+          if node.type == :send
+            receiver, method, _ = *node
+            concat?(method) && root_node_is_string_type?(receiver)
+          else
+            string_type?(node)
+          end
+        end
       end
     end
   end

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

@@ -12,15 +12,15 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
-            if line.length > max
-              message = format(MSG, line.length, max)
-              add_offense(nil,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index], max,
-                                       line.length - max),
-                          message) do
-                self.max = line.length
-              end
+            next unless line.length > max
+
+            message = format(MSG, line.length, max)
+            add_offense(nil,
+                        source_range(processed_source.buffer,
+                                     processed_source[0...index], max,
+                                     line.length - max),
+                        message) do
+              self.max = line.length
             end
           end
         end

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

@@ -28,12 +28,13 @@ module Rubocop
         def on_send(node)
           return if ignored_node?(node)
           receiver, _method_name, *_args = *node
-          if receiver && receiver.type == :block && receiver.loc.end.is?('end')
-            range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
-                                              receiver.loc.end.begin_pos,
-                                              node.loc.expression.end_pos)
-            add_offense(nil, range)
-          end
+          return unless receiver && receiver.type == :block &&
+            receiver.loc.end.is?('end')
+
+          range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
+                                            receiver.loc.end.begin_pos,
+                                            node.loc.expression.end_pos)
+          add_offense(nil, range)
         end
       end
     end

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

@@ -19,11 +19,10 @@ module Rubocop
 
         def on_module(node)
           _name, body = *node
+          return unless body && body.type == :begin
 
-          if body && body.type == :begin
-            body.children.each do |body_node|
-              add_offense(body_node, :expression) if body_node == TARGET_NODE
-            end
+          body.children.each do |body_node|
+            add_offense(body_node, :expression) if body_node == TARGET_NODE
           end
         end
       end

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

@@ -32,9 +32,9 @@ module Rubocop
             Parser::Source::Range.new(next_thing.source_buffer,
                                       end_position(condition),
                                       next_thing.begin_pos)
-          if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
-            node.loc.expression.begin.line
-          end
+          return unless right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
+
+          node.loc.expression.begin.line
         end
 
         def end_position(conditional_node)

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

@@ -30,6 +30,8 @@ module Rubocop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             condition, _body, _rest = *node
+            # look inside parentheses around the condition
+            condition = condition.children.first while condition.type == :begin
             # unwrap the negated portion of the condition (a send node)
             pos_condition, _method, = *condition
             corrector.replace(

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

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Use `next` to skip iteration instead of a condition at the end.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1 do
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      class Next < Cop
+        include IfNode
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `next` to skip iteration.'
+        METHODS = [:collect, :detect, :downto, :each, :find, :find_all,
+                   :inject, :loop, :map!, :map, :reduce, :reverse_each,
+                   :select, :times, :upto]
+
+        def on_block(node)
+          method, _, body = *node
+          return if body.nil?
+
+          _, method_name = *method
+          return unless method?(method_name)
+          return unless ends_with_condition?(body)
+
+          add_offense(method, :selector, MSG)
+        end
+
+        def on_while(node)
+          _, body = *node
+          return unless ends_with_condition?(body)
+
+          add_offense(node, :keyword, MSG)
+        end
+        alias_method :on_until, :on_while
+
+        def on_for(node)
+          _, _, body = *node
+          return unless ends_with_condition?(body)
+
+          add_offense(node, :keyword, MSG)
+        end
+
+        private
+
+        def method?(method_name)
+          METHODS.include?(method_name) || /\Aeach_/.match(method_name)
+        end
+
+        def ends_with_condition?(body)
+          return true if simple_if_without_break?(body)
+
+          body.type == :begin && simple_if_without_break?(body.children.last)
+        end
+
+        def simple_if_without_break?(body)
+          return false if ternary_op?(body)
+          return false if if_else?(body)
+          return false unless body.type == :if
+          return false if style == :skip_modifier_ifs && modifier_if?(body)
+
+          _, return_method, return_body  = *body
+          (return_method || return_body).type != :break
+        end
+      end
+    end
+  end
+end

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

@@ -21,10 +21,9 @@ module Rubocop
 
         def on_send(node)
           _receiver, method, args = *node
+          return unless OPS.include?(method)
 
-          if OPS.include?(method)
-            add_offense(node, :selector) if args == NIL_NODE
-          end
+          add_offense(node, :selector) if args == NIL_NODE
         end
 
         private

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

@@ -9,9 +9,12 @@ module Rubocop
       #
       #  # bad
       #  if x != nil
+      #
+      #  # good (when not allowing semantic changes)
+      #  # bad (when allowing semantic changes)
       #  if !x.nil?
       #
-      #  # good
+      #  # good (when allowing semantic changes)
       #  if x
       #
       # Non-nil checks are allowed if they are the final nodes of predicate.
@@ -43,13 +46,17 @@ module Rubocop
 
           if method == :!=
             add_offense(node, :selector) if args == NIL_NODE
-          elsif method == :!
+          elsif include_semantic_changes? && method == :!
             add_offense(node, :expression) if nil_check?(receiver)
           end
         end
 
         private
 
+        def include_semantic_changes?
+          cop_config['IncludeSemanticChanges']
+        end
+
         def process_method(name, body)
           # only predicate methods are handled differently
           return unless name.to_s.end_with?('?')
@@ -82,7 +89,12 @@ module Rubocop
         def autocorrect_comparison(node)
           @corrections << lambda do |corrector|
             expr = node.loc.expression
-            new_code = expr.source.sub(/\s*!=\s*nil/, '')
+            new_code =
+              if include_semantic_changes?
+                expr.source.sub(/\s*!=\s*nil/, '')
+              else
+                expr.source.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
+              end
             corrector.replace(expr, new_code)
           end
         end

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

@@ -13,10 +13,10 @@ module Rubocop
           _receiver, method_name, *args = *node
 
           # not does not take any arguments
-          if args.empty? && method_name == :! &&
-              node.loc.selector.is?('not')
-            add_offense(node, :selector)
-          end
+          return unless args.empty? && method_name == :! &&
+            node.loc.selector.is?('not')
+
+          add_offense(node, :selector)
         end
 
         private

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

@@ -33,15 +33,14 @@ module Rubocop
 
           # TODO: handle non-decimal literals as well
           return if int.start_with?('0')
+          return unless int.size >= min_digits
 
-          if int.size >= min_digits
-            case int
-            when /^\d+$/
-              add_offense(node, :expression) { self.max = int.size + 1 }
-            when /\d{4}/, /_\d{1,2}_/
-              add_offense(node, :expression) do
-                self.config_to_allow_offenses = { 'Enabled' => false }
-              end
+          case int
+          when /^\d+$/
+            add_offense(node, :expression) { self.max = int.size + 1 }
+          when /\d{4}/, /_\d{1,2}_/
+            add_offense(node, :expression) do
+              self.config_to_allow_offenses = { 'Enabled' => false }
             end
           end
         end

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

@@ -14,12 +14,10 @@ module Rubocop
 
         def on_def(node)
           name, args, _body = *node
+          return unless name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
+            args.children.size == 1 && !TARGET_ARGS.include?(args)
 
-          if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
-              args.children.size == 1 && !TARGET_ARGS.include?(args)
-            add_offense(args.children[0], :expression,
-                        format(MSG, name))
-          end
+          add_offense(args.children[0], :expression, format(MSG, name))
         end
       end
     end

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

@@ -14,10 +14,10 @@ module Rubocop
 
         def on_args(node)
           count = args_count(node)
-          if count > max_params
-            add_offense(node, :expression, format(MSG, max_params)) do
-              self.max = count
-            end
+          return unless count > max_params
+
+          add_offense(node, :expression, format(MSG, max_params)) do
+            self.max = count
           end
         end
 

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

@@ -27,13 +27,12 @@ module Rubocop
         def process_control_op(node)
           cond, _body = *node
 
-          if cond.type == :begin
-            return if parens_required?(node)
-            # allow safe assignment
-            return if safe_assignment?(cond) && safe_assignment_allowed?
+          return unless cond.type == :begin
+          return if parens_required?(node)
+          # allow safe assignment
+          return if safe_assignment?(cond) && safe_assignment_allowed?
 
-            add_offense(cond, :expression, message(node))
-          end
+          add_offense(cond, :expression, message(node))
         end
 
         def parens_required?(node)

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

@@ -61,11 +61,11 @@ module Rubocop
 
         def on_percent_literal(node, types)
           type = type(node)
-          if types.include?(type) &&
-              !uses_preferred_delimiter?(node, type) &&
-              !contains_preferred_delimiter?(node, type)
-            add_offense(node, :expression)
-          end
+          return unless types.include?(type) &&
+            !uses_preferred_delimiter?(node, type) &&
+            !contains_preferred_delimiter?(node, type)
+
+          add_offense(node, :expression)
         end
 
         def preferred_delimiters(type)