ruby_snowflake_client 1.0.0

data/ext/vendor/github.com/aws/smithy-go/transport/http/request.go

@@ -0,0 +1,189 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+
+	iointernal "github.com/aws/smithy-go/transport/http/internal/io"
+)
+
+// Request provides the HTTP specific request structure for HTTP specific
+// middleware steps to use to serialize input, and send an operation's request.
+type Request struct {
+	*http.Request
+	stream           io.Reader
+	isStreamSeekable bool
+	streamStartPos   int64
+}
+
+// NewStackRequest returns an initialized request ready to be populated with the
+// HTTP request details. Returns empty interface so the function can be used as
+// a parameter to the Smithy middleware Stack constructor.
+func NewStackRequest() interface{} {
+	return &Request{
+		Request: &http.Request{
+			URL:           &url.URL{},
+			Header:        http.Header{},
+			ContentLength: -1, // default to unknown length
+		},
+	}
+}
+
+// IsHTTPS returns if the request is HTTPS. Returns false if no endpoint URL is set.
+func (r *Request) IsHTTPS() bool {
+	if r.URL == nil {
+		return false
+	}
+	return strings.EqualFold(r.URL.Scheme, "https")
+}
+
+// Clone returns a deep copy of the Request for the new context. A reference to
+// the Stream is copied, but the underlying stream is not copied.
+func (r *Request) Clone() *Request {
+	rc := *r
+	rc.Request = rc.Request.Clone(context.TODO())
+	return &rc
+}
+
+// StreamLength returns the number of bytes of the serialized stream attached
+// to the request and ok set. If the length cannot be determined, an error will
+// be returned.
+func (r *Request) StreamLength() (size int64, ok bool, err error) {
+	return streamLength(r.stream, r.isStreamSeekable, r.streamStartPos)
+}
+
+func streamLength(stream io.Reader, seekable bool, startPos int64) (size int64, ok bool, err error) {
+	if stream == nil {
+		return 0, true, nil
+	}
+
+	if l, ok := stream.(interface{ Len() int }); ok {
+		return int64(l.Len()), true, nil
+	}
+
+	if !seekable {
+		return 0, false, nil
+	}
+
+	s := stream.(io.Seeker)
+	endOffset, err := s.Seek(0, io.SeekEnd)
+	if err != nil {
+		return 0, false, err
+	}
+
+	// The reason to seek to streamStartPos instead of 0 is to ensure that the
+	// SDK only sends the stream from the starting position the user's
+	// application provided it to the SDK at. For example application opens a
+	// file, and wants to skip the first N bytes uploading the rest. The
+	// application would move the file's offset N bytes, then hand it off to
+	// the SDK to send the remaining. The SDK should respect that initial offset.
+	_, err = s.Seek(startPos, io.SeekStart)
+	if err != nil {
+		return 0, false, err
+	}
+
+	return endOffset - startPos, true, nil
+}
+
+// RewindStream will rewind the io.Reader to the relative start position if it
+// is an io.Seeker.
+func (r *Request) RewindStream() error {
+	// If there is no stream there is nothing to rewind.
+	if r.stream == nil {
+		return nil
+	}
+
+	if !r.isStreamSeekable {
+		return fmt.Errorf("request stream is not seekable")
+	}
+	_, err := r.stream.(io.Seeker).Seek(r.streamStartPos, io.SeekStart)
+	return err
+}
+
+// GetStream returns the request stream io.Reader if a stream is set. If no
+// stream is present nil will be returned.
+func (r *Request) GetStream() io.Reader {
+	return r.stream
+}
+
+// IsStreamSeekable returns whether the stream is seekable.
+func (r *Request) IsStreamSeekable() bool {
+	return r.isStreamSeekable
+}
+
+// SetStream returns a clone of the request with the stream set to the provided
+// reader. May return an error if the provided reader is seekable but returns
+// an error.
+func (r *Request) SetStream(reader io.Reader) (rc *Request, err error) {
+	rc = r.Clone()
+
+	if reader == http.NoBody {
+		reader = nil
+	}
+
+	var isStreamSeekable bool
+	var streamStartPos int64
+	switch v := reader.(type) {
+	case io.Seeker:
+		n, err := v.Seek(0, io.SeekCurrent)
+		if err != nil {
+			return r, err
+		}
+		isStreamSeekable = true
+		streamStartPos = n
+	default:
+		// If the stream length can be determined, and is determined to be empty,
+		// use a nil stream to prevent confusion between empty vs not-empty
+		// streams.
+		length, ok, err := streamLength(reader, false, 0)
+		if err != nil {
+			return nil, err
+		} else if ok && length == 0 {
+			reader = nil
+		}
+	}
+
+	rc.stream = reader
+	rc.isStreamSeekable = isStreamSeekable
+	rc.streamStartPos = streamStartPos
+
+	return rc, err
+}
+
+// Build returns a build standard HTTP request value from the Smithy request.
+// The request's stream is wrapped in a safe container that allows it to be
+// reused for subsequent attempts.
+func (r *Request) Build(ctx context.Context) *http.Request {
+	req := r.Request.Clone(ctx)
+
+	if r.stream == nil && req.ContentLength == -1 {
+		req.ContentLength = 0
+	}
+
+	switch stream := r.stream.(type) {
+	case *io.PipeReader:
+		req.Body = ioutil.NopCloser(stream)
+		req.ContentLength = -1
+	default:
+		// HTTP Client Request must only have a non-nil body if the
+		// ContentLength is explicitly unknown (-1) or non-zero. The HTTP
+		// Client will interpret a non-nil body and ContentLength 0 as
+		// "unknown". This is unwanted behavior.
+		if req.ContentLength != 0 && r.stream != nil {
+			req.Body = iointernal.NewSafeReadCloser(ioutil.NopCloser(stream))
+		}
+	}
+
+	return req
+}
+
+// RequestCloner is a function that can take an input request type and clone the request
+// for use in a subsequent retry attempt.
+func RequestCloner(v interface{}) interface{} {
+	return v.(*Request).Clone()
+}

data/ext/vendor/github.com/aws/smithy-go/transport/http/response.go

@@ -0,0 +1,34 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Response provides the HTTP specific response structure for HTTP specific
+// middleware steps to use to deserialize the response from an operation call.
+type Response struct {
+	*http.Response
+}
+
+// ResponseError provides the HTTP centric error type wrapping the underlying
+// error with the HTTP response value.
+type ResponseError struct {
+	Response *Response
+	Err      error
+}
+
+// HTTPStatusCode returns the HTTP response status code received from the service.
+func (e *ResponseError) HTTPStatusCode() int { return e.Response.StatusCode }
+
+// HTTPResponse returns the HTTP response received from the service.
+func (e *ResponseError) HTTPResponse() *Response { return e.Response }
+
+// Unwrap returns the nested error if any, or nil.
+func (e *ResponseError) Unwrap() error { return e.Err }
+
+func (e *ResponseError) Error() string {
+	return fmt.Sprintf(
+		"http response error StatusCode: %d, %v",
+		e.Response.StatusCode, e.Err)
+}

data/ext/vendor/github.com/aws/smithy-go/transport/http/time.go

@@ -0,0 +1,13 @@
+package http
+
+import (
+	"time"
+
+	smithytime "github.com/aws/smithy-go/time"
+)
+
+// ParseTime parses a time string like the HTTP Date header. This uses a more
+// relaxed rule set for date parsing compared to the standard library.
+func ParseTime(text string) (t time.Time, err error) {
+	return smithytime.ParseHTTPDate(text)
+}

data/ext/vendor/github.com/aws/smithy-go/transport/http/url.go

@@ -0,0 +1,44 @@
+package http
+
+import "strings"
+
+// JoinPath returns an absolute URL path composed of the two paths provided.
+// Enforces that the returned path begins with '/'. If added path is empty the
+// returned path suffix will match the first parameter suffix.
+func JoinPath(a, b string) string {
+	if len(a) == 0 {
+		a = "/"
+	} else if a[0] != '/' {
+		a = "/" + a
+	}
+
+	if len(b) != 0 && b[0] == '/' {
+		b = b[1:]
+	}
+
+	if len(b) != 0 && len(a) > 1 && a[len(a)-1] != '/' {
+		a = a + "/"
+	}
+
+	return a + b
+}
+
+// JoinRawQuery returns an absolute raw query expression. Any duplicate '&'
+// will be collapsed to single separator between values.
+func JoinRawQuery(a, b string) string {
+	a = strings.TrimFunc(a, isAmpersand)
+	b = strings.TrimFunc(b, isAmpersand)
+
+	if len(a) == 0 {
+		return b
+	}
+	if len(b) == 0 {
+		return a
+	}
+
+	return a + "&" + b
+}
+
+func isAmpersand(v rune) bool {
+	return v == '&'
+}

data/ext/vendor/github.com/aws/smithy-go/transport/http/user_agent.go

@@ -0,0 +1,37 @@
+package http
+
+import (
+	"strings"
+)
+
+// UserAgentBuilder is a builder for a HTTP User-Agent string.
+type UserAgentBuilder struct {
+	sb strings.Builder
+}
+
+// NewUserAgentBuilder returns a new UserAgentBuilder.
+func NewUserAgentBuilder() *UserAgentBuilder {
+	return &UserAgentBuilder{sb: strings.Builder{}}
+}
+
+// AddKey adds the named component/product to the agent string
+func (u *UserAgentBuilder) AddKey(key string) {
+	u.appendTo(key)
+}
+
+// AddKeyValue adds the named key to the agent string with the given value.
+func (u *UserAgentBuilder) AddKeyValue(key, value string) {
+	u.appendTo(key + "/" + value)
+}
+
+// Build returns the constructed User-Agent string. May be called multiple times.
+func (u *UserAgentBuilder) Build() string {
+	return u.sb.String()
+}
+
+func (u *UserAgentBuilder) appendTo(value string) {
+	if u.sb.Len() > 0 {
+		u.sb.WriteRune(' ')
+	}
+	u.sb.WriteString(value)
+}

data/ext/vendor/github.com/aws/smithy-go/validation.go

@@ -0,0 +1,140 @@
+package smithy
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+)
+
+// An InvalidParamsError provides wrapping of invalid parameter errors found when
+// validating API operation input parameters.
+type InvalidParamsError struct {
+	// Context is the base context of the invalid parameter group.
+	Context string
+	errs    []InvalidParamError
+}
+
+// Add adds a new invalid parameter error to the collection of invalid
+// parameters. The context of the invalid parameter will be updated to reflect
+// this collection.
+func (e *InvalidParamsError) Add(err InvalidParamError) {
+	err.SetContext(e.Context)
+	e.errs = append(e.errs, err)
+}
+
+// AddNested adds the invalid parameter errors from another InvalidParamsError
+// value into this collection. The nested errors will have their nested context
+// updated and base context to reflect the merging.
+//
+// Use for nested validations errors.
+func (e *InvalidParamsError) AddNested(nestedCtx string, nested InvalidParamsError) {
+	for _, err := range nested.errs {
+		err.SetContext(e.Context)
+		err.AddNestedContext(nestedCtx)
+		e.errs = append(e.errs, err)
+	}
+}
+
+// Len returns the number of invalid parameter errors
+func (e *InvalidParamsError) Len() int {
+	return len(e.errs)
+}
+
+// Error returns the string formatted form of the invalid parameters.
+func (e InvalidParamsError) Error() string {
+	w := &bytes.Buffer{}
+	fmt.Fprintf(w, "%d validation error(s) found.\n", len(e.errs))
+
+	for _, err := range e.errs {
+		fmt.Fprintf(w, "- %s\n", err.Error())
+	}
+
+	return w.String()
+}
+
+// Errs returns a slice of the invalid parameters
+func (e InvalidParamsError) Errs() []error {
+	errs := make([]error, len(e.errs))
+	for i := 0; i < len(errs); i++ {
+		errs[i] = e.errs[i]
+	}
+
+	return errs
+}
+
+// An InvalidParamError represents an invalid parameter error type.
+type InvalidParamError interface {
+	error
+
+	// Field name the error occurred on.
+	Field() string
+
+	// SetContext updates the context of the error.
+	SetContext(string)
+
+	// AddNestedContext updates the error's context to include a nested level.
+	AddNestedContext(string)
+}
+
+type invalidParamError struct {
+	context       string
+	nestedContext string
+	field         string
+	reason        string
+}
+
+// Error returns the string version of the invalid parameter error.
+func (e invalidParamError) Error() string {
+	return fmt.Sprintf("%s, %s.", e.reason, e.Field())
+}
+
+// Field Returns the field and context the error occurred.
+func (e invalidParamError) Field() string {
+	sb := &strings.Builder{}
+	sb.WriteString(e.context)
+	if sb.Len() > 0 {
+		if len(e.nestedContext) == 0 || (len(e.nestedContext) > 0 && e.nestedContext[:1] != "[") {
+			sb.WriteRune('.')
+		}
+	}
+	if len(e.nestedContext) > 0 {
+		sb.WriteString(e.nestedContext)
+		sb.WriteRune('.')
+	}
+	sb.WriteString(e.field)
+	return sb.String()
+}
+
+// SetContext updates the base context of the error.
+func (e *invalidParamError) SetContext(ctx string) {
+	e.context = ctx
+}
+
+// AddNestedContext prepends a context to the field's path.
+func (e *invalidParamError) AddNestedContext(ctx string) {
+	if len(e.nestedContext) == 0 {
+		e.nestedContext = ctx
+		return
+	}
+	// Check if our nested context is an index into a slice or map
+	if e.nestedContext[:1] != "[" {
+		e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)
+		return
+	}
+	e.nestedContext = ctx + e.nestedContext
+}
+
+// An ParamRequiredError represents an required parameter error.
+type ParamRequiredError struct {
+	invalidParamError
+}
+
+// NewErrParamRequired creates a new required parameter error.
+func NewErrParamRequired(field string) *ParamRequiredError {
+	return &ParamRequiredError{
+		invalidParamError{
+			field:  field,
+			reason: fmt.Sprintf("missing required field"),
+		},
+	}
+}

data/ext/vendor/github.com/aws/smithy-go/waiter/logger.go

@@ -0,0 +1,36 @@
+package waiter
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/smithy-go/logging"
+	"github.com/aws/smithy-go/middleware"
+)
+
+// Logger is the Logger middleware used by the waiter to log an attempt
+type Logger struct {
+	// Attempt is the current attempt to be logged
+	Attempt int64
+}
+
+// ID representing the Logger middleware
+func (*Logger) ID() string {
+	return "WaiterLogger"
+}
+
+// HandleInitialize performs handling of request in initialize stack step
+func (m *Logger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+	logger := middleware.GetLogger(ctx)
+
+	logger.Logf(logging.Debug, fmt.Sprintf("attempting waiter request, attempt count: %d", m.Attempt))
+
+	return next.HandleInitialize(ctx, in)
+}
+
+// AddLogger is a helper util to add waiter logger after `SetLogger` middleware in
+func (m Logger) AddLogger(stack *middleware.Stack) error {
+	return stack.Initialize.Insert(&m, "SetLogger", middleware.After)
+}

data/ext/vendor/github.com/aws/smithy-go/waiter/waiter.go

@@ -0,0 +1,66 @@
+package waiter
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/aws/smithy-go/rand"
+)
+
+// ComputeDelay computes delay between waiter attempts. The function takes in a current attempt count,
+// minimum delay, maximum delay, and remaining wait time for waiter as input. The inputs minDelay and maxDelay
+// must always be greater than 0, along with minDelay lesser than or equal to maxDelay.
+//
+// Returns the computed delay and if next attempt count is possible within the given input time constraints.
+// Note that the zeroth attempt results in no delay.
+func ComputeDelay(attempt int64, minDelay, maxDelay, remainingTime time.Duration) (delay time.Duration, err error) {
+	// zeroth attempt, no delay
+	if attempt <= 0 {
+		return 0, nil
+	}
+
+	// remainingTime is zero or less, no delay
+	if remainingTime <= 0 {
+		return 0, nil
+	}
+
+	// validate min delay is greater than 0
+	if minDelay == 0 {
+		return 0, fmt.Errorf("minDelay must be greater than zero when computing Delay")
+	}
+
+	// validate max delay is greater than 0
+	if maxDelay == 0 {
+		return 0, fmt.Errorf("maxDelay must be greater than zero when computing Delay")
+	}
+
+	// Get attempt ceiling to prevent integer overflow.
+	attemptCeiling := (math.Log(float64(maxDelay/minDelay)) / math.Log(2)) + 1
+
+	if attempt > int64(attemptCeiling) {
+		delay = maxDelay
+	} else {
+		// Compute exponential delay based on attempt.
+		ri := 1 << uint64(attempt-1)
+		// compute delay
+		delay = minDelay * time.Duration(ri)
+	}
+
+	if delay != minDelay {
+		// randomize to get jitter between min delay and delay value
+		d, err := rand.CryptoRandInt63n(int64(delay - minDelay))
+		if err != nil {
+			return 0, fmt.Errorf("error computing retry jitter, %w", err)
+		}
+
+		delay = time.Duration(d) + minDelay
+	}
+
+	// check if this is the last attempt possible and compute delay accordingly
+	if remainingTime-delay <= minDelay {
+		delay = remainingTime - minDelay
+	}
+
+	return delay, nil
+}

data/ext/vendor/github.com/danieljoos/wincred/.gitattributes

@@ -0,0 +1 @@
+*.go text eol=lf

data/ext/vendor/github.com/danieljoos/wincred/.gitignore

@@ -0,0 +1,25 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+
+coverage.txt

data/ext/vendor/github.com/danieljoos/wincred/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Daniel Joos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.