plaid 14.11.0 → 14.11.1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Identifier of all cops containing a department and cop name.
+    #
+    # All cops are identified by their badge. For example, the badge for
+    # `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`.
+    # Badges can be parsed as either `Department/CopName` or just `CopName` to
+    # allow for badge references in source files that omit the department for
+    # RuboCop to infer.
+    class Badge
+      # Error raised when a badge parse fails.
+      class InvalidBadge < Error
+        MSG = 'Invalid badge %<badge>p. ' \
+              'Expected `Department/CopName` or `CopName`.'
+
+        def initialize(token)
+          super(format(MSG, badge: token))
+        end
+      end
+
+      attr_reader :department, :cop_name
+
+      def self.for(class_name)
+        new(*class_name.split('::').last(2))
+      end
+
+      def self.parse(identifier)
+        parts = identifier.split('/', 2)
+
+        raise InvalidBadge, identifier if parts.size > 2
+
+        if parts.one?
+          new(nil, *parts)
+        else
+          new(*parts)
+        end
+      end
+
+      def initialize(department, cop_name)
+        @department = department.to_sym if department
+        @cop_name   = cop_name
+      end
+
+      def ==(other)
+        hash == other.hash
+      end
+      alias eql? ==
+
+      def hash
+        [department, cop_name].hash
+      end
+
+      def match?(other)
+        cop_name == other.cop_name &&
+          (!qualified? || department == other.department)
+      end
+
+      def to_s
+        @to_s ||= qualified? ? "#{department}/#{cop_name}" : cop_name
+      end
+
+      def qualified?
+        !department.nil?
+      end
+
+      def with_department(department)
+        self.class.new(department, cop_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete cops.
+    #
+    # The Cop::Base class is meant to be extended.
+    #
+    # Cops track offenses and can autocorrect them on the fly.
+    #
+    # A commissioner object is responsible for traversing the AST and invoking
+    # the specific callbacks on each cop.
+    #
+    # First the callback `on_new_investigation` is called;
+    # if a cop needs to do its own processing of the AST or depends on
+    # something else.
+    #
+    # Then callbacks like `on_def`, `on_send` (see AST::Traversal) are called
+    # with their respective nodes.
+    #
+    # Finally the callback `on_investigation_end` is called.
+    #
+    # Within these callbacks, cops are meant to call `add_offense` or
+    # `add_global_offense`. Use the `processed_source` method to
+    # get the currently processed source being investigated.
+    #
+    # In case of invalid syntax / unparseable content,
+    # the callback `on_other_file` is called instead of all the other
+    # `on_...` callbacks.
+    #
+    # Private methods are not meant for custom cops consumption,
+    # nor are any instance variables.
+    #
+    class Base # rubocop:disable Metrics/ClassLength
+      extend RuboCop::AST::Sexp
+      extend NodePattern::Macros
+      include RuboCop::AST::Sexp
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      attr_reader :config, :processed_source
+
+      # Reports of an investigation.
+      # Immutable
+      # Consider creation API private
+      InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
+
+      # List of methods names to restrict calls for `on_send` / `on_csend`
+      RESTRICT_ON_SEND = Set[].freeze
+
+      # List of cops that should not try to autocorrect at the same
+      # time as this cop
+      #
+      # @return [Array<RuboCop::Cop::Cop>]
+      #
+      # @api public
+      def self.autocorrect_incompatible_with
+        []
+      end
+
+      # Cops (other than builtin) are encouraged to implement this
+      # @return [String, nil]
+      #
+      # @api public
+      def self.documentation_url
+        Documentation.url_for(self) if builtin?
+      end
+
+      def initialize(config = nil, options = nil)
+        @config = config || Config.new
+        @options = options || { debug: false }
+        reset_investigation
+      end
+
+      # Called before all on_... have been called
+      # When refining this method, always call `super`
+      def on_new_investigation
+        # Typically do nothing here
+      end
+
+      # Called after all on_... have been called
+      # When refining this method, always call `super`
+      def on_investigation_end
+        # Typically do nothing here
+      end
+
+      # Called instead of all on_... callbacks for unrecognized files / syntax errors
+      # When refining this method, always call `super`
+      def on_other_file
+        # Typically do nothing here
+      end
+
+      # Override and return the Force class(es) you need to join
+      def self.joining_forces; end
+
+      # Gets called if no message is specified when calling `add_offense` or
+      # `add_global_offense`
+      # Cops are discouraged to override this; instead pass your message directly
+      def message(_range = nil)
+        self.class::MSG
+      end
+
+      # Adds an offense that has no particular location.
+      # No correction can be applied to global offenses
+      def add_global_offense(message = nil, severity: nil)
+        severity = find_severity(nil, severity)
+        message = find_message(nil, message)
+        @current_offenses <<
+          Offense.new(severity, Offense::NO_LOCATION, message, name, :unsupported)
+      end
+
+      # Adds an offense on the specified range (or node with an expression)
+      # Unless that offense is disabled for this range, a corrector will be yielded
+      # to provide the cop the opportunity to autocorrect the offense.
+      # If message is not specified, the method `message` will be called.
+      def add_offense(node_or_range, message: nil, severity: nil, &block)
+        range = range_from_node_or_range(node_or_range)
+        return unless current_offense_locations.add?(range)
+
+        range_to_pass = callback_argument(range)
+
+        severity = find_severity(range_to_pass, severity)
+        message = find_message(range_to_pass, message)
+
+        status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
+
+        @current_offenses << Offense.new(severity, range, message, name, status, corrector)
+      end
+
+      # This method should be overridden when a cop's behavior depends
+      # on state that lives outside of these locations:
+      #
+      #   (1) the file under inspection
+      #   (2) the cop's source code
+      #   (3) the config (eg a .rubocop.yml file)
+      #
+      # For example, some cops may want to look at other parts of
+      # the codebase being inspected to find violations. A cop may
+      # use the presence or absence of file `foo.rb` to determine
+      # whether a certain violation exists in `bar.rb`.
+      #
+      # Overriding this method allows the cop to indicate to RuboCop's
+      # ResultCache system when those external dependencies change,
+      # ie when the ResultCache should be invalidated.
+      def external_dependency_checksum
+        nil
+      end
+
+      def self.inherited(subclass)
+        super
+        Registry.global.enlist(subclass)
+      end
+
+      # Call for abstract Cop classes
+      def self.exclude_from_registry
+        Registry.global.dismiss(self)
+      end
+
+      # Returns if class supports auto_correct.
+      # It is recommended to extend AutoCorrector instead of overriding
+      def self.support_autocorrect?
+        false
+      end
+
+      ### Naming
+
+      def self.badge
+        @badge ||= Badge.for(name)
+      end
+
+      def self.cop_name
+        badge.to_s
+      end
+
+      def self.department
+        badge.department
+      end
+
+      def self.lint?
+        department == :Lint
+      end
+
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) ||
+          given_names.include?(department.to_s)
+      end
+
+      def cop_name
+        @cop_name ||= self.class.cop_name
+      end
+
+      alias name cop_name
+
+      ### Configuration Helpers
+
+      def cop_config
+        # Use department configuration as basis, but let individual cop
+        # configuration override.
+        @cop_config ||= @config.for_badge(self.class.badge)
+      end
+
+      def config_to_allow_offenses
+        Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses[cop_name] ||= {}
+      end
+
+      def config_to_allow_offenses=(hash)
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
+          hash
+      end
+
+      def target_ruby_version
+        @config.target_ruby_version
+      end
+
+      def target_rails_version
+        @config.target_rails_version
+      end
+
+      def relevant_file?(file)
+        file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
+          file_name_matches_any?(file, 'Include', true) &&
+            !file_name_matches_any?(file, 'Exclude', false)
+      end
+
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
+      ### Persistence
+
+      # Override if your cop should be called repeatedly for multiple investigations
+      # Between calls to `on_new_investigation` and `on_investigation_end`,
+      # the result of `processed_source` will remain constant.
+      # You should invalidate any caches that depend on the current `processed_source`
+      # in the `on_new_investigation` callback.
+      # If your cop does autocorrections, be aware that your instance may be called
+      # multiple times with the same `processed_source.path` but different content.
+      def self.support_multiple_source?
+        false
+      end
+
+      # @api private
+      # Called between investigations
+      def ready
+        return self if self.class.support_multiple_source?
+
+        self.class.new(@config, @options)
+      end
+
+      ### Reserved for Cop::Cop
+
+      # @deprecated Make potential errors with previous API more obvious
+      def offenses
+        raise 'The offenses are not directly available; ' \
+          'they are returned as the result of the investigation'
+      end
+
+      private
+
+      ### Reserved for Cop::Cop
+
+      def callback_argument(range)
+        range
+      end
+
+      def apply_correction(corrector)
+        @current_corrector&.merge!(corrector) if corrector
+      end
+
+      def correction_strategy
+        return :unsupported unless correctable?
+        return :uncorrected unless autocorrect?
+
+        :attempt_correction
+      end
+
+      ### Reserved for Commissioner:
+
+      def current_offense_locations
+        @current_offense_locations ||= Set.new
+      end
+
+      def currently_disabled_lines
+        @currently_disabled_lines ||= Set.new
+      end
+
+      private_class_method def self.restrict_on_send
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_set.freeze
+      end
+
+      # Called before any investigation
+      def begin_investigation(processed_source)
+        @current_offenses = []
+        @current_offense_locations = nil
+        @currently_disabled_lines = nil
+        @processed_source = processed_source
+        @current_corrector = Corrector.new(@processed_source) if @processed_source.valid_syntax?
+      end
+
+      # Called to complete an investigation
+      def complete_investigation
+        InvestigationReport.new(self, processed_source, @current_offenses, @current_corrector)
+      ensure
+        reset_investigation
+      end
+
+      ### Actually private methods
+
+      def self.builtin?
+        return false unless (m = instance_methods(false).first) # any custom method will do
+
+        path, _line = instance_method(m).source_location
+        path.start_with?(__dir__)
+      end
+      private_class_method :builtin?
+
+      def reset_investigation
+        @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
+      end
+
+      # @return [Symbol, Corrector] offense status
+      def correct(range)
+        status = correction_strategy
+
+        if block_given?
+          corrector = Corrector.new(self)
+          yield corrector
+          if !corrector.empty? && !self.class.support_autocorrect?
+            raise "The Cop #{name} must `extend AutoCorrector` to be able to autocorrect"
+          end
+        end
+
+        status = attempt_correction(range, corrector) if status == :attempt_correction
+
+        [status, corrector]
+      end
+
+      # @return [Symbol] offense status
+      def attempt_correction(range, corrector)
+        if corrector && !corrector.empty?
+          status = :corrected
+        elsif disable_uncorrectable?
+          corrector = disable_uncorrectable(range)
+          status = :corrected_with_todo
+        else
+          return :uncorrected
+        end
+
+        apply_correction(corrector) if corrector
+        status
+      end
+
+      def disable_uncorrectable(range)
+        line = range.line
+        return unless currently_disabled_lines.add?(line)
+
+        disable_offense(range)
+      end
+
+      def range_from_node_or_range(node_or_range)
+        if node_or_range.respond_to?(:loc)
+          node_or_range.loc.expression
+        elsif node_or_range.is_a?(::Parser::Source::Range)
+          node_or_range
+        else
+          extra = ' (call `add_global_offense`)' if node_or_range.nil?
+          raise "Expected a Source::Range, got #{node_or_range.inspect}#{extra}"
+        end
+      end
+
+      def find_message(range, message)
+        annotate(message || message(range))
+      end
+
+      def annotate(message)
+        RuboCop::Cop::MessageAnnotator.new(
+          config, cop_name, cop_config, @options
+        ).annotate(message)
+      end
+
+      def file_name_matches_any?(file, parameter, default_result)
+        patterns = cop_config[parameter]
+        return default_result unless patterns
+
+        path = nil
+        patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
+          match_path?(pattern, path)
+        end
+      end
+
+      def enabled_line?(line_number)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
+      end
+
+      def find_severity(_range, severity)
+        custom_severity || severity || default_severity
+      end
+
+      def default_severity
+        self.class.lint? ? :warning : :convention
+      end
+
+      def custom_severity
+        severity = cop_config['Severity']
+        return unless severity
+
+        if Severity::NAMES.include?(severity.to_sym)
+          severity.to_sym
+        else
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # A Gem's requirements should be listed only once in a Gemfile.
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rubocop'
+      #
+      #   # bad
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   group :development, :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   gem 'rubocop', groups: [:development, :test]
+      class DuplicatedGem < Cop
+        include RangeHelp
+
+        MSG = 'Gem `%<gem_name>s` requirements already given on line '\
+          '%<line_of_first_occurrence>d of the Gemfile.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          duplicated_gem_nodes.each do |nodes|
+            nodes[1..-1].each do |node|
+              register_offense(
+                node,
+                node.first_argument.to_a.first,
+                nodes.first.first_line
+              )
+            end
+          end
+        end
+
+        private
+
+        def_node_search :gem_declarations, '(send nil? :gem str ...)'
+
+        def duplicated_gem_nodes
+          gem_declarations(processed_source.ast)
+            .group_by(&:first_argument)
+            .values
+            .select { |nodes| nodes.size > 1 && !condition?(nodes) }
+        end
+
+        def condition?(nodes)
+          nodes[0].parent&.if_type? && nodes[0].parent == nodes[1].parent
+        end
+
+        def register_offense(node, gem_name, line_of_first_occurrence)
+          line_range = node.loc.column...node.loc.last_column
+          offense_location =
+            source_range(processed_source.buffer, node.first_line, line_range)
+          message = format(
+            MSG,
+            gem_name: gem_name,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(node, location: offense_location, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Add a comment describing each gem in your Gemfile.
+      #
+      # Optionally, the "OnlyFor" configuration
+      # can be used to only register offenses when the gems
+      # use certain options or have version specifiers.
+      # Add "version_specifiers" and/or the gem option names
+      # you want to check.
+      #
+      # A useful use-case is to enforce a comment when using
+      # options that change the source of a gem:
+      #
+      # - `bitbucket`
+      # - `gist`
+      # - `git`
+      # - `github`
+      # - `source`
+      #
+      # For a full list of options supported by bundler,
+      # you can check the https://bundler.io/man/gemfile.5.html[official documentation].
+      #
+      # @example OnlyFor: [] (default)
+      #   # bad
+      #
+      #   gem 'foo'
+      #
+      #   # good
+      #
+      #   # Helpers for the foo things.
+      #   gem 'foo'
+      #
+      # @example OnlyFor: ['version_specifiers']
+      #   # bad
+      #
+      #   gem 'foo', '< 2.1'
+      #
+      #   # good
+      #
+      #   # Version 2.1 introduces breaking change baz
+      #   gem 'foo', '< 2.1'
+      #
+      # @example OnlyFor: ['version_specifiers', 'github']
+      #   # bad
+      #
+      #   gem 'foo', github: 'some_account/some_fork_of_foo'
+      #
+      #   gem 'bar', '< 2.1'
+      #
+      #   # good
+      #
+      #   # Using this fork because baz
+      #   gem 'foo', github: 'some_account/some_fork_of_foo'
+      #
+      #   # Version 2.1 introduces breaking change baz
+      #   gem 'bar', '< 2.1'
+      #
+      class GemComment < Cop
+        include DefNode
+
+        MSG = 'Missing gem description comment.'
+        CHECKED_OPTIONS_CONFIG = 'OnlyFor'
+        VERSION_SPECIFIERS_OPTION = 'version_specifiers'
+        RESTRICT_ON_SEND = %i[gem].freeze
+
+        def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
+
+        def on_send(node)
+          return unless gem_declaration?(node)
+          return if ignored_gem?(node)
+          return if commented_any_descendant?(node)
+          return if cop_config[CHECKED_OPTIONS_CONFIG].any? && !checked_options_present?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def commented_any_descendant?(node)
+          commented?(node) || node.each_descendant.any? { |n| commented?(n) }
+        end
+
+        def commented?(node)
+          preceding_lines = preceding_lines(node)
+          preceding_comment?(node, preceding_lines.last)
+        end
+
+        # The args node1 & node2 may represent a RuboCop::AST::Node
+        # or a Parser::Source::Comment. Both respond to #loc.
+        def precede?(node1, node2)
+          node2.loc.line - node1.loc.line <= 1
+        end
+
+        def preceding_lines(node)
+          processed_source.ast_with_comments[node].select do |line|
+            line.loc.line <= node.loc.line
+          end
+        end
+
+        def preceding_comment?(node1, node2)
+          node1 && node2 && precede?(node2, node1) &&
+            comment_line?(node2.loc.expression.source)
+        end
+
+        def ignored_gem?(node)
+          ignored_gems = Array(cop_config['IgnoredGems'])
+          ignored_gems.include?(node.first_argument.value)
+        end
+
+        def checked_options_present?(node)
+          (cop_config[CHECKED_OPTIONS_CONFIG].include?(VERSION_SPECIFIERS_OPTION) &&
+            version_specified_gem?(node)) ||
+            contains_checked_options?(node)
+        end
+
+        # Besides the gem name, all other *positional* arguments to `gem` are version specifiers,
+        # as long as it has one we know there's at least one version specifier.
+        def version_specified_gem?(node)
+          # arguments[0] is the gem name
+          node.arguments[1]&.str_type?
+        end
+
+        def contains_checked_options?(node)
+          (Array(cop_config[CHECKED_OPTIONS_CONFIG]) & gem_options(node).map(&:to_s)).any?
+        end
+
+        def gem_options(node)
+          return [] unless node.arguments.last&.type == :hash
+
+          node.arguments.last.keys.map(&:value)
+        end
+      end
+    end
+  end
+end