rubocop 0.30.1 → 0.31.0

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

@@ -58,7 +58,7 @@ module RuboCop
 
           receiver, _args, _body = *receiver if receiver.block_type?
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.remove(first_range)
             corrector.replace(receiver.loc.selector, replacement)
           end

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

@@ -47,9 +47,10 @@ module RuboCop
           receiver, _flatten, flatten_param  = *node
           flatten_level, = *flatten_param
           return if flatten_level.nil?
+
           array, = *receiver
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                               node.loc.dot.begin_pos,
                                               node.loc.expression.end_pos)

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # Checks for simple usages of parallel assignment.
+      # This will only complain when the number of variables
+      # being assigned matched the number of assigning variables.
+      #
+      # @example
+      #   # bad
+      #   a, b, c = 1, 2, 3
+      #   a, b, c = [1, 2, 3]
+      #
+      #   # good
+      #   one, two = *foo
+      #   a, b = foo()
+      #
+      #   a = 1
+      #   b = 2
+      #   c = 3
+      class ParallelAssignment < Cop
+        MSG = 'Do not use parallel assignment.'
+
+        def on_masgn(node)
+          left, right = *node
+          left_elements = *left
+          right_elements = [*right].compact # edge case for one constant
+
+          # only complain when the number of variables matches
+          return if left_elements.size != right_elements.size
+
+          # account for edge cases using one variable with a comma
+          return if left_elements.size == 1
+
+          # allow mass assignment as the return of a method call
+          return if right.block_type? || right.send_type?
+
+          # allow mass assignment when using splat
+          return if (left_elements + right_elements).any?(&:splat_type?)
+
+          return if variable_reassignment?(left_elements, right_elements)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          left, right = *node
+
+          lambda do |corrector|
+            l_vars = extract_sources(left)
+            r_vars = extract_sources(right)
+            groups = l_vars.zip(r_vars)
+
+            assignment = groups.map { |pair| pair.join(' = ') }
+
+            space_offset = node.loc.expression.column
+            corrector.replace(node.loc.expression,
+                              assignment.join("\n" << ' ' * space_offset))
+          end
+        end
+
+        private
+
+        def extract_sources(node)
+          node.children.map { |child| child.loc.expression.source }
+        end
+
+        def variable_reassignment?(left_elements, right_elements)
+          left_elements.any? do |le|
+            right_elements.any? do |re|
+              re.loc.expression.is?(le.loc.expression.source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,9 +33,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.dot, '_')
-          end
+          ->(corrector) { corrector.replace(node.loc.dot, '_') }
         end
       end
     end

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

@@ -15,32 +15,23 @@ module RuboCop
       #   [1, 2, 3].shuffle(random: Random.new(1))
       #
       #   # good
+      #   [1, 2, 3].shuffle
       #   [1, 2, 3].sample
       #   [1, 2, 3].sample(3)
       #   [1, 2, 3].sample(random: Random.new(1))
       class Sample < Cop
         MSG = 'Use `sample` instead of `shuffle%s`.'
         RANGE_TYPES = [:irange, :erange]
+        VALID_ARRAY_SELECTORS = [:first, :last, :[], nil]
 
         def on_send(node)
-          _receiver, method, params, = *node
-          return unless method == :shuffle
-          _receiver, _method, params, = *node.parent if params.nil?
+          _receiver, first_method, params, = *node
+          return unless first_method == :shuffle
+          _receiver, second_method, params, = *node.parent if params.nil?
+          return unless VALID_ARRAY_SELECTORS.include?(second_method)
+          return if second_method.nil? && params.nil?
 
-          message = if params && params.lvar_type?
-                      format(MSG, shuffle_params(node))
-                    elsif node.parent
-                      _params, selector = *node.parent
-                      if selector == :[]
-                        format(MSG, node.parent.loc.selector.source)
-                      else
-                        format(MSG, ".#{node.parent.loc.selector.source}")
-                      end
-                    else
-                      format(MSG, shuffle_params(node))
-                    end
-
-          add_offense(node, range_of_shuffle(node), message)
+          add_offense(node, range_of_shuffle(node), message(node, params))
         end
 
         def autocorrect(node)
@@ -57,7 +48,7 @@ module RuboCop
                                               node.parent.loc.selector.end_pos)
                   end
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(range, 'sample')
             return if selector.nil?
             corrector.insert_after(range, "(#{selector.loc.expression.source})")
@@ -66,6 +57,21 @@ module RuboCop
 
         private
 
+        def message(node, params)
+          if params && params.lvar_type?
+            format(MSG, shuffle_params(node))
+          elsif node.parent
+            _params, selector = *node.parent
+            if selector == :[]
+              format(MSG, node.parent.loc.selector.source)
+            else
+              format(MSG, ".#{node.parent.loc.selector.source}")
+            end
+          else
+            format(MSG, shuffle_params(node))
+          end
+        end
+
         def range_of_shuffle(node)
           Parser::Source::Range.new(node.loc.expression.source_buffer,
                                     node.loc.selector.begin_pos,
@@ -76,6 +82,7 @@ module RuboCop
           params = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                              node.loc.selector.end_pos,
                                              node.loc.expression.end_pos)
+
           params.source
         end
       end

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

@@ -38,9 +38,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.selector, 'size')
-          end
+          ->(corrector) { corrector.replace(node.loc.selector, 'size') }
         end
 
         private

data/lib/rubocop/cop/rails/action_filter.rb

@@ -31,7 +31,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.selector,
                               preferred_method(node.loc.selector.source).to_s)
           end

data/lib/rubocop/cop/rails/delegate.rb

@@ -41,17 +41,14 @@ module RuboCop
         private
 
         def autocorrect(node)
-          method_name, args, body = *node
-          return unless trivial_delegate?(method_name, args, body)
-          return if private_or_protected_delegation(node)
-
+          method_name, _args, body = *node
           delegation = ["delegate :#{body.children[1]}",
                         "to: :#{body.children[0].children[1]}"]
           if method_name == prefixed_method_name(body)
             delegation << ['prefix: true']
           end
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.expression, delegation.join(', '))
           end
         end

data/lib/rubocop/cop/rails/find_by.rb

@@ -41,7 +41,7 @@ module RuboCop
             node.loc.selector.end_pos
           )
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(where_loc, 'find_by')
             corrector.replace(first_loc, '')
           end

data/lib/rubocop/cop/rails/find_each.rb

@@ -31,9 +31,7 @@ module RuboCop
         def autocorrect(node)
           each_loc = node.loc.selector
 
-          @corrections << lambda do |corrector|
-            corrector.replace(each_loc, 'find_each')
-          end
+          ->(corrector) { corrector.replace(each_loc, 'find_each') }
         end
       end
     end

data/lib/rubocop/cop/rails/read_write_attribute.rb

@@ -47,9 +47,7 @@ module RuboCop
             replacement = write_attribute_replacement(node)
           end
 
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
+          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
         end
 
         private

data/lib/rubocop/cop/rails/time_zone.rb

@@ -31,6 +31,8 @@ module RuboCop
 
         MSG = 'Do not use `%s` without zone. Use `%s` instead.'
 
+        MSG_ACCEPTABLE = 'Do not use `%s` without zone. Use one of %s instead.'
+
         MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
 
         TIMECLASS = [:Time, :DateTime]
@@ -58,13 +60,29 @@ module RuboCop
           return check_localtime(node) if need_check_localtime?(chain)
 
           method_name = (chain & DANGER_METHODS).join('.')
-          safe_method_name = safe_method(method_name, node)
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             "#{klass}.#{method_name}",
-                             "Time.zone.#{safe_method_name}")
-                     )
+          message = build_message(klass, method_name, node)
+
+          add_offense(node, :selector, message)
+        end
+
+        def build_message(klass, method_name, node)
+          if acceptable?
+            accepted_methods = ACCEPTED_METHODS.map do |am|
+              "`#{klass}.#{method_name}.#{am}`"
+            end
+
+            format(MSG_ACCEPTABLE,
+                   "#{klass}.#{method_name}",
+                   accepted_methods.join(', ')
+                  )
+          else
+            safe_method_name = safe_method(method_name, node)
+            format(MSG,
+                   "#{klass}.#{method_name}",
+                   "#{klass}.zone.#{safe_method_name}"
+                  )
+          end
         end
 
         def extract_method_chain(node)
@@ -118,7 +136,11 @@ module RuboCop
         end
 
         def need_check_localtime?(chain)
-          (style == :acceptable) && chain.include?(:localtime)
+          acceptable? && chain.include?(:localtime)
+        end
+
+        def acceptable?
+          style == :acceptable
         end
 
         def good_methods

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

@@ -31,7 +31,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             # replace alias with alias_method
             corrector.replace(node.loc.keyword, 'alias_method')
             # insert a comma

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

@@ -19,11 +19,11 @@ module RuboCop
             {} # The first pair is always considered correct.
           end
 
-          def deltas(first_pair, prev_pair, current_pair)
-            if current_pair.loc.line == prev_pair.loc.line
-              {}
-            else
+          def deltas(first_pair, current_pair)
+            if Util.begins_its_line?(current_pair.loc.expression)
               { key: first_pair.loc.column - current_pair.loc.column }
+            else
+              {}
             end
           end
         end
@@ -35,7 +35,7 @@ module RuboCop
             !any_pairs_on_the_same_line?(node) && all_have_same_separator?(node)
           end
 
-          def deltas(first_pair, _prev_pair, current_pair)
+          def deltas(first_pair, current_pair)
             key_delta = key_delta(first_pair, current_pair)
             current_separator = current_pair.loc.operator
             separator_delta = separator_delta(first_pair, current_separator,
@@ -57,11 +57,9 @@ module RuboCop
           end
 
           def any_pairs_on_the_same_line?(node)
-            lines_of_the_children = node.children.map do |pair|
-              key, _value = *pair
-              key.loc.line
+            node.children[1..-1].any? do |pair|
+              !Util.begins_its_line?(pair.loc.expression)
             end
-            lines_of_the_children.uniq.size < lines_of_the_children.size
           end
 
           def all_have_same_separator?(node)
@@ -103,7 +101,7 @@ module RuboCop
           end
 
           def value_delta(first_pair, current_pair)
-            first_key, _ = *first_pair
+            first_key, = *first_pair
             _, current_value = *current_pair
             correct_value_column = first_key.loc.column +
                                    spaced_separator(current_pair).length +
@@ -180,9 +178,8 @@ module RuboCop
                            .deltas_for_first_pair(first_pair, node)
           add_offense(first_pair, :expression) unless good_alignment?
 
-          node.children.each_cons(2) do |prev, current|
-            @column_deltas = alignment_for(current).deltas(first_pair, prev,
-                                                           current)
+          node.children.each do |current|
+            @column_deltas = alignment_for(current).deltas(first_pair, current)
             add_offense(current, :expression) unless good_alignment?
           end
         end
@@ -233,7 +230,7 @@ module RuboCop
 
           key, value = *node
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             adjust(corrector, key_delta, key.loc.expression)
             adjust(corrector, separator_delta, node.loc.operator)
             adjust(corrector, value_delta, value.loc.expression)

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

@@ -18,6 +18,17 @@ module RuboCop
 
           add_offense(node, :selector)
         end
+
+        def autocorrect(node)
+          receiver_node, _method_name, *arg_nodes = *node
+          expr = node.loc.expression
+          array = receiver_node.loc.expression.source
+          join_arg  = arg_nodes[0].loc.expression.source
+
+          lambda do |corrector|
+            corrector.replace(expr, "#{array}.join(#{join_arg})")
+          end
+        end
       end
     end
   end

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

@@ -14,9 +14,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.selector, 'attr_reader')
-          end
+          ->(corrector) { corrector.replace(node.loc.selector, 'attr_reader') }
         end
       end
     end

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

@@ -36,7 +36,7 @@ module RuboCop
         def autocorrect(node)
           src = node.loc.begin.source
           replacement = src.start_with?('%Q') ? '%' : '%Q'
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
           end
         end

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

@@ -18,7 +18,7 @@ module RuboCop
         def autocorrect(comment)
           eq_begin, eq_end, contents = parts(comment)
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.remove(eq_begin)
             unless contents.length == 0
               corrector.replace(contents,