tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/octokit-4.23.0/lib/octokit/enterprise_management_console_client/management_console.rb

@@ -1,176 +0,0 @@
-module Octokit
-  class EnterpriseManagementConsoleClient
-
-    # Methods for the Enterprise Management Console API
-    #
-    # @see https://developer.github.com/v3/enterprise-admin/management_console/
-    module ManagementConsole
-
-      # Uploads a license for the first time
-      #
-      # @param license [String] The path to your .ghl license file.
-      # @param settings [Hash] A hash configuration of the initial settings.
-      #
-      # @see https://docs.github.com/en/enterprise-server@3.4/rest/enterprise-admin/management-console#create-a-github-license
-      # @return nil
-      def upload_license(license, settings = nil)
-        conn = faraday_configuration
-
-        params = { }
-        params[:license] = Faraday::UploadIO.new(license, 'binary')
-        params[:password] = @management_console_password
-        params[:settings] = "#{settings.to_json}" unless settings.nil?
-
-        @last_response = conn.post("/setup/api/start", params)
-      end
-
-      # Start a configuration process.
-      #
-      # @return nil
-      def start_configuration
-        post "/setup/api/configure", password_hash
-      end
-
-      # Upgrade an Enterprise installation
-      #
-      # @param license [String] The path to your .ghl license file.
-      #
-      # @return nil
-      def upgrade(license)
-        conn = faraday_configuration
-
-        params = { }
-        params[:license] = Faraday::UploadIO.new(license, 'binary')
-        params[:api_key] = @management_console_password
-        @last_response = conn.post("/setup/api/upgrade", params)
-      end
-
-      # Get information about the Enterprise installation
-      #
-      # @return [Sawyer::Resource] The installation information
-      def config_status
-        get "/setup/api/configcheck", password_hash
-      end
-      alias :config_check :config_status
-
-      # Get information about the Enterprise installation
-      #
-      # @return [Sawyer::Resource] The settings
-      def settings
-        get "/setup/api/settings", password_hash
-      end
-      alias :get_settings :settings
-
-      # Modify the Enterprise settings
-      #
-      # @param settings [Hash] A hash configuration of the new settings
-      #
-      # @return [nil]
-      def edit_settings(settings)
-        queries = password_hash
-        queries[:query][:settings] = "#{settings.to_json}"
-        put "/setup/api/settings", queries
-      end
-
-      # Get information about the Enterprise maintenance status
-      #
-      # @return [Sawyer::Resource] The maintenance status
-      def maintenance_status
-        get "/setup/api/maintenance", password_hash
-      end
-      alias :get_maintenance_status :maintenance_status
-
-      # Start (or turn off) the Enterprise maintenance mode
-      #
-      # @param maintenance [Hash] A hash configuration of the maintenance settings
-      # @return [nil]
-      def set_maintenance_status(maintenance)
-        queries = password_hash
-        queries[:query][:maintenance] = "#{maintenance.to_json}"
-        post "/setup/api/maintenance", queries
-      end
-      alias :edit_maintenance_status :set_maintenance_status
-
-      # Fetch the authorized SSH keys on the Enterprise install
-      #
-      # @return [Sawyer::Resource] An array of authorized SSH keys
-      def authorized_keys
-        get "/setup/api/settings/authorized-keys", password_hash
-      end
-      alias :get_authorized_keys :authorized_keys
-
-      # Add an authorized SSH keys on the Enterprise install
-      #
-      # @param key Either the file path to a key, a File handler to the key, or the contents of the key itself
-      # @return [Sawyer::Resource] An array of authorized SSH keys
-      def add_authorized_key(key)
-        queries = password_hash
-        case key
-        when String
-          if File.exist?(key)
-            key = File.open(key, "r")
-            content = key.read.strip
-            key.close
-          else
-            content = key
-          end
-        when File
-          content = key.read.strip
-          key.close
-        end
-
-        queries[:query][:authorized_key] = content
-        post "/setup/api/settings/authorized-keys", queries
-      end
-
-      # Removes an authorized SSH keys from the Enterprise install
-      #
-      # @param key Either the file path to a key, a File handler to the key, or the contents of the key itself
-      # @return [Sawyer::Resource] An array of authorized SSH keys
-      def remove_authorized_key(key)
-        queries = password_hash
-        case key
-        when String
-          if File.exist?(key)
-            key = File.open(key, "r")
-            content = key.read.strip
-            key.close
-          else
-            content = key
-          end
-        when File
-          content = key.read.strip
-          key.close
-        end
-
-        queries[:query][:authorized_key] = content
-        delete "/setup/api/settings/authorized-keys", queries
-      end
-      alias :delete_authorized_key :remove_authorized_key
-
-    end
-    private
-
-    def password_hash
-      { :query => { :api_key => @management_console_password } }
-    end
-
-    # We fall back to raw Faraday for handling the licenses because I'm suspicious
-    # that Sawyer isn't handling binary POSTs correctly: https://github.com/lostisland/sawyer/blob/03fca4c020f465ec42856d0486ec3991859b0aed/lib/sawyer/agent.rb#L85
-    def faraday_configuration
-      @faraday_configuration ||= Faraday.new(:url => @management_console_endpoint) do |http|
-        http.headers[:user_agent] = user_agent
-        http.request :multipart
-        http.request :url_encoded
-
-        # Disabling SSL is essential for certain self-hosted Enterprise instances
-        if self.connection_options[:ssl] && !self.connection_options[:ssl][:verify]
-          http.ssl[:verify] = false
-        end
-
-        http.use Octokit::Response::RaiseError
-        http.adapter Faraday.default_adapter
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'octokit/configurable'
-require 'octokit/connection'
-require 'octokit/warnable'
-require 'octokit/enterprise_management_console_client/management_console'
-
-module Octokit
-
-  # EnterpriseManagementConsoleClient is only meant to be used by GitHub Enterprise Admins
-  # and provides access to the management console API endpoints.
-  #
-  # @see Octokit::Client Use Octokit::Client for regular API use for GitHub
-  #   and GitHub Enterprise.
-  # @see https://developer.github.com/v3/enterprise-admin/management_console/
-  class EnterpriseManagementConsoleClient
-
-    include Octokit::Configurable
-    include Octokit::Connection
-    include Octokit::Warnable
-    include Octokit::EnterpriseManagementConsoleClient::ManagementConsole
-
-    def initialize(options = {})
-      # Use options passed in, but fall back to module defaults
-      Octokit::Configurable.keys.each do |key|
-        instance_variable_set(:"@#{key}", options[key] || Octokit.instance_variable_get(:"@#{key}"))
-      end
-    end
-
-    protected
-
-    def endpoint
-      management_console_endpoint
-    end
-
-    # Set Enterprise Management Console password
-    #
-    # @param value [String] Management console admin password
-    def management_console_password=(value)
-      reset_agent
-      @management_console_password = value
-    end
-
-    # Set Enterprise Management Console endpoint
-    #
-    # @param value [String] Management console endpoint
-    def management_console_endpoint=(value)
-      reset_agent
-      @management_console_endpoint = value
-    end
-  end
-end

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

@@ -1,354 +0,0 @@
-module Octokit
-  # Custom error class for rescuing from all GitHub errors
-  class Error < StandardError
-    attr_reader :context
-    # Returns the appropriate Octokit::Error subclass based
-    # on status and response message
-    #
-    # @param [Hash] response HTTP response
-    # @return [Octokit::Error]
-    def self.from_response(response)
-      status  = response[:status].to_i
-      body    = response[:body].to_s
-      headers = response[:response_headers]
-
-      if klass =  case status
-                  when 400      then Octokit::BadRequest
-                  when 401      then error_for_401(headers)
-                  when 403      then error_for_403(body)
-                  when 404      then error_for_404(body)
-                  when 405      then Octokit::MethodNotAllowed
-                  when 406      then Octokit::NotAcceptable
-                  when 409      then Octokit::Conflict
-                  when 415      then Octokit::UnsupportedMediaType
-                  when 422      then error_for_422(body)
-                  when 451      then Octokit::UnavailableForLegalReasons
-                  when 400..499 then Octokit::ClientError
-                  when 500      then Octokit::InternalServerError
-                  when 501      then Octokit::NotImplemented
-                  when 502      then Octokit::BadGateway
-                  when 503      then Octokit::ServiceUnavailable
-                  when 500..599 then Octokit::ServerError
-                  end
-        klass.new(response)
-      end
-    end
-
-     def build_error_context
-       if RATE_LIMITED_ERRORS.include?(self.class)
-         @context = Octokit::RateLimit.from_response(@response)
-       end
-     end
-
-    def initialize(response=nil)
-      @response = response
-      super(build_error_message)
-      build_error_context
-    end
-
-    # Documentation URL returned by the API for some errors
-    #
-    # @return [String]
-    def documentation_url
-      data[:documentation_url] if data.is_a? Hash
-    end
-
-    # Returns most appropriate error for 401 HTTP status code
-    # @private
-    def self.error_for_401(headers)
-      if Octokit::OneTimePasswordRequired.required_header(headers)
-        Octokit::OneTimePasswordRequired
-      else
-        Octokit::Unauthorized
-      end
-    end
-
-    # Returns most appropriate error for 403 HTTP status code
-    # @private
-    def self.error_for_403(body)
-      if body =~ /rate limit exceeded/i
-        Octokit::TooManyRequests
-      elsif body =~ /exceeded a secondary rate limit/i
-        Octokit::TooManyRequests
-      elsif body =~ /login attempts exceeded/i
-        Octokit::TooManyLoginAttempts
-      elsif body =~ /returns blobs up to [0-9]+ MB/i
-        Octokit::TooLargeContent
-      elsif body =~ /abuse/i
-        Octokit::AbuseDetected
-      elsif body =~ /repository access blocked/i
-        Octokit::RepositoryUnavailable
-      elsif body =~ /email address must be verified/i
-        Octokit::UnverifiedEmail
-      elsif body =~ /account was suspended/i
-        Octokit::AccountSuspended
-      elsif body =~ /billing issue/i
-        Octokit::BillingIssue
-      elsif body =~ /Resource protected by organization SAML enforcement/i
-        Octokit::SAMLProtected
-      elsif body =~ /suspended your access|This installation has been suspended/i
-        Octokit::InstallationSuspended
-      else
-        Octokit::Forbidden
-      end
-    end
-
-    # Return most appropriate error for 404 HTTP status code
-    # @private
-    def self.error_for_404(body)
-      if body =~ /Branch not protected/i
-        Octokit::BranchNotProtected
-      else
-        Octokit::NotFound
-      end
-    end
-
-    # Return most appropriate error for 422 HTTP status code
-    # @private
-    def self.error_for_422(body)
-      if body =~ /PullRequestReviewComment/i && body =~ /(commit_id|end_commit_oid) is not part of the pull request/i
-        Octokit::CommitIsNotPartOfPullRequest
-      elsif body =~ /Path diff too large/i
-        Octokit::PathDiffTooLarge
-      else
-        Octokit::UnprocessableEntity
-      end
-    end
-
-    # Array of validation errors
-    # @return [Array<Hash>] Error info
-    def errors
-      if data && data.is_a?(Hash)
-        data[:errors] || []
-      else
-        []
-      end
-    end
-
-    # Status code returned by the GitHub server.
-    #
-    # @return [Integer]
-    def response_status
-      @response[:status]
-    end
-
-    # Headers returned by the GitHub server.
-    #
-    # @return [Hash]
-    def response_headers
-      @response[:response_headers]
-    end
-
-    # Body returned by the GitHub server.
-    #
-    # @return [String]
-    def response_body
-      @response[:body]
-    end
-
-    private
-
-    def data
-      @data ||=
-        if (body = @response[:body]) && !body.empty?
-          if body.is_a?(String) &&
-            @response[:response_headers] &&
-            @response[:response_headers][:content_type] =~ /json/
-
-            Sawyer::Agent.serializer.decode(body)
-          else
-            body
-          end
-        else
-          nil
-        end
-    end
-
-    def response_message
-      case data
-      when Hash
-        data[:message]
-      when String
-        data
-      end
-    end
-
-    def response_error
-      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
-    end
-
-    def response_error_summary
-      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
-
-      summary = "\nError summary:\n"
-      summary << data[:errors].map do |error|
-        if error.is_a? Hash
-          error.map { |k,v| "  #{k}: #{v}" }
-        else
-          "  #{error}"
-        end
-      end.join("\n")
-
-      summary
-    end
-
-    def build_error_message
-      return nil if @response.nil?
-
-      message =  "#{@response[:method].to_s.upcase} "
-      message << redact_url(@response[:url].to_s) + ": "
-      message << "#{@response[:status]} - "
-      message << "#{response_message}" unless response_message.nil?
-      message << "#{response_error}" unless response_error.nil?
-      message << "#{response_error_summary}" unless response_error_summary.nil?
-      message << " // See: #{documentation_url}" unless documentation_url.nil?
-      message
-    end
-
-    def redact_url(url_string)
-      %w[client_secret access_token].each do |token|
-        url_string.gsub!(/#{token}=\S+/, "#{token}=(redacted)") if url_string.include? token
-      end
-      url_string
-    end
-  end
-
-  # Raised on errors in the 400-499 range
-  class ClientError < Error; end
-
-  # Raised when GitHub returns a 400 HTTP status code
-  class BadRequest < ClientError; end
-
-  # Raised when GitHub returns a 401 HTTP status code
-  class Unauthorized < ClientError; end
-
-  # Raised when GitHub returns a 401 HTTP status code
-  # and headers include "X-GitHub-OTP"
-  class OneTimePasswordRequired < ClientError
-    #@private
-    OTP_DELIVERY_PATTERN = /required; (\w+)/i
-
-    #@private
-    def self.required_header(headers)
-      OTP_DELIVERY_PATTERN.match headers['X-GitHub-OTP'].to_s
-    end
-
-    # Delivery method for the user's OTP
-    #
-    # @return [String]
-    def password_delivery
-      @password_delivery ||= delivery_method_from_header
-    end
-
-    private
-
-    def delivery_method_from_header
-      if match = self.class.required_header(@response[:response_headers])
-        match[1]
-      end
-    end
-  end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  class Forbidden < ClientError; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'rate limit exceeded'
-  class TooManyRequests < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'login attempts exceeded'
-  class TooManyLoginAttempts < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'returns blobs up to [0-9]+ MB'
-  class TooLargeContent < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'abuse'
-  class AbuseDetected < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'repository access blocked'
-  class RepositoryUnavailable < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'email address must be verified'
-  class UnverifiedEmail < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'account was suspended'
-  class AccountSuspended < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'billing issue'
-  class BillingIssue < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'Resource protected by organization SAML enforcement'
-  class SAMLProtected < Forbidden; end
-
-  # Raised when GitHub returns a 403 HTTP status code
-  # and body matches 'suspended your access'
-  class InstallationSuspended < Forbidden; end
-
-  # Raised when GitHub returns a 404 HTTP status code
-  class NotFound < ClientError; end
-
-  # Raised when GitHub returns a 404 HTTP status code
-  # and body matches 'Branch not protected'
-  class BranchNotProtected < ClientError; end
-
-  # Raised when GitHub returns a 405 HTTP status code
-  class MethodNotAllowed < ClientError; end
-
-  # Raised when GitHub returns a 406 HTTP status code
-  class NotAcceptable < ClientError; end
-
-  # Raised when GitHub returns a 409 HTTP status code
-  class Conflict < ClientError; end
-
-  # Raised when GitHub returns a 414 HTTP status code
-  class UnsupportedMediaType < ClientError; end
-
-  # Raised when GitHub returns a 422 HTTP status code
-  class UnprocessableEntity < ClientError; end
-
-  # Raised when GitHub returns a 422 HTTP status code
-  # and body matches 'PullRequestReviewComment' and 'commit_id (or end_commit_oid) is not part of the pull request'
-  class CommitIsNotPartOfPullRequest < UnprocessableEntity; end
-
-  # Raised when GitHub returns a 422 HTTP status code and body matches 'Path diff too large'.
-  # It could occur when attempting to post review comments on a "too large" file.
-  class PathDiffTooLarge < UnprocessableEntity; end
-
-  # Raised when GitHub returns a 451 HTTP status code
-  class UnavailableForLegalReasons < ClientError; end
-
-  # Raised on errors in the 500-599 range
-  class ServerError < Error; end
-
-  # Raised when GitHub returns a 500 HTTP status code
-  class InternalServerError < ServerError; end
-
-  # Raised when GitHub returns a 501 HTTP status code
-  class NotImplemented < ServerError; end
-
-  # Raised when GitHub returns a 502 HTTP status code
-  class BadGateway < ServerError; end
-
-  # Raised when GitHub returns a 503 HTTP status code
-  class ServiceUnavailable < ServerError; end
-
-  # Raised when client fails to provide valid Content-Type
-  class MissingContentType < ArgumentError; end
-
-  # Raised when a method requires an application client_id
-  # and secret but none is provided
-  class ApplicationCredentialsRequired < StandardError; end
-
-  # Raised when a repository is created with an invalid format
-  class InvalidRepository < ArgumentError; end
-
-  RATE_LIMITED_ERRORS = [Octokit::TooManyRequests, Octokit::AbuseDetected]
-end

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

@@ -1,36 +0,0 @@
-module Octokit
-
-  # Class to parse and create Gist URLs
-  class Gist
-
-    # !@attribute id
-    #   @return [String] Gist ID
-    attr_accessor :id
-
-    # Instantiate {Gist} object from Gist URL
-    # @ return [Gist]
-    def self.from_url(url)
-      Gist.new(URI.parse(url).path[1..-1])
-    end
-
-    def initialize(gist)
-      case gist
-      when Integer, String
-        @id = gist.to_s
-      end
-    end
-
-    # Gist ID
-    # @return [String]
-    def to_s
-      @id
-    end
-
-    # Gist URL
-    # @return [String]
-    def url
-      "https://gist.github.com/#{@id}"
-    end
-
-  end
-end