tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/middleware/follow_redirects.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'set'
+
+# Adapted from lostisland/faraday_middleware. Trimmed down to just the logic
+# that we need for octokit.rb.
+#
+# https://github.com/lostisland/faraday_middleware/blob/138766e/lib/faraday_middleware/response/follow_redirects.rb
+
+module Octokit
+  module Middleware
+    # Public: Exception thrown when the maximum amount of requests is exceeded.
+    class RedirectLimitReached < Faraday::ClientError
+      attr_reader :response
+
+      def initialize(response)
+        super "too many redirects; last one to: #{response['location']}"
+        @response = response
+      end
+    end
+
+    # Public: Follow HTTP 301, 302, 303, and 307 redirects.
+    #
+    # For HTTP 303, the original GET, POST, PUT, DELETE, or PATCH request gets
+    # converted into a GET. For HTTP 301, 302, and 307, the HTTP method remains
+    # unchanged.
+    #
+    # This middleware currently only works with synchronous requests; i.e. it
+    # doesn't support parallelism.
+    class FollowRedirects < Faraday::Middleware
+      # HTTP methods for which 30x redirects can be followed
+      ALLOWED_METHODS = Set.new %i[head options get post put patch delete]
+
+      # HTTP redirect status codes that this middleware implements
+      REDIRECT_CODES  = Set.new [301, 302, 303, 307]
+
+      # Keys in env hash which will get cleared between requests
+      ENV_TO_CLEAR    = Set.new %i[status response response_headers]
+
+      # Default value for max redirects followed
+      FOLLOW_LIMIT = 3
+
+      # Regex that matches characters that need to be escaped in URLs, sans
+      # the "%" character which we assume already represents an escaped
+      # sequence.
+      URI_UNSAFE = %r{[^\-_.!~*'()a-zA-Z\d;/?:@&=+$,\[\]%]}.freeze
+
+      # Public: Initialize the middleware.
+      #
+      # options - An options Hash (default: {}):
+      #           :limit               - A Integer redirect limit (default: 3).
+      def initialize(app, options = {})
+        super(app)
+        @options = options
+
+        @convert_to_get = Set.new [303]
+      end
+
+      def call(env)
+        perform_with_redirection(env, follow_limit)
+      end
+
+      private
+
+      def convert_to_get?(response)
+        !%i[head options].include?(response.env[:method]) &&
+          @convert_to_get.include?(response.status)
+      end
+
+      def perform_with_redirection(env, follows)
+        request_body = env[:body]
+        response = @app.call(env)
+
+        response.on_complete do |response_env|
+          if follow_redirect?(response_env, response)
+            raise(RedirectLimitReached, response) if follows.zero?
+
+            new_request_env = update_env(response_env, request_body, response)
+            response = perform_with_redirection(new_request_env, follows - 1)
+          end
+        end
+        response
+      end
+
+      def update_env(env, request_body, response)
+        original_url = env[:url]
+        env[:url] += safe_escape(response['location'])
+        unless same_host?(original_url, env[:url])
+          # HACK: Faraday’s Authorization middlewares don’t touch the request if the `Authorization` header is set.
+          #       This is a workaround to drop authentication info.
+          #       See https://github.com/octokit/octokit.rb/pull/1359#issuecomment-925609697
+          env[:request_headers]['Authorization'] = 'dummy'
+        end
+
+        if convert_to_get?(response)
+          env[:method] = :get
+          env[:body] = nil
+        else
+          env[:body] = request_body
+        end
+
+        ENV_TO_CLEAR.each { |key| env.delete(key) }
+
+        env
+      end
+
+      def follow_redirect?(env, response)
+        ALLOWED_METHODS.include?(env[:method]) &&
+          REDIRECT_CODES.include?(response.status)
+      end
+
+      def follow_limit
+        @options.fetch(:limit, FOLLOW_LIMIT)
+      end
+
+      def same_host?(original_url, redirect_url)
+        original_uri = Addressable::URI.parse(original_url)
+        redirect_uri = Addressable::URI.parse(redirect_url)
+
+        redirect_uri.host.nil? || original_uri.host == redirect_uri.host
+      end
+
+      # Internal: Escapes unsafe characters from a URL which might be a path
+      # component only or a fully-qualified URI so that it can be joined onto a
+      # URI:HTTP using the `+` operator. Doesn't escape "%" characters so to not
+      # risk double-escaping.
+      def safe_escape(uri)
+        uri.to_s.gsub(URI_UNSAFE) do |match|
+          "%#{match.unpack('H2' * match.bytesize).join('%').upcase}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/organization.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Octokit
+  # GitHub organization class to generate API path urls
+  class Organization
+    # Get the api path for an organization
+    #
+    # @param org [String, Integer] GitHub organization login or id
+    # @return [String] Organization Api path
+    def self.path(org)
+      case org
+      when String
+        "orgs/#{org}"
+      when Integer
+        "organizations/#{org}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/rate_limit.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Octokit
+  # Class for API Rate Limit info
+  #
+  # @!attribute [w] limit
+  #   @return [Integer] Max tries per rate limit period
+  # @!attribute [w] remaining
+  #   @return [Integer] Remaining tries per rate limit period
+  # @!attribute [w] resets_at
+  #   @return [Time] Indicates when rate limit resets
+  # @!attribute [w] resets_in
+  #   @return [Integer] Number of seconds when rate limit resets
+  #
+  # @see https://developer.github.com/v3/#rate-limiting
+  class RateLimit < Struct.new(:limit, :remaining, :resets_at, :resets_in)
+    # Get rate limit info from HTTP response
+    #
+    # @param response [#headers] HTTP response
+    # @return [RateLimit]
+    def self.from_response(response)
+      info = new
+      if response.respond_to?(:headers) && !response.headers.nil?
+        info.limit = (response.headers['X-RateLimit-Limit'] || 1).to_i
+        info.remaining = (response.headers['X-RateLimit-Remaining'] || 1).to_i
+        info.resets_at = Time.at((response.headers['X-RateLimit-Reset'] || Time.now).to_i)
+        info.resets_in = [(info.resets_at - Time.now).to_i, 0].max
+      end
+
+      info
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/repo_arguments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Octokit
+  # Class to extract options from Ruby arguments for
+  # Repository-related methods
+  class RepoArguments < Arguments
+    # !@attribute [r] repo
+    #   @return [Repository]
+    attr_reader :repo
+
+    def initialize(args)
+      arguments = super(args)
+      @repo = arguments.shift
+
+      arguments
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/repository.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Octokit
+  # Class to parse GitHub repository owner and name from
+  # URLs and to generate URLs
+  class Repository
+    attr_accessor :owner, :name, :id
+
+    NAME_WITH_OWNER_PATTERN = %r{\A[\w.-]+/[\w.-]+\z}i.freeze
+
+    # Instantiate from a GitHub repository URL
+    #
+    # @return [Repository]
+    def self.from_url(url)
+      new URI.parse(url).path[1..-1]
+             .gsub(%r{^repos/}, '')
+             .split('/', 3)[0..1]
+             .join('/')
+    end
+
+    # @raise [Octokit::InvalidRepository] if the repository
+    #   has an invalid format
+    def initialize(repo)
+      case repo
+      when Integer
+        @id = repo
+      when NAME_WITH_OWNER_PATTERN
+        @owner, @name = repo.split('/')
+      when Repository
+        @owner = repo.owner
+        @name = repo.name
+      when Hash
+        @name = repo[:repo] || repo[:name]
+        @owner = repo[:owner] || repo[:user] || repo[:username]
+      else
+        raise_invalid_repository!(repo)
+      end
+      validate_owner_and_name!(repo) if @owner && @name
+    end
+
+    # Repository owner/name
+    # @return [String]
+    def slug
+      "#{@owner}/#{@name}"
+    end
+    alias to_s slug
+
+    # @return [String] Repository API path
+    def path
+      return named_api_path if @owner && @name
+      return id_api_path if @id
+    end
+
+    # Get the api path for a repo
+    # @param repo [Integer, String, Hash, Repository] A GitHub repository.
+    # @return [String] Api path.
+    def self.path(repo)
+      new(repo).path
+    end
+
+    # @return [String] Api path for owner/name identified repos
+    def named_api_path
+      "repos/#{slug}"
+    end
+
+    # @return [String] Api path for id identified repos
+    def id_api_path
+      "repositories/#{@id}"
+    end
+
+    # Repository URL based on {Octokit::Client#web_endpoint}
+    # @return [String]
+    def url
+      "#{Octokit.web_endpoint}#{slug}"
+    end
+
+    alias user owner
+    alias username owner
+    alias repo name
+
+    private
+
+    def validate_owner_and_name!(repo)
+      if @owner.include?('/') || @name.include?('/') || !url.match(URI::ABS_URI)
+        raise_invalid_repository!(repo)
+      end
+    end
+
+    def raise_invalid_repository!(repo)
+      msg = "#{repo.inspect} is invalid as a repository identifier. " \
+            'Use the user/repo (String) format, or the repository ID (Integer), or a hash containing :repo and :user keys.'
+      raise Octokit::InvalidRepository, msg
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/response/base_middleware.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Octokit
+  module Response
+    # In Faraday 2.x, Faraday::Response::Middleware was removed
+    BaseMiddleware = defined?(Faraday::Response::Middleware) ? Faraday::Response::Middleware : Faraday::Middleware
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/response/feed_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'octokit/response/base_middleware'
+
+module Octokit
+  module Response
+    # Parses RSS and Atom feed responses.
+    class FeedParser < BaseMiddleware
+      def on_complete(env)
+        if env[:response_headers]['content-type'] =~ /(\batom|\brss)/
+          require 'rss'
+          env[:body] = RSS::Parser.parse env[:body]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/response/raise_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'octokit/response/base_middleware'
+require 'octokit/error'
+
+module Octokit
+  # Faraday response middleware
+  module Response
+    # This class raises an Octokit-flavored exception based
+    # HTTP status codes returned by the API
+    class RaiseError < BaseMiddleware
+      def on_complete(response)
+        if error = Octokit::Error.from_response(response)
+          raise error
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/user.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Octokit
+  # GitHub user class to generate API path urls
+  class User
+    # Get the api path for a user
+    #
+    # @param user [String, Integer] GitHub user login or id
+    # @return [String] User Api path
+    def self.path(user)
+      case user
+      when String
+        "users/#{user}"
+      when Integer
+        "user/#{user}"
+      else
+        'user'
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Octokit
+  # Current major release.
+  # @return [Integer]
+  MAJOR = 5
+
+  # Current minor release.
+  # @return [Integer]
+  MINOR = 3
+
+  # Current patch level.
+  # @return [Integer]
+  PATCH = 0
+
+  # Full release version.
+  # @return [String]
+  VERSION = [MAJOR, MINOR, PATCH].join('.').freeze
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit/warnable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Octokit
+  # Allows warnings to be suppressed via environment variable.
+  module Warnable
+    module_function
+
+    # Wrapper around Kernel#warn to print warnings unless
+    # OCTOKIT_SILENT is set to true.
+    #
+    # @return [nil]
+    def octokit_warn(*message)
+      warn message unless ENV['OCTOKIT_SILENT']
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/lib/octokit.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'octokit/default'
+require 'octokit/client'
+require 'octokit/enterprise_admin_client'
+require 'octokit/enterprise_management_console_client'
+
+# Ruby toolkit for the GitHub API
+module Octokit
+  class << self
+    include Octokit::Configurable
+
+    # API client based on configured options {Configurable}
+    #
+    # @return [Octokit::Client] API wrapper
+    def client
+      return @client if defined?(@client) && @client.same_options?(options)
+
+      @client = Octokit::Client.new(options)
+    end
+
+    # EnterpriseAdminClient client based on configured options {Configurable}
+    #
+    # @return [Octokit::EnterpriseAdminClient] API wrapper
+    def enterprise_admin_client
+      if defined?(@enterprise_admin_client) && @enterprise_admin_client.same_options?(options)
+        return @enterprise_admin_client
+      end
+
+      @enterprise_admin_client = Octokit::EnterpriseAdminClient.new(options)
+    end
+
+    # EnterpriseManagementConsoleClient client based on configured options {Configurable}
+    #
+    # @return [Octokit::EnterpriseManagementConsoleClient] API wrapper
+    def enterprise_management_console_client
+      if defined?(@enterprise_management_console_client) && @enterprise_management_console_client.same_options?(options)
+        return @enterprise_management_console_client
+      end
+
+      @enterprise_management_console_client = Octokit::EnterpriseManagementConsoleClient.new(options)
+    end
+
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      client.respond_to?(method_name, include_private) ||
+        enterprise_admin_client.respond_to?(method_name, include_private) ||
+        enterprise_management_console_client.respond_to?(method_name, include_private)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if client.respond_to?(method_name)
+        return client.send(method_name, *args, &block)
+      elsif enterprise_admin_client.respond_to?(method_name)
+        return enterprise_admin_client.send(method_name, *args, &block)
+      elsif enterprise_management_console_client.respond_to?(method_name)
+        return enterprise_management_console_client.send(method_name, *args, &block)
+      end
+
+      super
+    end
+  end
+end
+
+Octokit.setup

data/vendor/bundle/ruby/3.1.0/gems/octokit-5.3.0/octokit.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'octokit/version'
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '>= 1', '< 3'
+  spec.add_dependency 'faraday', '>= 1', '< 3'
+  spec.add_dependency 'sawyer', '~> 0.9'
+  spec.authors = ['Wynn Netherland', 'Erik Michaels-Ober', 'Clint Shryock']
+  spec.description = 'Simple wrapper for the GitHub API'
+  spec.email = ['wynn.netherland@gmail.com', 'sferik@gmail.com', 'clint@ctshryock.com']
+  spec.files = %w[.document CONTRIBUTING.md LICENSE.md README.md Rakefile octokit.gemspec]
+  spec.files += Dir.glob('lib/**/*.rb')
+  spec.homepage = 'https://github.com/octokit/octokit.rb'
+  spec.licenses = ['MIT']
+  spec.name = 'octokit'
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.summary = 'Ruby toolkit for working with the GitHub API'
+  spec.version = Octokit::VERSION.dup
+  spec.metadata = { 'rubygems_mfa_required' => 'true' }
+end