rubocop 0.87.1

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # A Scope represents a context of local variable visibility.
+      # 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
+        }.freeze
+
+        attr_reader :node, :variables, :naked_top_level
+
+        alias naked_top_level? naked_top_level
+
+        def initialize(node)
+          unless SCOPE_TYPES.include?(node.type)
+            # Accept any node type for top level scope
+            if node.parent
+              raise ArgumentError,
+                    "Node type must be any of #{SCOPE_TYPES}, " \
+                    "passed #{node.type}"
+            end
+            @naked_top_level = true
+          end
+          @node = node
+          @variables = {}
+        end
+
+        def ==(other)
+          @node.equal?(other.node)
+        end
+
+        def name
+          @node.method_name
+        end
+
+        def body_node
+          if naked_top_level?
+            node
+          else
+            child_index = case node.type
+                          when :module, :sclass     then 1
+                          when :def, :class, :block then 2
+                          when :defs                then 3
+                          end
+
+            node.children[child_index]
+          end
+        end
+
+        def include?(target_node)
+          !belong_to_outer_scope?(target_node) &&
+            !belong_to_inner_scope?(target_node)
+        end
+
+        def each_node(&block)
+          return to_enum(__method__) unless block_given?
+
+          yield node if naked_top_level?
+          scan_node(node, &block)
+        end
+
+        private
+
+        def scan_node(node, &block)
+          node.each_child_node do |child_node|
+            next unless include?(child_node)
+
+            yield child_node
+            scan_node(child_node, &block)
+          end
+        end
+
+        def belong_to_outer_scope?(target_node)
+          return true if !naked_top_level? && target_node.equal?(node)
+          return true if ancestor_node?(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
+
+        def belong_to_inner_scope?(target_node)
+          return false if !target_node.parent || 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
+
+        def ancestor_node?(target_node)
+          node.each_ancestor.any? do |ancestor_node|
+            ancestor_node.equal?(target_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # A Variable represents existence of a local variable.
+      # This holds a variable declaration node and some states of the variable.
+      class Variable
+        VARIABLE_DECLARATION_TYPES =
+          (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
+
+        attr_reader :name, :declaration_node, :scope,
+                    :assignments, :references, :captured_by_block
+
+        alias captured_by_block? captured_by_block
+
+        def initialize(name, declaration_node, scope)
+          unless VARIABLE_DECLARATION_TYPES.include?(declaration_node.type)
+            raise ArgumentError,
+                  "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " \
+                  "passed #{declaration_node.type}"
+          end
+
+          @name = name.to_sym
+          @declaration_node = declaration_node
+          @scope = scope
+
+          @assignments = []
+          @references = []
+          @captured_by_block = false
+        end
+
+        def assign(node)
+          @assignments << Assignment.new(node, self)
+        end
+
+        def referenced?
+          !@references.empty?
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def reference!(node)
+          reference = Reference.new(node, @scope)
+          @references << reference
+          consumed_branches = Set.new
+
+          @assignments.reverse_each do |assignment|
+            next if consumed_branches.include?(assignment.branch)
+
+            assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
+
+            # Modifier if/unless conditions are special. Assignments made in
+            # them do not put the assigned variable in scope to the left of the
+            # if/unless keyword. A preceding assignment is needed to put the
+            # variable in scope. For this reason we skip to the next assignment
+            # here.
+            next if in_modifier_if?(assignment)
+
+            break if !assignment.branch || assignment.branch == reference.branch
+
+            consumed_branches << assignment.branch unless assignment.branch.may_run_incompletely?
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def in_modifier_if?(assignment)
+          parent = assignment.node.parent
+          parent = parent.parent if parent&.begin_type?
+          parent&.if_type? && parent&.modifier_form?
+        end
+
+        def capture_with_block!
+          @captured_by_block = true
+        end
+
+        # This is a convenient way to check whether the variable is used
+        # in its entire variable lifetime.
+        # For more precise usage check, refer Assignment#used?.
+        #
+        # Once the variable is captured by a block, we have no idea
+        # when, where, and how many times the block would be invoked.
+        # This means we cannot track the usage of the variable.
+        # So we consider it's used to suppress false positive offenses.
+        def used?
+          @captured_by_block || referenced?
+        end
+
+        def should_be_unused?
+          name.to_s.start_with?('_')
+        end
+
+        def argument?
+          ARGUMENT_DECLARATION_TYPES.include?(@declaration_node.type)
+        end
+
+        def method_argument?
+          argument? && %i[def defs].include?(@scope.node.type)
+        end
+
+        def block_argument?
+          argument? && @scope.node.block_type?
+        end
+
+        def keyword_argument?
+          %i[kwarg kwoptarg].include?(@declaration_node.type)
+        end
+
+        def explicit_block_local_variable?
+          @declaration_node.shadowarg_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # A VariableTable manages the lifetime of all scopes and local variables
+      # in a program.
+      # This holds scopes as stack structure, provides a way to add local
+      # variables to current scope, and find local variables by considering
+      # variable visibility of the current scope.
+      class VariableTable
+        def initialize(hook_receiver = nil)
+          @hook_receiver = hook_receiver
+        end
+
+        def invoke_hook(hook_name, *args)
+          @hook_receiver&.send(hook_name, *args)
+        end
+
+        def scope_stack
+          @scope_stack ||= []
+        end
+
+        def push_scope(scope_node)
+          scope = Scope.new(scope_node)
+          invoke_hook(:before_entering_scope, scope)
+          scope_stack.push(scope)
+          invoke_hook(:after_entering_scope, scope)
+          scope
+        end
+
+        def pop_scope
+          scope = current_scope
+          invoke_hook(:before_leaving_scope, scope)
+          scope_stack.pop
+          invoke_hook(:after_leaving_scope, scope)
+          scope
+        end
+
+        def current_scope
+          scope_stack.last
+        end
+
+        def current_scope_level
+          scope_stack.count
+        end
+
+        def declare_variable(name, node)
+          variable = Variable.new(name, node, current_scope)
+          invoke_hook(:before_declaring_variable, variable)
+          current_scope.variables[variable.name] = variable
+          invoke_hook(:after_declaring_variable, variable)
+          variable
+        end
+
+        def assign_to_variable(name, node)
+          variable = find_variable(name)
+
+          unless variable
+            raise "Assigning to undeclared local variable \"#{name}\" " \
+                 "at #{node.source_range}, #{node.inspect}"
+          end
+
+          variable.assign(node)
+          mark_variable_as_captured_by_block_if_so(variable)
+        end
+
+        def reference_variable(name, node)
+          variable = find_variable(name)
+
+          # In this code:
+          #
+          #   foo = 1 unless foo
+          #
+          #   (if
+          #     (lvar :foo) nil
+          #     (lvasgn :foo
+          #       (int 1)))
+          #
+          # Parser knows whether the foo is a variable or method invocation.
+          # This means that if a :lvar node is shown in AST, the variable is
+          # assumed to be already declared, even if we haven't seen any :lvasgn
+          # or :arg node before the :lvar node.
+          #
+          # We don't invoke #declare_variable here otherwise
+          # Variable#declaration_node will be :lvar node, that is actually not.
+          # So just skip.
+          return unless variable
+
+          variable.reference!(node)
+          mark_variable_as_captured_by_block_if_so(variable)
+        end
+
+        def find_variable(name)
+          name = name.to_sym
+
+          scope_stack.reverse_each do |scope|
+            variable = scope.variables[name]
+            return variable if variable
+            # Only block scope allows referencing outer scope variables.
+            return nil unless scope.node.block_type?
+          end
+
+          nil
+        end
+
+        def variable_exist?(name)
+          find_variable(name)
+        end
+
+        def accessible_variables
+          scope_stack.reverse_each.each_with_object([]) do |scope, variables|
+            variables.concat(scope.variables.values)
+            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.block_type?
+          return if variable.scope == current_scope
+
+          variable.capture_with_block!
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/core_ext/string.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Extensions to the core String class
+class String
+  unless method_defined? :blank?
+    # Checks whether a string is blank. A string is considered blank if it
+    # is either empty or contains only whitespace characters.
+    #
+    # @return [Boolean] true is the string is blank, false otherwise
+    #
+    # @example
+    #   ''.blank? #=> true
+    #
+    # @example
+    #   '    '.blank? #=> true
+    #
+    # @example
+    #   '  test'.blank? #=> false
+    def blank?
+      empty? || strip.empty?
+    end
+  end
+end

data/lib/rubocop/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # An Error exception is different from an Offense with severity 'error'
+  # When this exception is raised, it means that RuboCop is unable to perform
+  # a requested action (probably due to misconfiguration) and must stop
+  # immediately, rather than carrying on
+  class Error < StandardError; end
+
+  class ValidationError < Error; end
+
+  # A wrapper to display errored location of analyzed file.
+  class ErrorWithAnalyzedFileLocation < Error
+    def initialize(cause:, node:, cop:)
+      @cause = cause
+      @cop = cop
+      @location = node.is_a?(RuboCop::AST::Node) ? node.loc : node
+    end
+
+    attr_reader :cause, :cop
+
+    def line
+      @location&.line
+    end
+
+    def column
+      @location&.column
+    end
+
+    def message
+      "cause: #{cause.inspect}"
+    end
+  end
+end

data/lib/rubocop/ext/processed_source.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to AST::ProcessedSource for our cached comment_config
+    module ProcessedSource
+      def comment_config
+        @comment_config ||= CommentConfig.new(self)
+      end
+
+      def disabled_line_ranges
+        comment_config.cop_disabled_line_ranges
+      end
+    end
+  end
+end
+
+RuboCop::ProcessedSource.include RuboCop::Ext::ProcessedSource

data/lib/rubocop/file_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  # Common methods for finding files.
+  module FileFinder
+    def self.root_level=(level)
+      @root_level = level
+    end
+
+    def self.root_level?(path)
+      @root_level == path.to_s
+    end
+
+    def find_file_upwards(filename, start_dir)
+      traverse_files_upwards(filename, start_dir) do |file|
+        # minimize iteration for performance
+        return file if file
+      end
+    end
+
+    def find_files_upwards(filename, start_dir)
+      files = []
+      traverse_files_upwards(filename, start_dir) do |file|
+        files << file
+      end
+      files
+    end
+
+    private
+
+    def traverse_files_upwards(filename, start_dir)
+      Pathname.new(start_dir).expand_path.ascend do |dir|
+        break if FileFinder.root_level?(dir)
+
+        file = dir + filename
+        yield(file.to_s) if file.exist?
+      end
+    end
+  end
+end