rubocop 0.25.0 → 0.26.0

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

@@ -9,16 +9,24 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
-            match = line.match(/^( *)\t/)
+            match = line.match(/^( *)[\t ]*\t/)
             next unless match
 
             spaces = match.captures[0]
 
             range = source_range(processed_source.buffer,
                                  index + 1,
-                                 spaces.length)
+                                 (spaces.length)...(match.end(0)))
 
-            add_offense(nil, range, MSG)
+            add_offense(range, range, MSG)
+          end
+        end
+
+        private
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.replace(range, range.source.gsub(/\t/, '  '))
           end
         end
       end

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

@@ -17,8 +17,12 @@ module RuboCop
         private
 
         def on_percent_literal(node)
-          return unless node.children.none? { |x| x.type == :dstr }
-
+          node.children.each do |string|
+            if string.type == :dstr ||
+              string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
+              return
+            end
+          end
           add_offense(node, :expression)
         end
 

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

@@ -18,25 +18,15 @@ module RuboCop
           check_name(node, name, node.loc.name)
         end
 
-        # TODO: Why is this checking invocations of setter rather than
-        #   definitions? Also, this is not variable.
-        def on_send(node)
-          return unless setter_call_on_self?(node)
-          _receiver, method_name, = *node
-          attribute_name = method_name.to_s.sub(/=$/, '').to_sym
-          check_name(node, attribute_name, node.loc.selector)
+        def on_cvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
         end
 
         private
 
         def message(style)
-          format('Use %s for variables.', style)
-        end
-
-        def setter_call_on_self?(send_node)
-          receiver, method_name, = *send_node
-          return false unless receiver && receiver.type == :self
-          method_name.to_s.end_with?('=')
+          format('Use %s for variable names.', style)
         end
       end
     end

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

@@ -9,18 +9,22 @@ module RuboCop
       class WhileUntilModifier < Cop
         include StatementModifier
 
-        def investigate(processed_source)
-          return unless processed_source.ast
-          on_node([:while, :until], processed_source.ast) do |node|
-            # discard modifier while/until
-            next unless node.loc.end
-            next unless fit_within_line_as_modifier_form?(node)
-            add_offense(node, :keyword, message(node.loc.keyword.source))
-          end
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
         end
 
         private
 
+        def check(node)
+          return unless node.loc.end
+          return unless fit_within_line_as_modifier_form?(node)
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+
         def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body."
         end

data/lib/rubocop/cop/variable_force.rb

@@ -51,11 +51,14 @@ module RuboCop
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
       TWISTED_SCOPE_TYPES = [:block, :class, :sclass, :defs].freeze
-      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:top_level, :module, :def]).freeze
+      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:module, :def]).freeze
 
-      def self.wrap_with_top_level_node(node)
-        # This is a custom node type, not defined in Parser.
-        Parser::AST::Node.new(:top_level, [node])
+      def self.wrap_with_top_level_scope_node(root_node)
+        if root_node.begin_type?
+          root_node
+        else
+          Astrolabe::Node.new(:begin, [root_node])
+        end
       end
 
       def variable_table
@@ -67,10 +70,10 @@ module RuboCop
         root_node = processed_source.ast
         return unless root_node
 
-        # Wrap the root node with :top_level scope node.
-        top_level_node = self.class.wrap_with_top_level_node(root_node)
+        # Wrap the root node with begin node if it's a standalone node.
+        root_node = self.class.wrap_with_top_level_scope_node(root_node)
 
-        inspect_variables_in_scope(top_level_node)
+        inspect_variables_in_scope(root_node)
       end
 
       # This is called for each scope recursively.
@@ -81,10 +84,9 @@ module RuboCop
       end
 
       def process_children(origin_node)
-        origin_node.children.each do |child|
-          next unless child.is_a?(Parser::AST::Node)
-          next if scanned_node?(child)
-          process_node(child)
+        origin_node.each_child_node do |child_node|
+          next if scanned_node?(child_node)
+          process_node(child_node)
         end
       end
 
@@ -245,15 +247,10 @@ module RuboCop
       end
 
       def process_rescue(node)
-        resbody_nodes = node.children.select do |child|
-          next false unless child.is_a?(Parser::AST::Node)
-          child.type == :resbody
-        end
+        resbody_nodes = node.each_child_node(:resbody)
 
         contain_retry = resbody_nodes.any? do |resbody_node|
-          scan(resbody_node) do |node_in_resbody|
-            break true if node_in_resbody.type == :retry
-          end
+          resbody_node.each_descendant.any?(&:retry_type?)
         end
 
         # Treat begin..rescue..end with retry as a loop.
@@ -309,9 +306,9 @@ module RuboCop
         referenced_variable_names_in_loop = []
         assignment_nodes_in_loop = []
 
-        # #scan does not consider scope,
+        # #each_descendant does not consider scope,
         # but we don't need to care about it here.
-        scan(loop_node) do |node|
+        loop_node.each_descendant do |node|
           case node.type
           when :lvar
             referenced_variable_names_in_loop << node.children.first
@@ -328,16 +325,6 @@ module RuboCop
         [referenced_variable_names_in_loop, assignment_nodes_in_loop]
       end
 
-      # Simple recursive scan
-      def scan(node, &block)
-        node.children.each do |child|
-          next unless child.is_a?(Parser::AST::Node)
-          yield child
-          scan(child, &block)
-        end
-        nil
-      end
-
       # Use Node#equal? for accurate check.
       def scanned_node?(node)
         scanned_nodes.any? do |scanned_node|

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

@@ -65,37 +65,29 @@ module RuboCop
         end
 
         def meta_assignment_node
-          if instance_variable_defined?(:@meta_assignment_node)
-            return @meta_assignment_node
+          unless instance_variable_defined?(:@meta_assignment_node)
+            @meta_assignment_node =
+              operator_assignment_node || multiple_assignment_node
           end
 
-          @meta_assignment_node = nil
-
-          return unless parent_node
-
-          if OPERATOR_ASSIGNMENT_TYPES.include?(parent_node.type) &&
-             parent_node.children.index(@node) == 0
-            return @meta_assignment_node = parent_node
-          end
-
-          return unless grantparent_node
-
-          if parent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE &&
-             grantparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-            return @meta_assignment_node = grantparent_node
-          end
-
-          nil
+          @meta_assignment_node
         end
 
         private
 
-        def parent_node
-          ancestor_nodes_in_scope.last
+        def operator_assignment_node
+          return nil unless node.parent
+          return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
+          return nil unless node.parent.children.index(node) == 0
+          node.parent
         end
 
-        def grantparent_node
-          ancestor_nodes_in_scope[-2]
+        def multiple_assignment_node
+          grandparent_node = node.parent ? node.parent.parent : nil
+          return nil unless grandparent_node
+          return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
+          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+          grandparent_node
         end
       end
     end

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

@@ -27,6 +27,25 @@ module RuboCop
           branch_point_node
         end
 
+        def run_exclusively_with?(other)
+          return false unless branch_point_node.equal?(other.branch_point_node)
+          return false if branch_body_node.equal?(other.branch_body_node)
+
+          # Main body of rescue is always run:
+          #
+          #   begin
+          #     # main
+          #   rescue
+          #     # resbody
+          #   end
+          if branch_point_node.type == :rescue &&
+            (branch_body_name == 'main' || other.branch_body_name == 'main')
+            return false
+          end
+
+          true
+        end
+
         def branch_id
           return nil unless inside_of_branch?
           @branch_id ||= [branch_point_node.object_id, branch_type].join('_')
@@ -57,12 +76,6 @@ module RuboCop
           @branch_body_node
         end
 
-        def ancestor_nodes_in_scope
-          @ancestor_nodes_in_scope ||= scope.ancestors_of_node(@node)
-        end
-
-        private
-
         def branch_body_name
           case branch_point_node.type
           when :if
@@ -83,6 +96,8 @@ module RuboCop
                 "Invalid body index #{body_index} of #{branch_point_node.type}"
         end
 
+        private
+
         def if_body_name
           case body_index
           when 1 then 'true'
@@ -128,9 +143,9 @@ module RuboCop
         end
 
         def set_branch_point_and_body_nodes!
-          ancestors_and_self_nodes = ancestor_nodes_in_scope + [@node]
+          self_and_ancestor_nodes = [node] + ancestor_nodes_in_scope
 
-          ancestors_and_self_nodes.reverse.each_cons(2) do |child, parent|
+          self_and_ancestor_nodes.each_cons(2) do |child, parent|
             next unless branch?(parent, child)
             @branch_point_node = parent
             @branch_body_node = child
@@ -138,6 +153,12 @@ module RuboCop
           end
         end
 
+        def ancestor_nodes_in_scope
+          node.each_ancestor.take_while do |ancestor_node|
+            !ancestor_node.equal?(scope.node)
+          end
+        end
+
         def branch?(parent_node, child_node)
           child_index = parent_node.children.index(child_node)
 

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

@@ -7,6 +7,14 @@ module RuboCop
       # This is a place where local variables belong to.
       # A scope instance holds a scope node and variable entries.
       class Scope
+        OUTER_SCOPE_CHILD_INDICES = {
+          defs:   0..0,
+          module: 0..0,
+          class:  0..1,
+          sclass: 0..0,
+          block:  0..0
+        }
+
         attr_reader :node, :variables
 
         def initialize(node)
@@ -34,7 +42,7 @@ module RuboCop
 
         def body_node
           child_index = case @node.type
-                        when :top_level           then 0
+                        when :begin               then 0
                         when :module, :sclass     then 1
                         when :def, :class, :block then 2
                         when :defs                then 3
@@ -43,35 +51,38 @@ module RuboCop
           @node.children[child_index]
         end
 
-        def ancestors_of_node(target_node)
-          ASTScanner.scan(@node) do |scanning_node, ancestor_nodes|
-            return ancestor_nodes[1..-1] if scanning_node.equal?(target_node)
-          end
-
-          fail "Node #{target_node} is not found in scope #{@node}"
+        def each_node(&block)
+          return to_enum(__method__) unless block_given?
+          scan_node(node, &block)
         end
 
-        # This class provides a ways to scan AST with tracking ancestor nodes.
-        class ASTScanner
-          def self.scan(node, &block)
-            new.scan(node, &block)
-          end
+        private
 
-          def initialize
-            @ancestor_nodes = []
+        def scan_node(node, &block)
+          node.each_child_node do |child_node|
+            next if belong_to_another_scope?(child_node)
+            yield child_node
+            scan_node(child_node, &block)
           end
+        end
 
-          def scan(node, &block)
-            @ancestor_nodes.push(node)
+        def belong_to_another_scope?(node)
+          belong_to_outer_scope?(node) || belong_to_inner_scope?(node)
+        end
 
-            node.children.each do |child|
-              next unless child.is_a?(Parser::AST::Node)
-              yield child, @ancestor_nodes
-              scan(child, &block)
-            end
+        def belong_to_outer_scope?(target_node)
+          return false unless target_node.parent.equal?(node)
+          indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
+          return false unless indices
+          indices.include?(target_node.sibling_index)
+        end
 
-            @ancestor_nodes.pop
-          end
+        def belong_to_inner_scope?(target_node)
+          return false if target_node.parent.equal?(node)
+          return false unless SCOPE_TYPES.include?(target_node.parent.type)
+          indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
+          return true unless indices
+          !indices.include?(target_node.sibling_index)
         end
       end
     end

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

@@ -46,17 +46,14 @@ module RuboCop
           @assignments.reverse_each do |assignment|
             next if consumed_branch_ids.include?(assignment.branch_id)
 
-            assignment.reference!
-
-            if assignment.inside_of_branch?
-              break if assignment.branch_id == reference.branch_id
-
-              unless assignment.reference_penetrable?
-                consumed_branch_ids << assignment.branch_id
-              end
-            else
-              break
+            unless assignment.run_exclusively_with?(reference)
+              assignment.reference!
             end
+
+            break unless assignment.inside_of_branch?
+            break if assignment.branch_id == reference.branch_id
+            next if assignment.reference_penetrable?
+            consumed_branch_ids << assignment.branch_id
           end
         end
 

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -16,7 +16,7 @@ module RuboCop
 
       @config_to_allow_offenses = {}
 
-      COPS = Cop::Cop.all.group_by { |c| c.cop_name }
+      COPS = Cop::Cop.all.group_by(&:cop_name)
 
       class << self
         attr_accessor :config_to_allow_offenses
@@ -55,7 +55,8 @@ module RuboCop
         default_cfg = RuboCop::ConfigLoader.default_configuration[cop_name]
         return unless default_cfg
 
-        params = default_cfg.keys - %w(Description Enabled) - cfg.keys
+        params = default_cfg.keys - %w(Description StyleGuide Enabled) -
+          cfg.keys
         return if params.empty?
 
         output.puts "# Configuration parameters: #{params.join(', ')}."