rubocop 0.42.0 → 0.43.0

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

@@ -28,7 +28,7 @@ module RuboCop
 
         def check(node)
           return unless node.loc.end
-          return unless fit_within_line_as_modifier_form?(node)
+          return unless single_line_as_modifier?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
 

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

@@ -25,19 +25,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          words = node.children
           if style == :percent
-            escape = words.any? { |w| needs_escaping?(w.children[0]) }
-            char = escape ? 'W' : 'w'
-            contents = autocorrect_words(words, escape, node.loc.line)
-            lambda do |corrector|
-              corrector.replace(node.source_range, "%#{char}(#{contents})")
-            end
+            correct_percent(node)
           else
-            words = words.map { |w| to_string_literal(w.children[0]) }
-            lambda do |corrector|
-              corrector.replace(node.source_range, "[#{words.join(', ')}]")
-            end
+            correct_bracketed(node)
           end
         end
 
@@ -50,9 +41,9 @@ module RuboCop
                     comments_in_array?(node)
           style_detected(:brackets, array_elems.size)
 
-          if style == :percent && array_elems.size >= min_size
-            add_offense(node, :expression, PERCENT_MSG)
-          end
+          return unless style == :percent && array_elems.size >= min_size
+
+          add_offense(node, :expression, PERCENT_MSG)
         end
 
         def check_percent(node)
@@ -94,13 +85,32 @@ module RuboCop
           cop_config['WordRegex']
         end
 
+        def correct_percent(node)
+          words = node.children
+          escape = words.any? { |w| needs_escaping?(w.children[0]) }
+          char = escape ? 'W' : 'w'
+          contents = autocorrect_words(words, escape, node.loc.line)
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "%#{char}(#{contents})")
+          end
+        end
+
+        def correct_bracketed(node)
+          words = node.children.map { |w| to_string_literal(w.children[0]) }
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+          end
+        end
+
         def autocorrect_words(word_nodes, escape, base_line_number)
           previous_node_line_number = base_line_number
           word_nodes.map do |node|
             number_of_line_breaks = node.loc.line - previous_node_line_number
             line_breaks = "\n" * number_of_line_breaks
             previous_node_line_number = node.loc.line
-            content = node.children[0]
+            content = node.children.first
             content = escape ? escape_string(content) : content
             content.gsub!(/\)/, '\\)')
             line_breaks + content

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

@@ -34,10 +34,12 @@ module RuboCop
 
           nonzero_length_predicate = nonzero_length_predicate(node)
 
+          # rubocop:disable Style/GuardClause
           if nonzero_length_predicate
             add_offense(node, :expression,
                         format(NONZERO_MSG, *nonzero_length_predicate))
           end
+          # rubocop:enable Style/GuardClause
         end
 
         def_node_matcher :zero_length_predicate, <<-END

data/lib/rubocop/cop/util.rb

@@ -81,10 +81,7 @@ module RuboCop
         yield sexp if Array(syms).include?(sexp.type)
         return if Array(excludes).include?(sexp.type)
 
-        sexp.children.each do |elem|
-          next unless elem.is_a?(Parser::AST::Node)
-          on_node(syms, elem, excludes, &block)
-        end
+        sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
       end
 
       def source_range(source_buffer, line_number, column, length = 1)
@@ -119,6 +116,10 @@ module RuboCop
         end
       end
 
+      def range_between(start_pos, end_pos)
+        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
+      end
+
       def range_with_surrounding_comma(range, side = :both)
         buffer = @processed_source.buffer
         src = buffer.source
@@ -247,6 +248,24 @@ module RuboCop
       def interpret_string_escapes(string)
         StringInterpreter.interpret(string)
       end
+
+      def same_line?(n1, n2)
+        n1.respond_to?(:loc) &&
+          n2.respond_to?(:loc) &&
+          n1.loc.line == n2.loc.line
+      end
+
+      def line_distance(n1, n2)
+        n2.loc.line - n1.loc.line
+      end
+
+      def preceed?(n1, n2)
+        line_distance(n1, n2) == 1
+      end
+
+      def stripped_source_upto(line)
+        processed_source[0..line].map(&:strip)
+      end
     end
   end
 end

data/lib/rubocop/cop/variable_force.rb

@@ -56,6 +56,18 @@ module RuboCop
 
       SEND_TYPE = :send
 
+      VariableReference = Struct.new(:name) do
+        def assignment?
+          false
+        end
+      end
+
+      AssignmentReference = Struct.new(:node) do
+        def assignment?
+          true
+        end
+      end
+
       def variable_table
         @variable_table ||= VariableTable.new(self)
       end
@@ -70,6 +82,15 @@ module RuboCop
         variable_table.pop_scope
       end
 
+      def process_node(node)
+        catch(:skip_children) do
+          dispatch_node(node)
+          process_children(node)
+        end
+      end
+
+      private
+
       # This is called for each scope recursively.
       def inspect_variables_in_scope(scope_node)
         variable_table.push_scope(scope_node)
@@ -84,13 +105,6 @@ module RuboCop
         end
       end
 
-      def process_node(node)
-        catch(:skip_children) do
-          dispatch_node(node)
-          process_children(node)
-        end
-      end
-
       def skip_children!
         throw :skip_children
       end
@@ -158,10 +172,7 @@ module RuboCop
 
       def process_regexp_named_captures(node)
         regexp_node, rhs_node = *node
-
-        regexp_string = regexp_node.children[0].children[0]
-        regexp = Regexp.new(regexp_string)
-        variable_names = regexp.named_captures.keys
+        variable_names = regexp_captured_names(regexp_node)
 
         variable_names.each do |name|
           next if variable_table.variable_exist?(name)
@@ -178,6 +189,13 @@ module RuboCop
         skip_children!
       end
 
+      def regexp_captured_names(node)
+        regexp_string = node.children[0].children[0] || ''
+        regexp = Regexp.new(regexp_string)
+
+        regexp.named_captures.keys
+      end
+
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -185,7 +203,7 @@ module RuboCop
           asgn_node, _operator, rhs_node = *node
         end
 
-        return unless asgn_node.type == :lvasgn
+        return unless asgn_node.lvasgn_type?
 
         name = asgn_node.children.first
 
@@ -264,7 +282,7 @@ module RuboCop
         if TWISTED_SCOPE_TYPES.include?(node.type)
           # See the comment at the end of file for this behavior.
           twisted_nodes = [node.children[0]]
-          twisted_nodes << node.children[1] if node.type == :class
+          twisted_nodes << node.children[1] if node.class_type?
           twisted_nodes.compact!
 
           twisted_nodes.each do |twisted_node|
@@ -312,23 +330,39 @@ module RuboCop
         referenced_variable_names_in_loop = []
         assignment_nodes_in_loop = []
 
+        each_descendant_reference(loop_node) do |reference|
+          if reference.assignment?
+            assignment_nodes_in_loop << reference.node
+          else
+            referenced_variable_names_in_loop << reference.name
+          end
+        end
+
+        [referenced_variable_names_in_loop, assignment_nodes_in_loop]
+      end
+
+      def each_descendant_reference(loop_node)
         # #each_descendant does not consider scope,
         # but we don't need to care about it here.
         loop_node.each_descendant do |node|
-          case node.type
-          when :lvar
-            referenced_variable_names_in_loop << node.children.first
-          when :lvasgn
-            assignment_nodes_in_loop << node
-          when *OPERATOR_ASSIGNMENT_TYPES
-            asgn_node = node.children.first
-            if asgn_node.type == :lvasgn
-              referenced_variable_names_in_loop << asgn_node.children.first
-            end
-          end
+          reference = descendant_reference(node)
+
+          yield reference if reference
         end
+      end
 
-        [referenced_variable_names_in_loop, assignment_nodes_in_loop]
+      def descendant_reference(node)
+        case node.type
+        when :lvar
+          VariableReference.new(node.children.first)
+        when :lvasgn
+          AssignmentReference.new(node)
+        when *OPERATOR_ASSIGNMENT_TYPES
+          asgn_node = node.children.first
+          if asgn_node.lvasgn_type?
+            VariableReference.new(asgn_node.children.first)
+          end
+        end
       end
 
       # Use Node#equal? for accurate check.

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -45,7 +45,7 @@ module RuboCop
           #   rescue
           #     # resbody
           #   end
-          if branch_point_node.type == :rescue &&
+          if branch_point_node.rescue_type? &&
              (branch_body_name == 'main' || other.branch_body_name == 'main')
             return false
           end
@@ -83,6 +83,7 @@ module RuboCop
           @branch_body_node
         end
 
+        # TODO: Replace case statement with function mapping
         def branch_body_name
           case branch_point_node.type
           when :if                     then if_body_name
@@ -91,11 +92,10 @@ module RuboCop
           when ENSURE_TYPE             then ensure_body_name
           when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
           when *LOOP_TYPES             then loop_body_name
-          else raise InvalidBranchBodyError
+          else
+            raise InvalidBranchBodyError, "Invalid body index #{body_index} " \
+                                          "of #{branch_point_node.type}"
           end
-        rescue InvalidBranchBodyError
-          raise InvalidBranchBodyError,
-                "Invalid body index #{body_index} of #{branch_point_node.type}"
         end
 
         private
@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def case_body_name
-          if branch_body_node.type == :when
+          if branch_body_node.when_type?
             "when#{body_index - 1}"
           else
             'else'
@@ -169,6 +169,7 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/MethodLength
         def branch?(parent_node, child_node)
           child_index = parent_node.children.index(child_node)
 
@@ -189,6 +190,7 @@ module RuboCop
             false
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         class InvalidBranchBodyError < StandardError; end
       end

data/lib/rubocop/cop/variable_force/variable.rb

@@ -87,7 +87,7 @@ module RuboCop
         end
 
         def block_argument?
-          argument? && @scope.node.type == :block
+          argument? && @scope.node.block_type?
         end
 
         def keyword_argument?
@@ -95,7 +95,7 @@ module RuboCop
         end
 
         def explicit_block_local_variable?
-          @declaration_node.type == :shadowarg
+          @declaration_node.shadowarg_type?
         end
       end
     end

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -99,7 +99,7 @@ module RuboCop
             variable = scope.variables[name]
             return variable if variable
             # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.type == :block
+            return nil unless scope.node.block_type?
           end
 
           nil
@@ -112,14 +112,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.each_with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.type == :block
+            break variables unless scope.node.block_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.type == :block
+          return unless current_scope.node.block_type?
           return if variable.scope == current_scope
           variable.capture_with_block!
         end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -151,6 +151,13 @@ module RuboCop
         require 'pathname'
         parent = Pathname.new(Dir.pwd)
 
+        output.puts '  Exclude:'
+        excludes(offending_files, cop_name, parent).each do |file|
+          output_exclude_path(output, file, parent)
+        end
+      end
+
+      def excludes(offending_files, cop_name, parent)
         # Exclude properties in .rubocop_todo.yml override default ones, as well
         # as any custom excludes in .rubocop.yml, so in order to retain those
         # excludes we must copy them.
@@ -158,18 +165,16 @@ module RuboCop
         # just look at the current working directory
         config = ConfigStore.new.for(parent)
         cfg = config[cop_name] || {}
-        excludes = ((cfg['Exclude'] || []) + offending_files).uniq
 
-        output.puts '  Exclude:'
-        excludes.each do |file|
-          file_path = Pathname.new(file)
-          begin
-            relative = file_path.relative_path_from(parent)
-            output.puts "    - '#{relative}'"
-          rescue ArgumentError
-            output.puts "    - '#{file}'"
-          end
-        end
+        ((cfg['Exclude'] || []) + offending_files).uniq
+      end
+
+      def output_exclude_path(output, file, parent)
+        file_path = Pathname.new(file)
+        relative = file_path.relative_path_from(parent)
+        output.puts "    - '#{relative}'"
+      rescue ArgumentError
+        output.puts "    - '#{file}'"
       end
     end
   end

data/lib/rubocop/formatter/formatter_set.rb

@@ -47,15 +47,6 @@ module RuboCop
       end
 
       def add_formatter(formatter_type, output_path = nil)
-        formatter_class = case formatter_type
-                          when Class
-                            formatter_type
-                          when /\A[A-Z]/
-                            custom_formatter_class(formatter_type)
-                          else
-                            builtin_formatter_class(formatter_type)
-                          end
-
         if output_path
           dir_path = File.dirname(output_path)
           FileUtils.mkdir_p(dir_path) unless File.exist?(dir_path)
@@ -64,7 +55,7 @@ module RuboCop
           output = $stdout
         end
 
-        self << formatter_class.new(output, @options)
+        self << formatter_class(formatter_type).new(output, @options)
       end
 
       def close_output_files
@@ -75,6 +66,17 @@ module RuboCop
 
       private
 
+      def formatter_class(formatter_type)
+        case formatter_type
+        when Class
+          formatter_type
+        when /\A[A-Z]/
+          custom_formatter_class(formatter_type)
+        else
+          builtin_formatter_class(formatter_type)
+        end
+      end
+
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
           key.start_with?(specified_key)