phillipug-foodie 0.1.0

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/constant_resolution.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check that certain constants are fully qualified.
+      #
+      # This is not enabled by default because it would mark a lot of offenses
+      # unnecessarily.
+      #
+      # Generally, gems should fully qualify all constants to avoid conflicts with
+      # the code that uses the gem. Enable this cop without using `Only`/`Ignore`
+      #
+      # Large projects will over time end up with one or two constant names that
+      # are problematic because of a conflict with a library or just internally
+      # using the same name a namespace and a class. To avoid too many unnecessary
+      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      #
+      # @example
+      #   # By default checks every constant
+      #
+      #   # bad
+      #   User
+      #
+      #   # bad
+      #   User::Login
+      #
+      #   # good
+      #   ::User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      # @example Only: ['Login']
+      #   # Restrict this cop to only being concerned about certain constants
+      #
+      #   # bad
+      #   Login
+      #
+      #   # good
+      #   ::Login
+      #
+      #   # good
+      #   User::Login
+      #
+      # @example Ignore: ['Login']
+      #   # Restrict this cop not being concerned about certain constants
+      #
+      #   # bad
+      #   User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      #   # good
+      #   Login
+      #
+      class ConstantResolution < Base
+        MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
+
+        # @!method unqualified_const?(node)
+        def_node_matcher :unqualified_const?, <<~PATTERN
+          (const nil? #const_name?)
+        PATTERN
+
+        def on_const(node)
+          return if !unqualified_const?(node) || node.parent&.defined_module
+
+          add_offense(node)
+        end
+
+        private
+
+        def const_name?(name)
+          name = name.to_s
+          (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)
+        end
+
+        def allowed_names
+          cop_config['Only']
+        end
+
+        def ignored_names
+          cop_config['Ignore']
+        end
+      end
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/debugger.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
+      # `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   WebConsole: ~
+      # ----
+      #
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using pry
+      #   def some_method
+      #     binding.pry
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using byebug
+      #   def some_method
+      #     byebug
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   def some_method
+      #     my_debugger
+      #   end
+      class Debugger < Base
+        MSG = 'Remove debugger entry point `%<source>s`.'
+
+        # @!method kernel?(node)
+        def_node_matcher :kernel?, <<~PATTERN
+          (const {nil? cbase} :Kernel)
+        PATTERN
+
+        # @!method valid_receiver?(node, arg1)
+        def_node_matcher :valid_receiver?, <<~PATTERN
+          {
+            (const {nil? cbase} %1)
+            (send {nil? #kernel?} %1)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless debugger_method?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            values = config.is_a?(Array) ? config : config.values.flatten
+            values.map do |v|
+              next unless v
+
+              *receiver, method_name = v.split('.')
+              {
+                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                method_name: method_name.to_sym
+              }
+            end.compact
+          end
+        end
+
+        def debugger_method?(send_node)
+          debugger_methods.any? do |method|
+            next unless method[:method_name] == send_node.method_name
+
+            if method[:receiver].nil?
+              send_node.receiver.nil?
+            else
+              valid_receiver?(send_node.receiver, method[:receiver])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of the deprecated class method usages.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   File.exists?(some_path)
+      #   Dir.exists?(some_path)
+      #   iterator?
+      #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+      #   Socket.gethostbyname(host)
+      #   Socket.gethostbyaddr(host)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   File.exist?(some_path)
+      #   Dir.exist?(some_path)
+      #   block_given?
+      #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+      #   Addrinfo.getaddrinfo(nodename, service)
+      #   Addrinfo.tcp(host, port).getnameinfo
+      class DeprecatedClassMethods < Base
+        extend AutoCorrector
+
+        # Inner class to DeprecatedClassMethods.
+        # This class exists to add abstraction and clean naming
+        # to the deprecated objects
+        class DeprecatedClassMethod
+          include RuboCop::AST::Sexp
+
+          attr_reader :method, :class_constant
+
+          def initialize(method, class_constant: nil, correctable: true)
+            @method = method
+            @class_constant = class_constant
+            @correctable = correctable
+          end
+
+          def class_nodes
+            @class_nodes ||=
+              if class_constant
+                [
+                  s(:const, nil, class_constant),
+                  s(:const, s(:cbase), class_constant)
+                ]
+              else
+                [nil]
+              end
+          end
+
+          def correctable?
+            @correctable
+          end
+
+          def to_s
+            [class_constant, method].compact.join(delimiter)
+          end
+
+          private
+
+          def delimiter
+            CLASS_METHOD_DELIMETER
+          end
+        end
+
+        # Inner class to DeprecatedClassMethods.
+        # This class exists to add abstraction and clean naming
+        # to the replacements for deprecated objects
+        class Replacement
+          attr_reader :method, :class_constant
+
+          def initialize(method, class_constant: nil, instance_method: false)
+            @method = method
+            @class_constant = class_constant
+            @instance_method = instance_method
+          end
+
+          def to_s
+            [class_constant, method].compact.join(delimiter)
+          end
+
+          private
+
+          def delimiter
+            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
+          end
+
+          def instance_method?
+            @instance_method
+          end
+        end
+
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
+
+        DEPRECATED_METHODS_OBJECT = {
+          DeprecatedClassMethod.new(:exists?, class_constant: :File) =>
+            Replacement.new(:exist?, class_constant: :File),
+
+          DeprecatedClassMethod.new(:exists?, class_constant: :Dir) =>
+            Replacement.new(:exist?, class_constant: :Dir),
+
+          DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
+
+          DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
+            Replacement.new(nil, class_constant: :ENV),
+
+          DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
+            Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
+
+          DeprecatedClassMethod.new(:gethostbyname, class_constant: :Socket, correctable: false) =>
+            Replacement.new(:getaddrinfo, class_constant: :Addrinfo, instance_method: true)
+        }.freeze
+
+        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
+
+        CLASS_METHOD_DELIMETER = '.'
+        INSTANCE_METHOD_DELIMETER = '#'
+
+        def on_send(node)
+          check(node) do |deprecated|
+            prefer = replacement(deprecated)
+            message = format(MSG, current: deprecated, prefer: prefer)
+            current_method = node.loc.selector
+
+            add_offense(current_method, message: message) do |corrector|
+              next unless deprecated.correctable?
+
+              if (preferred_method = prefer.method)
+                corrector.replace(current_method, preferred_method)
+              else
+                corrector.remove(node.loc.dot)
+                corrector.remove(current_method)
+              end
+            end
+          end
+        end
+
+        private
+
+        def check(node)
+          DEPRECATED_METHODS_OBJECT.each_key do |deprecated|
+            next unless deprecated.class_nodes.include?(node.receiver)
+            next unless node.method?(deprecated.method)
+
+            yield deprecated
+          end
+        end
+
+        def replacement(deprecated)
+          DEPRECATED_METHODS_OBJECT[deprecated]
+        end
+      end
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/deprecated_constants.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for deprecated constants.
+      #
+      # It has `DeprecatedConstants` config. If there is an alternative method, you can set
+      # alternative value as `Alternative`. And you can set the deprecated version as
+      # `DeprecatedVersion`. These options can be omitted if they are not needed.
+      #
+      #   DeprecatedConstants:
+      #     'DEPRECATED_CONSTANT':
+      #       Alternative: 'alternative_value'
+      #       DeprecatedVersion: 'deprecated_version'
+      #
+      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      #
+      # @example
+      #
+      #   # bad
+      #   NIL
+      #   TRUE
+      #   FALSE
+      #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #
+      #   # good
+      #   nil
+      #   true
+      #   false
+      #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #
+      class DeprecatedConstants < Base
+        extend AutoCorrector
+
+        SUGGEST_GOOD_MSG = 'Use `%<good>s` instead of `%<bad>s`%<deprecated_message>s.'
+        DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
+
+        def on_const(node)
+          # FIXME: Workaround for "`undefined method `expression' for nil:NilClass`" when processing
+          #        `__ENCODING__`. It is better to be able to work without this condition.
+          #        Maybe further investigation of RuboCop AST will lead to an essential solution.
+          return unless node.loc
+
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          return unless (deprecated_constant = deprecated_constants[constant])
+
+          alternative = deprecated_constant['Alternative']
+          version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
+
+          add_offense(node, message: message(alternative, node.source, version)) do |corrector|
+            corrector.replace(node, alternative)
+          end
+        end
+
+        private
+
+        def constant_name(node, nested_constant_name)
+          return nested_constant_name.to_s unless node.namespace.const_type?
+
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+        end
+
+        def message(good, bad, deprecated_version)
+          deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
+
+          if good
+            format(SUGGEST_GOOD_MSG, good: good, bad: bad, deprecated_message: deprecated_message)
+          else
+            format(DO_NOT_USE_MSG, bad: bad, deprecated_message: deprecated_message)
+          end
+        end
+
+        def deprecated_constants
+          cop_config.fetch('DeprecatedConstants', {})
+        end
+      end
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+      # deprecated since OpenSSL version 2.2.0. Prefer passing a string
+      # instead.
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Cipher instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Cipher::AES.new(128, :GCM)
+      #
+      #   # good
+      #   OpenSSL::Cipher.new('aes-128-gcm')
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Digest instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.new
+      #
+      #   # good
+      #   OpenSSL::Digest.new('SHA256')
+      #
+      # @example
+      #
+      #   # Example for ::Digest inherited class methods.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.digest('foo')
+      #
+      #   # good
+      #   OpenSSL::Digest.digest('SHA256', 'foo')
+      #
+      class DeprecatedOpenSSLConstant < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
+
+        NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
+
+        # @!method algorithm_const(node)
+        def_node_matcher :algorithm_const, <<~PATTERN
+          (send
+            $(const
+              (const
+                (const {nil? cbase} :OpenSSL) {:Cipher :Digest})
+              _)
+            ...)
+        PATTERN
+
+        # @!method digest_const?(node)
+        def_node_matcher :digest_const?, <<~PATTERN
+          (const _ :Digest)
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if digest_const?(node.receiver)
+          return unless algorithm_const(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          algorithm_constant, = algorithm_const(node)
+
+          corrector.remove(algorithm_constant.loc.double_colon)
+          corrector.remove(algorithm_constant.loc.name)
+
+          corrector.replace(
+            correction_range(node),
+            "#{node.loc.selector.source}(#{replacement_args(node)})"
+          )
+        end
+
+        def message(node)
+          algorithm_constant, = algorithm_const(node)
+          parent_constant = openssl_class(algorithm_constant)
+          replacement_args = replacement_args(node)
+          method = node.loc.selector.source
+
+          format(
+            MSG,
+            constant: parent_constant,
+            method: method,
+            replacement_args: replacement_args,
+            original: node.source
+          )
+        end
+
+        def correction_range(node)
+          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+        end
+
+        def openssl_class(node)
+          node.children.first.source
+        end
+
+        def algorithm_name(node)
+          name = node.loc.name.source
+
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
+            name.scan(/.{3}/).join('-')
+          else
+            name
+          end
+        end
+
+        def sanitize_arguments(arguments)
+          arguments.flat_map do |arg|
+            argument = arg.str_type? ? arg.value : arg.source
+
+            argument.tr(":'", '').split('-')
+          end
+        end
+
+        def replacement_args(node)
+          algorithm_constant, = algorithm_const(node)
+          algorithm_name = algorithm_name(algorithm_constant)
+
+          if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' unless size_and_mode == ['cbc']
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
+        end
+      end
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks constructors for disjunctive assignments (`||=`) that should
+      # be plain assignments.
+      #
+      # So far, this cop is only concerned with disjunctive assignment of
+      # instance variables.
+      #
+      # In ruby, an instance variable is nil until a value is assigned, so the
+      # disjunction is unnecessary. A plain assignment has the same effect.
+      #
+      # @safety
+      #   This cop is unsafe because it can register a false positive when a
+      #   method is redefined in a subclass that calls super. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Base
+      #     def initialize
+      #       @config ||= 'base'
+      #     end
+      #   end
+      #
+      #   class Derived < Base
+      #     def initialize
+      #       @config = 'derived'
+      #       super
+      #     end
+      #   end
+      #   ----
+      #
+      #   Without the disjunctive assignment, `Derived` will be unable to override
+      #   the value for `@config`.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     @x ||= 1
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     @x = 1
+      #   end
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
+
+        def on_def(node)
+          check(node)
+        end
+
+        private
+
+        # @param [DefNode] node a constructor definition
+        def check(node)
+          return unless node.method?(:initialize)
+
+          check_body(node.body)
+        end
+
+        def check_body(body)
+          return if body.nil?
+
+          case body.type
+          when :begin
+            check_body_lines(body.child_nodes)
+          else
+            check_body_lines([body])
+          end
+        end
+
+        # @param [Array] lines the logical lines of the constructor
+        def check_body_lines(lines)
+          lines.each do |line|
+            case line.type
+            when :or_asgn
+              check_disjunctive_assignment(line)
+            else
+              # Once we encounter something other than a disjunctive
+              # assignment, we cease our investigation, because we can't be
+              # certain that any future disjunctive assignments are offensive.
+              # You're off the case, detective!
+              break
+            end
+          end
+        end
+
+        # Add an offense if the LHS of the given disjunctive assignment is
+        # an instance variable.
+        #
+        # For now, we only care about assignments to instance variables.
+        #
+        # @param [Node] node a disjunctive assignment
+        def check_disjunctive_assignment(node)
+          lhs = node.child_nodes.first
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end