plaid 14.7.0 → 14.8.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/team.rb

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # A group of cops, ready to be called on duty to inspect files.
-    # Team is responsible for selecting only relevant cops to be sent on duty,
-    # as well as insuring that the needed forces are sent along with them.
-    #
-    # For performance reasons, Team will first dispatch cops & forces in two groups,
-    # first the ones needed for autocorrection (if any), then the rest
-    # (unless autocorrections happened).
-    class Team
-      attr_reader :errors, :warnings, :updated_source_file, :cops
-
-      alias updated_source_file? updated_source_file
-
-      def initialize(cops, config = nil, options = {})
-        @cops = cops
-        @config = config
-        @options = options
-        reset
-        @ready = true
-
-        validate_config
-      end
-
-      # @return [Team]
-      def self.new(cop_or_classes, config, options = {})
-        # Support v0 api:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
-
-        super
-      end
-
-      # @return [Team] with cops assembled from the given `cop_classes`
-      def self.mobilize(cop_classes, config, options = {})
-        cops = mobilize_cops(cop_classes, config, options)
-        new(cops, config, options)
-      end
-
-      # @return [Array<Cop::Cop>]
-      def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
-          cop_class.new(config, options)
-        end
-      end
-
-      def autocorrect?
-        @options[:auto_correct]
-      end
-
-      def debug?
-        @options[:debug]
-      end
-
-      # @deprecated. Use investigate
-      # @return Array<offenses>
-      def inspect_file(processed_source)
-        investigate(processed_source).offenses
-      end
-
-      # @return [Commissioner::InvestigationReport]
-      def investigate(processed_source)
-        be_ready
-
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
-
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-
-        report = investigate_partial(autocorrect_cops, processed_source)
-
-        unless autocorrect(processed_source, report)
-          # If we corrected some errors, another round of inspection will be
-          # done, and any other offenses will be caught then, so only need
-          # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source))
-        end
-
-        process_errors(processed_source.path, report.errors)
-
-        report
-      ensure
-        @ready = false
-      end
-
-      # @deprecated
-      def forces
-        @forces ||= self.class.forces_for(cops)
-      end
-
-      # @return [Array<Force>] needed for the given cops
-      def self.forces_for(cops)
-        needed = Hash.new { |h, k| h[k] = [] }
-        cops.each do |cop|
-          Array(cop.class.joining_forces).each { |force| needed[force] << cop }
-        end
-
-        needed.map do |force_class, joining_cops|
-          force_class.new(joining_cops)
-        end
-      end
-
-      def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
-        Digest::SHA1.hexdigest(keys.join)
-      end
-
-      private
-
-      def autocorrect(processed_source, report)
-        @updated_source_file = false
-        return unless autocorrect?
-        return if report.processed_source.parser_error
-
-        new_source = autocorrect_report(report)
-
-        return unless new_source
-
-        if @options[:stdin]
-          # holds source read in from stdin, when --stdin option is used
-          @options[:stdin] = new_source
-        else
-          filename = processed_source.buffer.name
-          File.open(filename, 'w') { |f| f.write(new_source) }
-        end
-        @updated_source_file = true
-      end
-
-      def be_ready
-        return if @ready
-
-        reset
-        @cops.map!(&:ready)
-        @ready = true
-      end
-
-      def reset
-        @errors = []
-        @warnings = []
-      end
-
-      # @return [Commissioner::InvestigationReport]
-      def investigate_partial(cops, processed_source)
-        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
-        commissioner.investigate(processed_source)
-      end
-
-      # @return [Array<cop>]
-      def roundup_relevant_cops(filename)
-        cops.reject do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
-        end
-      end
-
-      def support_target_ruby_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_ruby_version?)
-
-        cop.class.support_target_ruby_version?(cop.target_ruby_version)
-      end
-
-      def support_target_rails_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_rails_version?)
-
-        cop.class.support_target_rails_version?(cop.target_rails_version)
-      end
-
-      def autocorrect_report(report)
-        corrector = collate_corrections(report)
-
-        corrector.rewrite unless corrector.empty?
-      end
-
-      def collate_corrections(report)
-        corrector = Corrector.new(report.processed_source)
-
-        each_corrector(report) do |to_merge|
-          suppress_clobbering do
-            corrector.merge!(to_merge)
-          end
-        end
-
-        corrector
-      end
-
-      def each_corrector(report)
-        skips = Set.new
-        report.cop_reports.each do |cop_report|
-          cop = cop_report.cop
-          corrector = cop_report.corrector
-
-          next if corrector.nil? || corrector.empty?
-          next if skips.include?(cop.class)
-
-          yield corrector
-
-          skips.merge(cop.class.autocorrect_incompatible_with)
-        end
-      end
-
-      def suppress_clobbering
-        yield
-      rescue ::Parser::ClobberingError
-        # ignore Clobbering errors
-      end
-
-      def validate_config
-        cops.each do |cop|
-          cop.validate_config if cop.respond_to?(:validate_config)
-        end
-      end
-
-      def process_errors(file, errors)
-        errors.each do |error|
-          line = ":#{error.line}" if error.line
-          column = ":#{error.column}" if error.column
-          location = "#{file}#{line}#{column}"
-          cause = error.cause
-
-          if cause.is_a?(Warning)
-            handle_warning(cause, location)
-          else
-            handle_error(cause, location, error.cop)
-          end
-        end
-      end
-
-      def handle_warning(error, location)
-        message = Rainbow("#{error.message} (from file: #{location})").yellow
-
-        @warnings << message
-        warn message
-        puts error.backtrace if debug?
-      end
-
-      def handle_error(error, location, cop)
-        message = Rainbow("An error occurred while #{cop.name}" \
-                           " cop was inspecting #{location}.").red
-        @errors << message
-        warn message
-        if debug?
-          puts error.message, error.backtrace
-        else
-          warn 'To see the complete backtrace run rubocop -d.'
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/util.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # This module contains a collection of useful utility methods.
-    module Util
-      include PathUtil
-
-      # Match literal regex characters, not including anchors, character
-      # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX =
-        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
-
-      module_function
-
-      # This is a bad API
-      def comment_line?(line_source)
-        /^\s*#/.match?(line_source)
-      end
-
-      # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
-      def comment_lines?(node)
-        processed_source[line_range(node)].any? { |line| comment_line?(line) }
-      end
-
-      def line_range(node)
-        node.first_line..node.last_line
-      end
-
-      def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end &&
-          node.loc.end.is?(')')
-      end
-
-      def add_parentheses(node, corrector)
-        if node.arguments.empty?
-          corrector.insert_after(node, '()')
-        else
-          corrector.replace(args_begin(node), '(')
-          corrector.insert_after(args_end(node), ')')
-        end
-      end
-
-      def args_begin(node)
-        loc = node.loc
-        selector =
-          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-        selector.end.resize(1)
-      end
-
-      def args_end(node)
-        node.loc.expression.end
-      end
-
-      def on_node(syms, sexp, excludes = [], &block)
-        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
-
-        yield sexp if Array(syms).include?(sexp.type)
-        return if Array(excludes).include?(sexp.type)
-
-        sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
-      end
-
-      def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
-      end
-
-      # Returns, for example, a bare `if` node if the given node is an `if`
-      # with calls chained to the end of it.
-      def first_part_of_call_chain(node)
-        while node
-          case node.type
-          when :send
-            node = node.receiver
-          when :block
-            node = node.send_node
-          else
-            break
-          end
-        end
-        node
-      end
-
-      # If converting a string to Ruby string literal source code, must
-      # double quotes be used?
-      def double_quotes_required?(string)
-        # Double quotes are required for strings which either:
-        # - Contain single quotes
-        # - Contain non-printable characters, which must use an escape
-
-        # Regex matches IF there is a ' or there is a \\ in the string that is
-        # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        /'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
-      end
-
-      def needs_escaping?(string)
-        double_quotes_required?(escape_string(string))
-      end
-
-      def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
-      end
-
-      def to_string_literal(string)
-        if needs_escaping?(string) && compatible_external_encoding_for?(string)
-          string.inspect
-        else
-          "'#{string.gsub('\\') { '\\\\' }}'"
-        end
-      end
-
-      def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
-      end
-
-      def interpret_string_escapes(string)
-        StringInterpreter.interpret(string)
-      end
-
-      def same_line?(node1, node2)
-        node1.respond_to?(:loc) &&
-          node2.respond_to?(:loc) &&
-          node1.loc.line == node2.loc.line
-      end
-
-      def to_supported_styles(enforced_style)
-        enforced_style
-          .sub(/^Enforced/, 'Supported')
-          .sub('Style', 'Styles')
-      end
-
-      private
-
-      def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/utils/format_string.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Utils
-      # Parses {Kernel#sprintf} format strings.
-      class FormatString
-        DIGIT_DOLLAR  = /(\d+)\$/.freeze
-        FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
-        NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
-        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
-        WIDTH         = /(?<width>#{NUMBER})/.freeze
-        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
-        TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
-        NAME          = /<(?<name>\w+)>/.freeze
-        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
-
-        SEQUENCE = /
-            % (?<type>%)
-          | % (?<flags>#{FLAG}*)
-            (?:
-              (?: #{WIDTH}? #{PRECISION}? #{NAME}?
-                | #{WIDTH}? #{NAME} #{PRECISION}?
-                | #{NAME} (?<more_flags>#{FLAG}*) #{WIDTH}? #{PRECISION}?
-              ) #{TYPE}
-              | #{WIDTH}? #{PRECISION}? #{TEMPLATE_NAME}
-            )
-        /x.freeze
-
-        # The syntax of a format sequence is as follows.
-        #
-        # ```
-        # %[flags][width][.precision]type
-        # ```
-        #
-        # A format sequence consists of a percent sign, followed by optional
-        # flags, width, and precision indicators, then terminated with a field
-        # type character.
-        #
-        # For more complex formatting, Ruby supports a reference by name.
-        #
-        # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
-        class FormatSequence
-          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
-
-          def initialize(match)
-            @source = match[0]
-            @begin_pos = match.begin(0)
-            @end_pos = match.end(0)
-            @flags = match[:flags].to_s + match[:more_flags].to_s
-            @width = match[:width]
-            @precision = match[:precision]
-            @name = match[:name]
-            @type = match[:type]
-          end
-
-          def percent?
-            type == '%'
-          end
-
-          def annotated?
-            name && @source.include?('<')
-          end
-
-          def template?
-            name && @source.include?('{')
-          end
-
-          # Number of arguments required for the format sequence
-          def arity
-            @source.scan('*').count + 1
-          end
-
-          def max_digit_dollar_num
-            @source.scan(DIGIT_DOLLAR).map do |(digit_dollar_num)|
-              digit_dollar_num.to_i
-            end.max
-          end
-
-          def style
-            if annotated?
-              :annotated
-            elsif template?
-              :template
-            else
-              :unannotated
-            end
-          end
-        end
-
-        def initialize(string)
-          @source = string
-        end
-
-        def format_sequences
-          @format_sequences ||= parse
-        end
-
-        def valid?
-          !mixed_formats?
-        end
-
-        def named_interpolation?
-          format_sequences.any?(&:name)
-        end
-
-        def max_digit_dollar_num
-          format_sequences.map(&:max_digit_dollar_num).max
-        end
-
-        private
-
-        def parse
-          matches = []
-          @source.scan(SEQUENCE) { matches << FormatSequence.new(Regexp.last_match) }
-          matches
-        end
-
-        def mixed_formats?
-          formats = format_sequences.reject(&:percent?).map do |seq|
-            if seq.name
-              :named
-            elsif seq.max_digit_dollar_num
-              :numbered
-            else
-              :unnumbered
-            end
-          end
-
-          formats.uniq.size > 1
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/variable_force/assignment.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This class represents each assignment of a variable.
-      class Assignment
-        include Branchable
-
-        MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
-
-        attr_reader :node, :variable, :referenced, :references
-
-        alias referenced? referenced
-
-        def initialize(node, variable)
-          unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
-            raise ArgumentError,
-                  "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " \
-                  "passed #{node.type}"
-          end
-
-          @node = node
-          @variable = variable
-          @referenced = false
-          @references = []
-        end
-
-        def name
-          @node.children.first
-        end
-
-        def scope
-          @variable.scope
-        end
-
-        def reference!(node)
-          @references << node
-          @referenced = true
-        end
-
-        def used?
-          @variable.captured_by_block? || @referenced
-        end
-
-        def regexp_named_capture?
-          @node.type == REGEXP_NAMED_CAPTURE_TYPE
-        end
-
-        def operator_assignment?
-          return false unless meta_assignment_node
-
-          OPERATOR_ASSIGNMENT_TYPES.include?(meta_assignment_node.type)
-        end
-
-        def multiple_assignment?
-          return false unless meta_assignment_node
-
-          meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
-        end
-
-        def operator
-          assignment_node = meta_assignment_node || @node
-          assignment_node.loc.operator.source
-        end
-
-        def meta_assignment_node
-          unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node =
-              operator_assignment_node || multiple_assignment_node
-          end
-
-          @meta_assignment_node
-        end
-
-        private
-
-        def operator_assignment_node
-          return nil unless node.parent
-          return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
-          return nil unless node.sibling_index.zero?
-
-          node.parent
-        end
-
-        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
-  end
-end