plaid 14.10.0 → 14.11.0

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

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Error raised when an unqualified cop name is used that could
-    # refer to two or more cops under different departments
-    class AmbiguousCopName < RuboCop::Error
-      MSG = 'Ambiguous cop name `%<name>s` used in %<origin>s needs ' \
-            'department qualifier. Did you mean %<options>s?'
-
-      def initialize(name, origin, badges)
-        super(
-          format(
-            MSG,
-            name: name,
-            origin: origin,
-            options: badges.to_a.join(' or ')
-          )
-        )
-      end
-    end
-
-    # Registry that tracks all cops by their badge and department.
-    class Registry
-      include Enumerable
-
-      attr_reader :options
-
-      def initialize(cops = [], options = {})
-        @registry = {}
-        @departments = {}
-        @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
-
-        @enrollment_queue = cops
-        @options = options
-      end
-
-      def enlist(cop)
-        @enrollment_queue << cop
-      end
-
-      def dismiss(cop)
-        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
-      end
-
-      # @return [Array<Symbol>] list of departments for current cops.
-      def departments
-        clear_enrollment_queue
-        @departments.keys
-      end
-
-      # @return [Registry] Cops for that specific department.
-      def with_department(department)
-        clear_enrollment_queue
-        with(@departments.fetch(department, []))
-      end
-
-      # @return [Registry] Cops not for a specific department.
-      def without_department(department)
-        clear_enrollment_queue
-        without_department = @departments.dup
-        without_department.delete(department)
-
-        with(without_department.values.flatten)
-      end
-
-      def contains_cop_matching?(names)
-        cops.any? { |cop| cop.match?(names) }
-      end
-
-      # Convert a user provided cop name into a properly namespaced name
-      #
-      # @example gives back a correctly qualified cop name
-      #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.
-      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
-      #
-      # @example fixes incorrect namespaces
-      #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
-      #
-      # @example namespaces bare cop identifiers
-      #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
-      #
-      # @example passes back unrecognized cop names
-      #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('NotACop') # => 'NotACop'
-      #
-      # @param name [String] Cop name extracted from config
-      # @param path [String, nil] Path of file that `name` was extracted from
-      #
-      # @raise [AmbiguousCopName]
-      #   if a bare identifier with two possible namespaces is provided
-      #
-      # @note Emits a warning if the provided name has an incorrect namespace
-      #
-      # @return [String] Qualified cop name
-      def qualified_cop_name(name, path, warn: true)
-        badge = Badge.parse(name)
-        print_warning(name, path) if warn && department_missing?(badge, name)
-        return name if registered?(badge)
-
-        potential_badges = qualify_badge(badge)
-
-        case potential_badges.size
-        when 0 then name # No namespace found. Deal with it later in caller.
-        when 1 then resolve_badge(badge, potential_badges.first, path)
-        else raise AmbiguousCopName.new(badge, path, potential_badges)
-        end
-      end
-
-      def department_missing?(badge, name)
-        !badge.qualified? && unqualified_cop_names.include?(name)
-      end
-
-      def print_warning(name, path)
-        message = "#{path}: Warning: no department given for #{name}."
-        if path.end_with?('.rb')
-          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
-        end
-        warn message
-      end
-
-      def unqualified_cop_names
-        clear_enrollment_queue
-        @unqualified_cop_names ||=
-          Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
-          'RedundantCopDisableDirective'
-      end
-
-      # @return [Hash{String => Array<Class>}]
-      def to_h
-        clear_enrollment_queue
-        @cops_by_cop_name
-      end
-
-      def cops
-        clear_enrollment_queue
-        @registry.values
-      end
-
-      def length
-        clear_enrollment_queue
-        @registry.size
-      end
-
-      def enabled(config, only = [], only_safe: false)
-        select do |cop|
-          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
-        end
-      end
-
-      def enabled?(cop, config, only_safe)
-        cfg = config.for_cop(cop)
-
-        cop_enabled = cfg.fetch('Enabled') == true ||
-                      enabled_pending_cop?(cfg, config)
-
-        if only_safe
-          cop_enabled && cfg.fetch('Safe', true)
-        else
-          cop_enabled
-        end
-      end
-
-      def enabled_pending_cop?(cop_cfg, config)
-        return false if @options[:disable_pending_cops]
-
-        cop_cfg.fetch('Enabled') == 'pending' &&
-          (@options[:enable_pending_cops] || config.enabled_new_cops?)
-      end
-
-      def names
-        cops.map(&:cop_name)
-      end
-
-      def ==(other)
-        cops == other.cops
-      end
-
-      def sort!
-        clear_enrollment_queue
-        @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
-
-        self
-      end
-
-      def select(&block)
-        cops.select(&block)
-      end
-
-      def each(&block)
-        cops.each(&block)
-      end
-
-      # @param [String] cop_name
-      # @return [Class, nil]
-      def find_by_cop_name(cop_name)
-        to_h[cop_name].first
-      end
-
-      @global = new
-
-      class << self
-        attr_reader :global
-      end
-
-      def self.all
-        global.without_department(:Test).cops
-      end
-
-      def self.qualified_cop_name(name, origin)
-        global.qualified_cop_name(name, origin)
-      end
-
-      # Changes momentarily the global registry
-      # Intended for testing purposes
-      def self.with_temporary_global(temp_global = global.dup)
-        previous = @global
-        @global = temp_global
-        yield
-      ensure
-        @global = previous
-      end
-
-      private
-
-      def initialize_copy(reg)
-        initialize(reg.cops, reg.options)
-      end
-
-      def clear_enrollment_queue
-        return if @enrollment_queue.empty?
-
-        @enrollment_queue.each do |cop|
-          @registry[cop.badge] = cop
-          @departments[cop.department] ||= []
-          @departments[cop.department] << cop
-          @cops_by_cop_name[cop.cop_name] << cop
-        end
-        @enrollment_queue = []
-      end
-
-      def with(cops)
-        self.class.new(cops)
-      end
-
-      def qualify_badge(badge)
-        clear_enrollment_queue
-        @departments
-          .map { |department, _| badge.with_department(department) }
-          .select { |potential_badge| registered?(potential_badge) }
-      end
-
-      def resolve_badge(given_badge, real_badge, source_path)
-        unless given_badge.match?(real_badge)
-          path = PathUtil.smart_path(source_path)
-          warn "#{path}: #{given_badge} has the wrong namespace - " \
-               "should be #{real_badge.department}"
-        end
-
-        real_badge.to_s
-      end
-
-      def registered?(badge)
-        clear_enrollment_queue
-        @registry.key?(badge)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # This cop checks for the use of `Kernel#eval` and `Binding#eval`.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   eval(something)
-      #   binding.eval(something)
-      class Eval < Base
-        MSG = 'The use of `eval` is a serious security risk.'
-        RESTRICT_ON_SEND = %i[eval].freeze
-
-        def_node_matcher :eval?, <<~PATTERN
-          (send {nil? (send nil? :binding)} :eval $!str ...)
-        PATTERN
-
-        def on_send(node)
-          eval?(node) do |code|
-            return if code.dstr_type? && code.recursive_literal?
-
-            add_offense(node.loc.selector)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # This cop checks for the use of JSON class methods which have potential
-      # security issues.
-      #
-      # Autocorrect is disabled by default because it's potentially dangerous.
-      # If using a stream, like `JSON.load(open('file'))`, it will need to call
-      # `#read` manually, like `JSON.parse(open('file').read)`.
-      # If reading single values (rather than proper JSON objects), like
-      # `JSON.load('false')`, it will need to pass the `quirks_mode: true`
-      # option, like `JSON.parse('false', quirks_mode: true)`.
-      # Other similar issues may apply.
-      #
-      # @example
-      #   # bad
-      #   JSON.load("{}")
-      #   JSON.restore("{}")
-      #
-      #   # good
-      #   JSON.parse("{}")
-      #
-      class JSONLoad < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
-        RESTRICT_ON_SEND = %i[load restore].freeze
-
-        def_node_matcher :json_load, <<~PATTERN
-          (send (const {nil? cbase} :JSON) ${:load :restore} ...)
-        PATTERN
-
-        def on_send(node)
-          json_load(node) do |method|
-            add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
-              corrector.replace(node.loc.selector, 'parse')
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # This cop checks for the use of Marshal class methods which have
-      # potential security issues leading to remote code execution when
-      # loading from an untrusted source.
-      #
-      # @example
-      #   # bad
-      #   Marshal.load("{}")
-      #   Marshal.restore("{}")
-      #
-      #   # good
-      #   Marshal.dump("{}")
-      #
-      #   # okish - deep copy hack
-      #   Marshal.load(Marshal.dump({}))
-      #
-      class MarshalLoad < Base
-        MSG = 'Avoid using `Marshal.%<method>s`.'
-        RESTRICT_ON_SEND = %i[load restore].freeze
-
-        def_node_matcher :marshal_load, <<~PATTERN
-          (send (const {nil? cbase} :Marshal) ${:load :restore}
-          !(send (const {nil? cbase} :Marshal) :dump ...))
-        PATTERN
-
-        def on_send(node)
-          marshal_load(node) do |method|
-            add_offense(node.loc.selector, message: format(MSG, method: method))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # This cop checks for the use of `Kernel#open`.
-      #
-      # `Kernel#open` enables not only file access but also process invocation
-      # by prefixing a pipe symbol (e.g., `open("| ls")`). So, it may lead to
-      # a serious security risk by using variable input to the argument of
-      # `Kernel#open`. It would be better to use `File.open`, `IO.popen` or
-      # `URI#open` explicitly.
-      #
-      # @example
-      #   # bad
-      #   open(something)
-      #
-      #   # good
-      #   File.open(something)
-      #   IO.popen(something)
-      #   URI.parse(something).open
-      class Open < Base
-        MSG = 'The use of `Kernel#open` is a serious security risk.'
-        RESTRICT_ON_SEND = %i[open].freeze
-
-        def_node_matcher :open?, <<~PATTERN
-          (send nil? :open $!str ...)
-        PATTERN
-
-        def on_send(node)
-          open?(node) do |code|
-            return if safe?(code)
-
-            add_offense(node.loc.selector)
-          end
-        end
-
-        private
-
-        def safe?(node)
-          if simple_string?(node)
-            safe_argument?(node.str_content)
-          elsif composite_string?(node)
-            safe?(node.children.first)
-          else
-            false
-          end
-        end
-
-        def safe_argument?(argument)
-          !argument.empty? && !argument.start_with?('|')
-        end
-
-        def simple_string?(node)
-          node.str_type?
-        end
-
-        def composite_string?(node)
-          interpolated_string?(node) || concatenated_string?(node)
-        end
-
-        def interpolated_string?(node)
-          node.dstr_type?
-        end
-
-        def concatenated_string?(node)
-          node.send_type? && node.method?(:+) && node.receiver.str_type?
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # This cop checks for the use of YAML class methods which have
-      # potential security issues leading to remote code execution when
-      # loading from an untrusted source.
-      #
-      # @example
-      #   # bad
-      #   YAML.load("--- foo")
-      #
-      #   # good
-      #   YAML.safe_load("--- foo")
-      #   YAML.dump("foo")
-      #
-      class YAMLLoad < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
-        RESTRICT_ON_SEND = %i[load].freeze
-
-        def_node_matcher :yaml_load, <<~PATTERN
-          (send (const {nil? cbase} :YAML) :load ...)
-        PATTERN
-
-        def on_send(node)
-          yaml_load(node) do
-            add_offense(node.loc.selector) do |corrector|
-              corrector.replace(node.loc.selector, 'safe_load')
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Severity class is simple value object about severity
-    class Severity
-      include Comparable
-
-      NAMES = %i[refactor convention warning error fatal].freeze
-
-      # @api private
-      CODE_TABLE = { R: :refactor, C: :convention,
-                     W: :warning, E: :error, F: :fatal }.freeze
-
-      # @api public
-      #
-      # @!attribute [r] name
-      #
-      # @return [Symbol]
-      #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
-      attr_reader :name
-
-      def self.name_from_code(code)
-        name = code.to_sym
-        CODE_TABLE[name] || name
-      end
-
-      # @api private
-      def initialize(name_or_code)
-        name = Severity.name_from_code(name_or_code)
-        raise ArgumentError, "Unknown severity: #{name}" unless NAMES.include?(name)
-
-        @name = name.freeze
-        freeze
-      end
-
-      def to_s
-        @name.to_s
-      end
-
-      def code
-        @name.to_s[0].upcase
-      end
-
-      def level
-        NAMES.index(name) + 1
-      end
-
-      def ==(other)
-        @name == if other.is_a?(Symbol)
-                   other
-                 else
-                   other.name
-                 end
-      end
-
-      def hash
-        @name.hash
-      end
-
-      def <=>(other)
-        level <=> other.level
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Access modifiers should be declared to apply to a group of methods
-      # or inline before each method, depending on configuration.
-      # EnforcedStyle config covers only method definitions.
-      # Applications of visibility methods to symbols can be controlled
-      # using AllowModifiersOnSymbols config.
-      #
-      # @example EnforcedStyle: group (default)
-      #   # bad
-      #   class Foo
-      #
-      #     private def bar; end
-      #     private def baz; end
-      #
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #
-      #     private
-      #
-      #     def bar; end
-      #     def baz; end
-      #
-      #   end
-      #
-      # @example EnforcedStyle: inline
-      #   # bad
-      #   class Foo
-      #
-      #     private
-      #
-      #     def bar; end
-      #     def baz; end
-      #
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #
-      #     private def bar; end
-      #     private def baz; end
-      #
-      #   end
-      #
-      # @example AllowModifiersOnSymbols: true
-      #   # good
-      #   class Foo
-      #
-      #     private :bar, :baz
-      #
-      #   end
-      #
-      # @example AllowModifiersOnSymbols: false
-      #   # bad
-      #   class Foo
-      #
-      #     private :bar, :baz
-      #
-      #   end
-      class AccessModifierDeclarations < Base
-        include ConfigurableEnforcedStyle
-
-        GROUP_STYLE_MESSAGE = [
-          '`%<access_modifier>s` should not be',
-          'inlined in method definitions.'
-        ].join(' ')
-
-        INLINE_STYLE_MESSAGE = [
-          '`%<access_modifier>s` should be',
-          'inlined in method definitions.'
-        ].join(' ')
-
-        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
-
-        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public} (sym _))
-        PATTERN
-
-        def on_send(node)
-          return unless node.access_modifier?
-          return if node.parent.pair_type?
-          return if cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
-
-          if offense?(node)
-            add_offense(node.loc.selector) if opposite_style_detected
-          else
-            correct_style_detected
-          end
-        end
-
-        private
-
-        def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
-            (inline_style? && access_modifier_is_not_inlined?(node))
-        end
-
-        def group_style?
-          style == :group
-        end
-
-        def inline_style?
-          style == :inline
-        end
-
-        def access_modifier_is_inlined?(node)
-          node.arguments.any?
-        end
-
-        def access_modifier_is_not_inlined?(node)
-          !access_modifier_is_inlined?(node)
-        end
-
-        def message(range)
-          access_modifier = range.source
-
-          if group_style?
-            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
-          elsif inline_style?
-            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
-          end
-        end
-      end
-    end
-  end
-end