rubocop 0.29.1 → 0.30.0

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -9,6 +9,7 @@ module RuboCop
         include SafeAssignment
 
         MSG = 'Assignment in condition - you probably meant to use `==`.'
+        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send]
 
         def on_if(node)
           check(node)
@@ -29,15 +30,16 @@ module RuboCop
 
           # assignments inside blocks are not what we're looking for
           return if condition.type == :block
-
-          condition.each_node(:begin, *EQUALS_ASGN_NODES, :send) do |asgn_node|
+          traverse_node(condition, ASGN_TYPES) do |asgn_node|
             if asgn_node.type == :send
               _receiver, method_name, *_args = *asgn_node
-              return if method_name != :[]=
+              next :skip_children if method_name != :[]=
             end
 
             # skip safe assignment nodes if safe assignment is allowed
-            return if safe_assignment_allowed? && safe_assignment?(asgn_node)
+            if safe_assignment_allowed? && safe_assignment?(asgn_node)
+              next :skip_children
+            end
 
             # assignment nodes from shorthand ops like ||= don't have operator
             if asgn_node.type != :begin && asgn_node.loc.operator
@@ -45,6 +47,16 @@ module RuboCop
             end
           end
         end
+
+        # each_node/visit_descendants_with_types with :skip_children
+        def traverse_node(node, types, &block)
+          result = yield node if types.include?(node.type)
+          # return to skip all descendant nodes
+          return if result == :skip_children
+          node.children.each do |child|
+            traverse_node(child, types, &block) if child.is_a?(Astrolabe::Node)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -16,24 +16,19 @@ module RuboCop
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d%s'
 
-        def initialize(config = nil, options = nil)
-          super
-          @inspected_blocks = []
-        end
-
         def on_block(node)
-          return if already_processed_node?(node)
+          return if ignored_node?(node)
           check_block_alignment(node, node)
         end
 
         def on_and(node)
-          return if already_processed_node?(node)
+          return if ignored_node?(node)
 
           _left, right = *node
           return unless right.type == :block
 
           check_block_alignment(node, right)
-          @inspected_blocks << right
+          ignore_node(right)
         end
 
         alias_method :on_or, :on_and
@@ -74,9 +69,9 @@ module RuboCop
                                                                 block_node)
             return
           end
-          return if already_processed_node?(block_node)
+          return if ignored_node?(block_node)
 
-          @inspected_blocks << block_node
+          ignore_node(block_node)
           check_block_alignment(begin_node, block_node)
         end
 
@@ -140,10 +135,6 @@ module RuboCop
         def message
         end
 
-        def already_processed_node?(node)
-          @inspected_blocks.include?(node)
-        end
-
         def block_is_on_next_line?(begin_node, block_node)
           begin_node.loc.line != block_node.loc.line
         end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -19,7 +19,7 @@ module RuboCop
             final_node = begin_node.children.last
             next unless final_node
             # handle strings like __FILE__
-            return if special_string?(final_node)
+            next if special_string?(final_node)
             next unless LITERALS.include?(final_node.type)
 
             add_offense(final_node, :expression)

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for non-local exit from iterator, without return value.
+      # It warns only when satisfies all of these: `return` doesn't have return
+      # value, block followed by method chain, and block have arguments.
+      #
+      # @example
+      #
+      #   class ItemApi
+      #     rescue_from ValidationError do |e| # non-iteration block with arg
+      #       return message: 'validation error' unless e.errors # allowd
+      #       error_array = e.errors.map do |error| # block with method chain
+      #         return if error.suppress? # warned
+      #         return "#{error.param}: invalid" unless error.message # allowed
+      #         "#{error.param}: #{error.message}"
+      #       end
+      #       message: 'validation error', errors: error_array
+      #     end
+      #
+      #     def update_items
+      #       transaction do # block without arguments
+      #         return unless update_necessary? # allowed
+      #         find_each do |item| # block without method chain
+      #           return if item.stock == 0 # false-negative...
+      #           item.update!(foobar: true)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NonLocalExitFromIterator < Cop
+        MSG = 'Non-local exit from iterator, without return value. ' \
+          '`next`, `break`, `Array#find`, `Array#any?`, etc. is preferred.'
+
+        def on_return(return_node)
+          return if return_value?(return_node)
+          return_node.each_ancestor(:block) do |block_node|
+            send_node, args_node, _body_node = *block_node
+            next if args_node.children.empty?
+            if chained_send?(send_node)
+              add_offense(return_node, :keyword)
+              break
+            end
+          end
+        end
+
+        def return_value?(return_node)
+          !return_node.children.empty?
+        end
+
+        def chained_send?(send_node)
+          receiver_node, _selector_node = *send_node
+          !receiver_node.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/void.rb

@@ -13,9 +13,19 @@ module RuboCop
         OPS = %w(* / % + - == === != < > <= >= <=>)
         VARS = [:ivar, :lvar, :cvar, :const]
         LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
+                    :hash, :regexp, :nil, :true, :false, :sym]
 
         def on_begin(node)
+          check_begin(node)
+        end
+
+        def on_kwbegin(node)
+          check_begin(node)
+        end
+
+        private
+
+        def check_begin(node)
           expressions = *node
 
           expressions.drop_last(1).each do |expr|
@@ -25,8 +35,6 @@ module RuboCop
           end
         end
 
-        private
-
         def check_for_void_op(node)
           return unless node.type == :send
           return unless node.loc.selector

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -15,6 +15,23 @@ module RuboCop
         return if modifier_if?(node) || ternary_op?(node)
         on_normal_if_unless(node)
       end
+
+      def if_else_clause(node)
+        return unless node.if_type?
+
+        keyword = node.loc.keyword
+        if keyword.is?('if')
+          node.children.last
+        elsif keyword.is?('elsif')
+          node.children.last
+        elsif keyword.is?('unless')
+          node.children[1]
+        end
+      end
+
+      def case_else_clause(node)
+        node.children.last if node.case_type?
+      end
     end
   end
 end

data/lib/rubocop/cop/performance/detect.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of
+      # `select.first`, `select.last`, `find_all.first`, and `find_all.last`
+      # and change them to use `detect` instead.
+      #
+      # @example
+      #   # bad
+      #   [].select { |item| true }.first
+      #   [].select { |item| true }.last
+      #   [].find_all { |item| true }.first
+      #   [].find_all { |item| true }.last
+      #
+      #   # good
+      #   [].detect { |item| true }
+      #   [].reverse.detect { |item| true }
+      class Detect < Cop
+        MSG = 'Use `%s` instead of `%s.%s`.'
+        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'
+
+        SELECT_METHODS = [:select, :find_all]
+
+        def on_send(node)
+          receiver, second_method = *node
+          return unless second_method == :first || second_method == :last
+          return if receiver.nil?
+
+          receiver, _args, _body = *receiver if receiver.block_type?
+
+          _, first_method = *receiver
+          return unless SELECT_METHODS.include?(first_method)
+
+          range = receiver.loc.selector.join(node.loc.selector)
+
+          message = second_method == :last ? REVERSE_MSG : MSG
+          add_offense(node, range, format(message,
+                                          preferred_method,
+                                          first_method,
+                                          second_method))
+        end
+
+        def autocorrect(node)
+          receiver, first_method = *node
+
+          replacement = if first_method == :last
+                          "reverse.#{preferred_method}"
+                        else
+                          preferred_method
+                        end
+          first_range = node.loc.dot.join(node.loc.selector)
+
+          receiver, _args, _body = *receiver if receiver.block_type?
+
+          @corrections << lambda do |corrector|
+            corrector.remove(first_range)
+            corrector.replace(receiver.loc.selector, replacement)
+          end
+        end
+
+        private
+
+        def preferred_method
+          config.for_cop('Style/CollectionMethods') \
+            ['PreferredMethods']['detect'] || 'detect'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/flat_map.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
+      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
+      #
+      #   # good
+      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
+      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
+      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
+      class FlatMap < Cop
+        MSG = 'Use `flat_map` instead of `%s...%s`.'
+        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
+                                  'and `flatten` can be used to flatten ' \
+                                  'multiple levels'
+        FLATTEN = [:flatten, :flatten!]
+
+        def on_send(node)
+          left, second_method, flatten_param  = *node
+          return unless FLATTEN.include?(second_method)
+          flatten_level, = *flatten_param
+          expression, = *left
+          _array, first_method = *expression
+          return unless first_method == :map || first_method == :collect
+
+          message = MSG
+          if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
+            message = MSG + FLATTEN_MULTIPLE_LEVELS
+          else
+            return unless flatten_level == 1
+          end
+
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            expression.loc.selector.begin_pos,
+                                            node.loc.selector.end_pos)
+
+          add_offense(node, range, format(message, first_method, second_method))
+        end
+
+        def autocorrect(node)
+          receiver, _flatten, flatten_param  = *node
+          flatten_level, = *flatten_param
+          return if flatten_level.nil?
+          array, = *receiver
+
+          @corrections << lambda do |corrector|
+            range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                              node.loc.dot.begin_pos,
+                                              node.loc.expression.end_pos)
+
+            corrector.remove(range)
+            corrector.replace(array.loc.selector, 'flat_map')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/reverse_each.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `reverse.each` and
+      # change them to use `reverse_each` instead.
+      #
+      # @example
+      #   # bad
+      #   [].reverse.each
+      #
+      #   # good
+      #   [].reverse_each
+      class ReverseEach < Cop
+        MSG = 'Use `reverse_each` instead of `reverse.each`.'
+
+        def on_send(node)
+          receiver, second_method = *node
+          return unless second_method == :each
+          return if receiver.nil?
+          _, first_method = *receiver
+          return unless first_method == :reverse
+
+          source_buffer = node.loc.expression.source_buffer
+          location_of_reverse = receiver.loc.selector.begin_pos
+          end_location = node.loc.selector.end_pos
+
+          range = Parser::Source::Range.new(source_buffer,
+                                            location_of_reverse,
+                                            end_location)
+          add_offense(node, range, MSG)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.dot, '_')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/sample.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `shuffle.first` and
+      # change them to use `sample` instead.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].shuffle.first
+      #   [1, 2, 3].shuffle.last
+      #   [1, 2, 3].shuffle[0]
+      #
+      #   # good
+      #   [1, 2, 3].sample
+      class Sample < Cop
+        MSG = 'Use `sample` instead of `shuffle.%s`.'
+        MSG_SELECTOR = 'Use `sample` instead of `shuffle[%s]`.'
+        ARRAY_SELECTORS = [:first, :last, :[]]
+
+        def on_send(node)
+          receiver, second_method, selector = *node
+          return unless ARRAY_SELECTORS.include?(second_method)
+          return if receiver.nil?
+          _array, first_method = *receiver
+          return unless first_method == :shuffle
+
+          begin_of_offense = receiver.loc.selector.begin_pos
+          end_of_offense = node.loc.selector.end_pos
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            begin_of_offense,
+                                            end_of_offense)
+
+          message = if second_method == :[]
+                      format(MSG_SELECTOR, selector.loc.expression.source)
+                    else
+                      format(MSG, second_method)
+                    end
+
+          add_offense(node, range, message)
+        end
+
+        def autocorrect(node)
+          receiver, = *node
+          location_of_shuffle = receiver.loc.selector.begin_pos
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            location_of_shuffle,
+                                            node.loc.selector.end_pos)
+
+          @corrections << lambda do |corrector|
+            corrector.replace(range, 'sample')
+          end
+        end
+      end
+    end
+  end
+end