rubocop 0.60.0 → 0.61.0

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

@@ -47,11 +47,11 @@ module RuboCop
           uniqueness
         ].freeze
 
-        BLACKLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-        WHITELIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
+        DENYLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
+        ALLOWLIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
 
         def on_send(node)
-          return unless !node.receiver && BLACKLIST.include?(node.method_name)
+          return unless !node.receiver && DENYLIST.include?(node.method_name)
 
           add_offense(node, location: :selector)
         end
@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def preferred_method(method)
-          WHITELIST[BLACKLIST.index(method.to_sym)]
+          ALLOWLIST[DENYLIST.index(method.to_sym)]
         end
 
         def correct_validate_type(corrector, node)

data/lib/rubocop/cop/security/open.rb

@@ -26,24 +26,44 @@ module RuboCop
           (send nil? :open $!str ...)
         PATTERN
 
+        def on_send(node)
+          open?(node) do |code|
+            return if safe?(code)
+
+            add_offense(node, location: :selector)
+          end
+        end
+
+        private
+
         def safe?(node)
-          if node.str_type?
-            !node.str_content.empty? && !node.str_content.start_with?('|')
-          elsif node.dstr_type?
-            safe?(node.child_nodes.first)
-          elsif node.send_type? && node.method_name == :+
-            safe?(node.child_nodes.first)
+          if simple_string?(node)
+            safe_argument?(node.str_content)
+          elsif composite_string?(node)
+            safe?(node.children.first)
           else
             false
           end
         end
 
-        def on_send(node)
-          open?(node) do |code|
-            return if safe?(code)
+        def safe_argument?(argument)
+          !argument.empty? && !argument.start_with?('|')
+        end
 
-            add_offense(node, location: :selector)
-          end
+        def simple_string?(node)
+          node.str_type?
+        end
+
+        def composite_string?(node)
+          interpolated_string?(node) || concatenated_string?(node)
+        end
+
+        def interpolated_string?(node)
+          node.dstr_type?
+        end
+
+        def concatenated_string?(node)
+          node.send_type? && node.method?(:+) && node.receiver.str_type?
         end
       end
     end

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

@@ -3,7 +3,13 @@
 module RuboCop
   module Cop
     module Style
+      #
       # This cop checks for BEGIN blocks.
+      #
+      # @example
+      #   # bad
+      #   BEGIN { test }
+      #
       class BeginBlock < Cop
         MSG = 'Avoid the use of `BEGIN` blocks.'.freeze
 

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

@@ -154,7 +154,7 @@ module RuboCop
         end
 
         def right_whole_line_range(loc_end)
-          if range_by_whole_lines(loc_end).source.strip =~ /}\s*,?\z/
+          if range_by_whole_lines(loc_end).source.strip =~ /\A}\s*,?\z/
             range_by_whole_lines(loc_end, include_final_newline: true)
           else
             loc_end

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

@@ -67,8 +67,11 @@ module RuboCop
         private
 
         def correct_case_when(corrector, case_node, when_nodes)
-          remove_case_node(corrector, case_node)
-          corrector.replace(when_nodes.first.loc.keyword, 'if')
+          case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
+
+          corrector.replace(case_range, 'if')
+
+          keep_first_when_comment(case_node, when_nodes.first, corrector)
 
           when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
@@ -88,12 +91,15 @@ module RuboCop
           end
         end
 
-        def remove_case_node(corrector, case_node)
-          range = range_by_whole_lines(
-            case_node.loc.keyword, include_final_newline: true
-          )
+        def keep_first_when_comment(case_node, first_when_node, corrector)
+          comment = processed_source.comments_before_line(
+            first_when_node.loc.keyword.line
+          ).map(&:text).join("\n")
+
+          line = range_by_whole_lines(case_node.source_range)
 
-          corrector.remove(range)
+          corrector.insert_before(line, "#{comment}\n") if !comment.empty? &&
+                                                           !case_node.parent
         end
       end
     end

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

@@ -46,18 +46,6 @@ module RuboCop
         PREFER_EACH = 'Prefer `each` over `for`.'.freeze
         PREFER_FOR = 'Prefer `for` over `each`.'.freeze
 
-        def_node_matcher :deconstruct_for, <<-PATTERN
-          (for $_item $_enumerable _block)
-        PATTERN
-
-        def_node_matcher :deconstruct_each, <<-PATTERN
-          (block (send $_enumerable :each) $_ _block)
-        PATTERN
-
-        def_node_matcher :extract_variables, <<-PATTERN
-          (args $_)
-        PATTERN
-
         def on_for(node)
           if style == :each
             add_offense(node, message: PREFER_EACH) do
@@ -69,13 +57,12 @@ module RuboCop
         end
 
         def on_block(node)
-          return if node.single_line?
-
-          return unless node.send_node.method?(:each) &&
-                        !node.send_node.arguments?
+          return unless suspect_enumerable?(node)
 
           if style == :for
-            incorrect_style_detected(node)
+            add_offense(node, message: PREFER_FOR) do
+              opposite_style_detected
+            end
           else
             correct_style_detected
           end
@@ -83,73 +70,17 @@ module RuboCop
 
         def autocorrect(node)
           if style == :each
-            autocorrect_to_each(node)
+            ForToEachCorrector.new(node)
           else
-            autocorrect_to_for(node)
+            EachToForCorrector.new(node)
           end
         end
 
         private
 
-        def incorrect_style_detected(node)
-          add_offense(node, message: PREFER_FOR) do
-            opposite_style_detected
-          end
-        end
-
-        def autocorrect_to_each(node)
-          item, enumerable = deconstruct_for(node)
-
-          end_pos = end_position(node, enumerable)
-
-          replacement_range = replacement_range(node, end_pos)
-
-          enum_source = enumerable_source(enumerable)
-
-          correction = "#{enum_source}.each do |#{item.source}|"
-          ->(corrector) { corrector.replace(replacement_range, correction) }
-        end
-
-        def end_position(node, enumerable)
-          if node.do?
-            node.loc.begin.end_pos
-          elsif enumerable.begin_type?
-            enumerable.loc.end.end_pos
-          else
-            enumerable.loc.expression.end.end_pos
-          end
-        end
-
-        def enumerable_source(enumerable)
-          return "(#{enumerable.source})" if wrap_into_parentheses?(enumerable)
-
-          enumerable.source
-        end
-
-        def wrap_into_parentheses?(enumerable)
-          enumerable.irange_type? || enumerable.erange_type?
-        end
-
-        def autocorrect_to_for(node)
-          enumerable, items = deconstruct_each(node)
-          variables = extract_variables(items)
-
-          if variables.nil?
-            replacement_range = replacement_range(node, node.loc.begin.end_pos)
-            correction = "for _ in #{enumerable.source} do"
-          else
-            replacement_range = replacement_range(node,
-                                                  items.loc.expression.end_pos)
-            correction = "for #{variables.source} in #{enumerable.source} do"
-          end
-
-          ->(corrector) { corrector.replace(replacement_range, correction) }
-        end
-
-        def replacement_range(node, end_pos)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    end_pos)
+        def suspect_enumerable?(node)
+          node.multiline? &&
+            node.send_node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -101,9 +101,9 @@ module RuboCop
             token_number += 1
           end
 
-          if processed_source.tokens[token_number].text =~
-             Encoding::ENCODING_PATTERN
-            token = processed_source.tokens[token_number]
+          next_token = processed_source.tokens[token_number]
+          if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
+            token = next_token
           end
 
           token
@@ -155,7 +155,9 @@ module RuboCop
 
         def proceeding_comment
           last_special_comment = last_special_comment(processed_source)
-          if processed_source.following_line(last_special_comment).empty?
+          following_line = processed_source.following_line(last_special_comment)
+
+          if following_line && following_line.empty?
             "\n#{FROZEN_STRING_LITERAL_ENABLED}"
           else
             "\n#{FROZEN_STRING_LITERAL_ENABLED}\n"

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

@@ -23,7 +23,7 @@ module RuboCop
         MSG = 'Do not introduce global variables.'.freeze
 
         # built-in global variables and their English aliases
-        # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+        # https://www.zenspider.com/ruby/quickref.html
         BUILT_IN_VARS = %w[
           $: $LOAD_PATH
           $" $LOADED_FEATURES

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

@@ -20,16 +20,21 @@ module RuboCop
 
         MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
 
-        def on_while(node)
-          return unless node.condition.truthy_literal?
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
 
-          add_offense(node, location: :keyword)
+        def after_leaving_scope(scope, _variable_table)
+          @variables ||= []
+          @variables.concat(scope.variables.values)
         end
 
-        def on_until(node)
-          return unless node.condition.falsey_literal?
+        def on_while(node)
+          while_or_until(node) if node.condition.truthy_literal?
+        end
 
-          add_offense(node, location: :keyword)
+        def on_until(node)
+          while_or_until(node) if node.condition.falsey_literal?
         end
 
         alias on_while_post on_while
@@ -47,6 +52,37 @@ module RuboCop
 
         private
 
+        def while_or_until(node)
+          range = node.source_range
+          # Not every `while true` and `until false` can be turned into a
+          # `loop do` without further modification. The reason is that a
+          # variable that's introduced inside a while/until loop is in scope
+          # outside of that loop too, but a variable that's assigned for the
+          # first time inside a block can not be accessed after the block. In
+          # those more complicated cases we don't report an offense.
+          return if @variables.any? do |var|
+            assigned_inside_loop?(var, range) &&
+            !assigned_before_loop?(var, range) &&
+            referenced_after_loop?(var, range)
+          end
+
+          add_offense(node, location: :keyword)
+        end
+
+        def assigned_inside_loop?(var, range)
+          var.assignments.any? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def assigned_before_loop?(var, range)
+          b = range.begin_pos
+          var.assignments.any? { |a| a.node.source_range.end_pos < b }
+        end
+
+        def referenced_after_loop?(var, range)
+          e = range.end_pos
+          var.references.any? { |r| r.node.source_range.begin_pos > e }
+        end
+
         def replace_begin_end_with_modifier(node)
           lambda do |corrector|
             corrector.replace(node.body.loc.begin, 'loop do')

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

@@ -77,18 +77,12 @@ module RuboCop
         end
 
         def autocorrect(node)
-          block_method, _args = *node
-          selector = block_method.source
-
-          # Don't autocorrect if this would change the meaning of the code
-          return if selector == '->' && arg_to_unparenthesized_call?(node)
-
-          lambda do |corrector|
-            if selector == 'lambda'
+          if node.send_node.source == 'lambda'
+            lambda do |corrector|
               autocorrect_method_to_literal(corrector, node)
-            else
-              autocorrect_literal_to_method(corrector, node)
             end
+          else
+            LambdaLiteralToMethodCorrector.new(node)
           end
         end
 
@@ -115,25 +109,6 @@ module RuboCop
           end
         end
 
-        def autocorrect_literal_to_method(corrector, node)
-          block_method, args = *node
-
-          # Check for unparenthesized args' preceding and trailing whitespaces.
-          remove_unparenthesized_whitespace(corrector, node)
-
-          # Avoid correcting to `lambdado` by inserting whitespace
-          # if none exists before or after the lambda arguments.
-          if needs_whitespace?(block_method, args, node)
-            corrector.insert_before(node.loc.begin, ' ')
-          end
-          corrector.replace(block_method.source_range, 'lambda')
-          corrector.remove(args.source_range) if args.source_range
-          return if args.children.empty?
-
-          arg_str = " |#{lambda_arg_string(args)}|"
-          corrector.insert_after(node.loc.begin, arg_str)
-        end
-
         def autocorrect_method_to_literal(corrector, node)
           block_method, args = *node
           corrector.replace(block_method.source_range, '->')
@@ -145,67 +120,9 @@ module RuboCop
           corrector.remove(whitespace_and_old_args)
         end
 
-        def needs_whitespace?(block_method, args, node)
-          selector_end = block_method.loc.selector.end.end_pos
-          block_begin  = node.loc.begin.begin_pos
-
-          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
-            (block_begin == selector_end)
-        end
-
-        def begin_pos(node)
-          node.loc.begin && node.loc.begin.begin_pos
-        end
-
-        def end_pos(node)
-          node.loc.end && node.loc.end.end_pos
-        end
-
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
-
-        def arg_to_unparenthesized_call?(arg_node)
-          parent = arg_node.parent
-
-          if parent && parent.pair_type?
-            arg_node = parent.parent
-            parent = arg_node.parent
-          end
-
-          return false unless parent && parent.send_type?
-          return false if parent.parenthesized_call?
-
-          arg_node.sibling_index > 1
-        end
-
-        def remove_unparenthesized_whitespace(corrector, node)
-          args = node.arguments
-
-          return unless unparenthesized_literal_args?(args)
-
-          remove_leading_whitespace(node, corrector)
-          remove_trailing_whitespace(node, corrector)
-        end
-
-        def remove_leading_whitespace(node, corrector)
-          corrector.remove_preceding(
-            node.arguments.source_range,
-            node.arguments.source_range.begin_pos -
-              node.send_node.source_range.end_pos
-          )
-        end
-
-        def remove_trailing_whitespace(node, corrector)
-          corrector.remove_preceding(
-            node.loc.begin,
-            node.loc.begin.begin_pos - node.arguments.source_range.end_pos - 1
-          )
-        end
-
-        def unparenthesized_literal_args?(args)
-          args.source_range && args.source_range.begin && !parentheses?(args)
-        end
       end
     end
   end