resource

type Bytes ¶

type Bytes []byte

Bytes represents an in-memory resource backed by a byte slice.

func (b Bytes) Location() string

func (b Bytes) Open() (io.ReadCloser, error)

func (b Bytes) WriteTo(w io.Writer) (int64, error)

type BytesResolver ¶

type BytesResolver struct {
	// Encoding is the base64 encoding to use.  If not supplied, base64.StdEncoding is used.
	Encoding *base64.Encoding
}

BytesResolver resolves values as in-memory bytes encoding as base64 strings. The choice of encoding is configurable, and defaults to base64.StdEncoding. Any scheme is ignored by this resolver, allowing it to be mapped to any desired scheme.

func (r BytesResolver) Resolve(v string) (Interface, error)

type File ¶

type File string

File represents a resource backed by a system file.

func (f File) Location() string

func (f File) Open() (io.ReadCloser, error)

func (f File) WriteTo(w io.Writer) (int64, error)

type FileResolver ¶

type FileResolver struct {
	// Root is the optional file system path that acts as the logical root directory
	// for any resource strings this instance resolves.  If not supplied, no root is assumed.
	Root string
}

FileResolver resolves values as file system paths, relative to an optional Root directory. Any scheme is ignored by this resolver.

func (r FileResolver) Resolve(v string) (Interface, error)

type HTTP ¶

type HTTP struct {
	// URL is the required URL of the resource
	URL string

	// OpenMethod is the HTTP verb used to request the resource's data.  If not
	// supplied, GET is used.
	OpenMethod string

	// Client is the HTTP client to use to obtain the resource.  If not supplied,
	// http.DefaultClient is used.
	Client HTTPClient
}

HTTP represents a resource backed by an HTTP or HTTPS URL.

func (h HTTP) Location() string

func (h HTTP) Open() (io.ReadCloser, error)

func (h HTTP) WriteTo(w io.Writer) (int64, error)

type HTTPClient ¶

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

HTTPClient is the method set expected of an object which can transact with an HTTP server. http.Client implements this interface.

func WithClose(c HTTPClient) HTTPClient

func WithHeader(name, value string, c HTTPClient) HTTPClient

func WithHeaders(h http.Header, c HTTPClient) HTTPClient

func WithMethod(method string, c HTTPClient) HTTPClient

func WithTimeout(d time.Duration, c HTTPClient) HTTPClient

type HTTPClientFunc ¶

type HTTPClientFunc func(*http.Request) (*http.Response, error)

func (f HTTPClientFunc) Do(request *http.Request) (*http.Response, error)

type HTTPError ¶

type HTTPError struct {
	URL  string
	Code int
}

HTTPError represents a failure to obtain an HTTP resource. This error indicates that a successful HTTP transaction occurred with a non-2XX response code.

func (he HTTPError) Error() string

func (he HTTPError) StatusCode() int

type HTTPResolver ¶

type HTTPResolver struct {
	OpenMethod string
	Client     HTTPClient
}

HTTPResolver uses an HTTP client to resolve resources. Resource strings are expected to be valid URIs resolvable by the net/http package.

func (r HTTPResolver) Resolve(v string) (Interface, error)

type Interface ¶

type Interface interface {
	io.WriterTo

	Location() string
	Open() (io.ReadCloser, error)
}

Interface represents a handle to a resource.

All resource handles implement io.WriterTo, giving each type of resource the ability to optimize how transfers of data occur. For example, in-memory resources can perform a simple copy without creating intermediate objects.

func Must(r Interface, err error) Interface

type NoSchemeError ¶

type NoSchemeError struct {
	Value string
}

NoSchemeError is returned when no scheme was supplied on a resource and the SchemeResolver had no NoScheme resolver configured.

func (e NoSchemeError) Error() string

type Resolver ¶

type Resolver interface {
	// Resolve accepts a resource string and returns a handle that can load data
	// from that resource.  All Resolver implementations must safely permit this
	// method to be called concurrently.
	Resolve(string) (Interface, error)
}

Resolver is the strategy used to turn strings into resource handles.

func DefaultResolver() Resolver

type ResolverFunc ¶

type ResolverFunc func(string) (Interface, error)

ResolverFunc is a function type that can resolve resources

func (rf ResolverFunc) Resolve(v string) (Interface, error)

type Resolvers ¶

type Resolvers map[string]Resolver

Resolvers represents a mapping of component resolvers by an arbitrary string key. The most common usage is looking up a resolver by the scheme that it is mapped to.

func NewDefaultSchemeResolvers() Resolvers

StringScheme is mapped to a StringResolver
BytesScheme is mapped to a BytesResolver with standard base64 encoding
FileScheme is mapped to a FileResolver with no relative path
HTTPScheme and HTTPSScheme are mapped to an HTTPResolver using the default HTTP Client

func (rs Resolvers) Get(k string) (Resolver, bool)

func (rs *Resolvers) Set(k string, r Resolver)

type SchemeError ¶

type SchemeError struct {
	Value  string
	Scheme string
}

SchemeError is returned when a scheme had no associated resolver.

func (e SchemeError) Error() string

type SchemeResolver ¶

type SchemeResolver struct {
	Resolvers Resolvers
	NoScheme  Resolver
}

SchemeResolver is a resource resolver that uses URI-style schemes to determine how to resolve resources. For example, "http://localhost/foo" is a resource value with the scheme "http". Resource values resolved by this type of resolver do not have to be well-formed URIs unless the component resolver expects that. For example, "string://hello world" would resolve to a string resource when using the default scheme resolver.

func (sr SchemeResolver) Resolve(v string) (Interface, error)

type String ¶

type String string

String represents an in-memory resource backed by a golang string.

func (s String) Location() string

func (s String) Open() (io.ReadCloser, error)

func (s String) WriteTo(w io.Writer) (int64, error)

type StringResolver ¶

type StringResolver struct{}

StringResolver resolves values as in-memory strings rather than external locations. This resolver ignores any scheme associated with the value, allowing it to be mapped to any desired scheme.

func (r StringResolver) Resolve(v string) (Interface, error)

type TemplateResolver ¶

type TemplateResolver struct {
	// Resolver is the decorated Resolver.  This resolver will receive expanded resource strings.
	// This field is required.
	Resolver Resolver

	// Template is the optional template for parsing.  If supplied, this template's Parse method is used
	// to expand resource strings.  If not supplied, a simple default template is created and used each
	// time a resource string needs to be resolved.
	//
	// When supplied, this template's Parse method is guarded by an internal mutex.  Care must be taken that
	// the same template is not used with multiple TemplateResolver instances.  It's safest to use template.Clone
	// for each TemplateResolver's Template field, thus ensuring no race conditions will occur.
	Template *template.Template

	// Data is the optional data passed to each template execution.  If supplied, this value is passed as is
	// to template.Execute.
	Data interface{}
	// contains filtered or unexported fields
}

TemplateResolver is a decorator that expands resource strings as text templates and passes the results to another Resolver. An arbitrary template can be used for parsing, which allows customization of delimiters, functions, etc.

func (tr *TemplateResolver) Resolve(v string) (Interface, error)