cli

package
v0.7.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 20, 2021 License: MIT Imports: 52 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Cache *viper.Viper

Cache is used to store temporary data between runs.

View Source 
var GlobalFlags *pflag.FlagSet

GlobalFlags contains all the fixed up front flags This allows us to parse them before we hand over control to cobra

View Source 
var ReadableLexer = lexers.Register(chroma.MustNewLexer(
	&chroma.Config{
		Name:         "CLI Readable",
		Aliases:      []string{"readable"},
		NotMultiline: true,
		DotAll:       true,
	},
	chroma.Rules{
		"whitespace": {
			{`\s+`, chroma.Text, nil},
		},
		"scalar": {
			{`(true|false|null)\b`, chroma.KeywordConstant, nil},
			{`"?0x[0-9a-f]+(...)?"?`, chroma.LiteralNumberHex, nil},
			{`"?[0-9]{4}-[0-9]{2}-[0-9]{2}(T[0-9:+-.]+Z?)?"?`, chroma.LiteralDate, nil},
			{`-?(0|[1-9]\d*)(\.\d+[eE](\+|-)?\d+|[eE](\+|-)?\d+|\.\d+)`, chroma.LiteralNumberFloat, nil},
			{`-?(0|[1-9]\d*)`, chroma.LiteralNumberInteger, nil},
			{`"([a-z]+://|/)(\\\\|\\"|[^"])+"`, chroma.LiteralStringSymbol, nil},
			{`"(\\\\|\\"|[^"])*"`, chroma.LiteralStringDouble, nil},
		},
		"objectrow": {
			{`:`, chroma.Punctuation, nil},
			{`\n`, chroma.Punctuation, chroma.Pop(1)},
			{`\}`, chroma.Punctuation, chroma.Pop(2)},
			chroma.Include("value"),
		},
		"object": {
			chroma.Include("whitespace"),
			{`\}`, chroma.Punctuation, chroma.Pop(1)},
			{`(\\\\|\\:|[^:])+`, chroma.NameTag, chroma.Push("objectrow")},
		},
		"arrayvalue": {
			{`\]`, chroma.Punctuation, chroma.Pop(1)},
			chroma.Include("value"),
		},
		"value": {
			chroma.Include("whitespace"),
			{`\{`, chroma.Punctuation, chroma.Push("object")},
			{`\[`, chroma.Punctuation, chroma.Push("arrayvalue")},
			chroma.Include("scalar"),
		},
		"root": {
			chroma.Include("value"),
		},
	},
))

ReadableLexer colorizes the output of the Readable marshaller.

View Source 
var Root *cobra.Command

Root command (entrypoint) of the CLI.

View Source 
var SchemaLexer = lexers.Register(chroma.MustNewLexer(
	&chroma.Config{
		Name:         "CLI Schema",
		Aliases:      []string{"schema"},
		NotMultiline: true,
		DotAll:       true,
	},
	chroma.Rules{
		"whitespace": {
			{`\s+`, chroma.Text, nil},
		},
		"value": {
			chroma.Include("whitespace"),
			{`(\()([^ )]+)`, chroma.ByGroups(chroma.Text, chroma.Keyword), nil},
			{`([^:]+)(:)([^ )]+)`, chroma.ByGroups(chroma.String, chroma.Text, chroma.Text), nil},
			{`[^\n]*`, chroma.Text, chroma.Pop(1)},
		},
		"row": {
			chroma.Include("whitespace"),
			{`([^*:\n]+)(\*?)(:)`, chroma.ByGroups(chroma.NameTag, chroma.GenericStrong, chroma.Text), chroma.Push("value")},
			{`(\()([^ )]+)`, chroma.ByGroups(chroma.Text, chroma.Keyword), chroma.Push("value")},
		},
		"root": {
			chroma.Include("row"),
		},
	},
))

SchemaLexer colorizes schema output.

View Source 
var Stderr io.Writer = os.Stderr

Stderr is a cross-platform, color-safe writer if colors are enabled, otherwise it defaults to `os.Stderr`.

View Source 
var Stdout io.Writer = os.Stdout

Stdout is a cross-platform, color-safe writer if colors are enabled, otherwise it defaults to `os.Stdout`.

Functions

func AddAuth 

func AddAuth(name string, h AuthHandler)

AddAuth registers a new named auth handler.

func AddContentType 

func AddContentType(name string, q float32, ct ContentType)

AddContentType adds a new content type marshaller with the given default content type name and q factor (0-1.0, higher has priority).

func AddEncoding 

func AddEncoding(name string, encoding ContentEncoding)

AddEncoding adds a new content encoding with the given name.

func AddGlobalFlag 

func AddGlobalFlag(name, short, description string, defaultValue interface{}, multi bool)

AddGlobalFlag will make a new global flag on the root command.

func AddLinkParser 

func AddLinkParser(parser LinkParser)

AddLinkParser adds a new link parser to create standardized link relation objects on a parsed response.

func AddLoader 

func AddLoader(loader Loader)

AddLoader adds a new API spec loader to the CLI.

func BestEffortSystemCertPool 

func BestEffortSystemCertPool() *x509.CertPool

BestEffortSystemCertPool returns system cert pool as best effort, otherwise an empty cert pool

func CachedTransport 

func CachedTransport() *httpcache.Transport

CachedTransport returns an HTTP transport with caching abilities.

func DecodeResponse 

func DecodeResponse(resp *http.Response) error

DecodeResponse will replace the response body with a decoding reader if needed. Assumes the original body will be closed outside of this function.

func DeepAssign 

func DeepAssign(target, source map[string]interface{})

DeepAssign recursively merges a source map into the target.

func Defaults 

func Defaults()

Defaults adds the default encodings, content types, and link parsers to the CLI.

func GetBody 

func GetBody(mediaType string, args []string) (string, error)

GetBody returns the request body if one was passed either as shorthand arguments or via stdin.

func Highlight 

func Highlight(lexer string, data []byte) ([]byte, error)

Highlight a block of data with the given lexer.

func Init 

func Init(name string, version string)

Init will set up the CLI.

func InvalidateCachedTransport 

func InvalidateCachedTransport() http.RoundTripper

InvalidateCachedTransport returns an HTTP transport which will not read cached items (it deletes them) and then refreshes the cache when new items are fetched.

func LogDebug 

func LogDebug(format string, values ...interface{})

LogDebug logs a debug message if --rsh-verbose (-v) was passed.

func LogDebugRequest 

func LogDebugRequest(req *http.Request)

LogDebugRequest logs the request in a debug message if verbose output is enabled.

func LogDebugResponse 

func LogDebugResponse(start time.Time, resp *http.Response)

LogDebugResponse logs the response in a debug message if verbose output is enabled.

func LogError 

func LogError(format string, values ...interface{})

LogError logs an error message.

func LogInfo 

func LogInfo(format string, values ...interface{})

LogInfo logs an info message.

func LogWarning 

func LogWarning(format string, values ...interface{})

LogWarning logs a warning message.

func MakeRequest 

func MakeRequest(req *http.Request, options ...requestOption) (*http.Response, error)

MakeRequest makes an HTTP request using the default client. It adds the user-agent, auth, and any passed headers or query params to the request before sending it out on the wire. If verbose mode is enabled, it will print out both the request and response.

func MakeRequestAndFormat 

func MakeRequestAndFormat(req *http.Request)

MakeRequestAndFormat is a convenience function for calling `GetParsedResponse` and then calling the default formatter's `Format` function with the parsed response. Panics on error.

func Marshal 

func Marshal(contentType string, value interface{}) ([]byte, error)

Marshal a value to the given content type if possible.

func MarshalReadable 

func MarshalReadable(v interface{}) ([]byte, error)

MarshalReadable marshals a value into a human-friendly readable format.

func MinCachedTransport 

func MinCachedTransport(min time.Duration) *httpcache.Transport

MinCachedTransport returns an HTTP transport with caching abilities and a minimum cache duration for any responses if no cache headers are set. 

func ParseLinks(base *url.URL, resp *Response) error

ParseLinks uses all registered LinkParsers to parse links for a response.

func Run 

func Run()

Run the CLI! Parse arguments, make requests, print responses.

func Unmarshal 

func Unmarshal(contentType string, data []byte, value interface{}) error

Unmarshal raw data from the given content type into a value.

func WithClient 

func WithClient(c *http.Client) requestOption

WithClient sets the client to use for the request.

func WithoutLog 

func WithoutLog() requestOption

WithoutLog disabled debug logging for the given request/response.

Types

type API 

type API struct {
	Short      string      `json:"short"`
	Long       string      `json:"long,omitempty"`
	Operations []Operation `json:"operations,omitempty"`
	Auth       []APIAuth   `json:"auth,omitempty"`
	AutoConfig AutoConfig  `json:"autoconfig,omitempty"`
}

API represents an abstracted API description used to build CLI commands around available resources, operations, and links. An API is produced by a Loader and cached by the CLI in-between runs when possible.

func Load 

func Load(entrypoint string, root *cobra.Command) (API, error)

Load will hydrate the command tree for an API, possibly refreshing the API spec if the cache is out of date.

func (*API) Merge 

func (a *API) Merge(other API)

Merge two APIs together. Takes the description if none is set and merges operations. Ignores auth - if that differs then create another API instead.

type APIAuth 

type APIAuth struct {
	Name   string            `json:"name"`
	Params map[string]string `json:"params"`
}

APIAuth describes the auth type and parameters for an API.

type APIConfig 

type APIConfig struct {
	Base      string                 `json:"base"`
	SpecFiles []string               `json:"spec_files,omitempty" mapstructure:"spec_files,omitempty"`
	Profiles  map[string]*APIProfile `json:"profiles,omitempty" mapstructure:",omitempty"`
	TLS       *TLSConfig             `json:"tls,omitempty" mapstructure:",omitempty"`
	// contains filtered or unexported fields
}

APIConfig describes per-API configuration options like the base URI and auth scheme, if any.

func (APIConfig) Save 

func (a APIConfig) Save() error

Save the API configuration to disk.

type APIProfile 

type APIProfile struct {
	Headers map[string]string `json:"headers,omitempty"`
	Query   map[string]string `json:"query,omitempty"`
	Auth    *APIAuth          `json:"auth"`
}

APIProfile contains account-specific API information

type AuthHandler 

type AuthHandler interface {
	// Parameters returns an ordered list of required and optional input
	// parameters for this auth handler. Used when configuring an API.
	Parameters() []AuthParam

	// OnRequest applies auth to an outgoing request before it hits the wire.
	OnRequest(req *http.Request, key string, params map[string]string) error
}

AuthHandler is used to register new authentication handlers that will apply auth to an outgoing request as needed.

type AuthParam 

type AuthParam struct {
	Name     string
	Help     string
	Required bool
}

AuthParam describes an auth input parameter for an AuthHandler.

type AutoConfig 

type AutoConfig struct {
	Headers map[string]string        `json:"headers,omitempty"`
	Prompt  map[string]AutoConfigVar `json:"prompt,omitempty"`
	Auth    APIAuth                  `json:"auth,omitempty"`
}

AutoConfig holds an API's automatic configuration settings for the CLI. These are advertised via OpenAPI extension and picked up by the CLI to make it easier to get started using an API.

type AutoConfigVar 

type AutoConfigVar struct {
	Description string        `json:"description,omitempty"`
	Example     string        `json:"example,omitempty"`
	Default     interface{}   `json:"default,omitempty"`
	Enum        []interface{} `json:"enum,omitempty"`

	// Exclude the value from being sent to the server. This essentially makes
	// it a value which is only used in param templates.
	Exclude bool `json:"exclude,omitempty"`
}

AutoConfigVar represents a variable given by the user when prompted during auto-configuration setup of an API.

type BasicAuth 

type BasicAuth struct{}

BasicAuth implements HTTP Basic authentication.

func (*BasicAuth) OnRequest 

func (a *BasicAuth) OnRequest(req *http.Request, key string, params map[string]string) error

OnRequest gets run before the request goes out on the wire.

func (*BasicAuth) Parameters 

func (a *BasicAuth) Parameters() []AuthParam

Parameters define the HTTP Basic Auth parameter names.

type BrotliEncoding 

type BrotliEncoding struct{}

BrotliEncoding supports RFC 7932 Brotli content encoding.

func (BrotliEncoding) Reader 

func (b BrotliEncoding) Reader(stream io.Reader) (io.Reader, error)

Reader returns a new reader for the stream that removes the brotli encoding.

type CBOR 

type CBOR struct{}

CBOR describes content types like `application/cbor` or `application/foo+cbor`. http://cbor.io/

func (CBOR) Detect 

func (c CBOR) Detect(contentType string) bool

Detect if the content type is YAML.

func (CBOR) Marshal 

func (c CBOR) Marshal(value interface{}) ([]byte, error)

Marshal the value to encoded YAML.

func (CBOR) Unmarshal 

func (c CBOR) Unmarshal(data []byte, value interface{}) error

Unmarshal the value from encoded YAML.

type ContentEncoding 

type ContentEncoding interface {
	Reader(stream io.Reader) (io.Reader, error)
}

ContentEncoding is used to encode/decode content for transfer over the wire, for example with gzip.

type ContentType 

type ContentType interface {
	Detect(contentType string) bool
	Marshal(value interface{}) ([]byte, error)
	Unmarshal(data []byte, value interface{}) error
}

ContentType is used to marshal/unmarshal data to various formats.

type DefaultFormatter 

type DefaultFormatter struct {
	// contains filtered or unexported fields
}

DefaultFormatter can apply JMESPath queries and can output prettyfied JSON and YAML output. If Stdout is a TTY, then colorized output is provided. The default formatter uses the `rsh-filter` and `rsh-output-format` configuration values to perform JMESPath queries and set JSON (default) or YAML output.

func NewDefaultFormatter 

func NewDefaultFormatter(tty bool) *DefaultFormatter

NewDefaultFormatter creates a new formatted with autodetected TTY capabilities.

func (*DefaultFormatter) Format 

func (f *DefaultFormatter) Format(resp Response) error

Format will filter, prettify, colorize and output the data.

type GzipEncoding 

type GzipEncoding struct{}

GzipEncoding supports gzip-encoded response content.

func (GzipEncoding) Reader 

func (g GzipEncoding) Reader(stream io.Reader) (io.Reader, error)

Reader returns a new reader for the stream that removes the gzip encoding.

type HALParser 

type HALParser struct{}

HALParser parses HAL hypermedia links. Ignores curies. 

func (h HALParser) ParseLinks(resp *Response) error

ParseLinks processes the links in a parsed response.

type Ion 

type Ion struct{}

Ion describes content types like `application/ion`.

func (Ion) Detect 

func (i Ion) Detect(contentType string) bool

Detect if the content type is Ion.

func (Ion) Marshal 

func (i Ion) Marshal(value interface{}) ([]byte, error)

Marshal the value to encoded binary Ion.

func (Ion) Unmarshal 

func (i Ion) Unmarshal(data []byte, value interface{}) error

Unmarshal the value form encoded binary or text Ion.

type JSON 

type JSON struct{}

JSON describes content types like `application/json` or `application/problem+json`.

func (JSON) Detect 

func (j JSON) Detect(contentType string) bool

Detect if the content type is JSON.

func (JSON) Marshal 

func (j JSON) Marshal(value interface{}) ([]byte, error)

Marshal the value to encoded JSON.

func (JSON) Unmarshal 

func (j JSON) Unmarshal(data []byte, value interface{}) error

Unmarshal the value from encoded JSON.

type JSONAPIParser 

type JSONAPIParser struct{}

JSONAPIParser parses JSON:API hypermedia links. 

func (j JSONAPIParser) ParseLinks(resp *Response) error

ParseLinks processes the links in a parsed response. 

type Link struct {
	Rel string `json:"rel"`
	URI string `json:"uri"`
}

Link describes a hypermedia link to another resource.

type LinkHeaderParser 

type LinkHeaderParser struct{}

LinkHeaderParser parses RFC 5988 HTTP link relation headers. 

func (l LinkHeaderParser) ParseLinks(resp *Response) error

ParseLinks processes the links in a parsed response.

type LinkParser 

type LinkParser interface {
	ParseLinks(resp *Response) error
}

LinkParser parses link relationships in a response. 

type Links map[string][]*Link

Links represents a map of `rel` => list of linke relations.

type Loader 

type Loader interface {
	LocationHints() []string
	Detect(resp *http.Response) bool
	Load(entrypoint, spec url.URL, resp *http.Response) (API, error)
}

Loader is used to detect and load an API spec, turning it into CLI commands.

type MsgPack 

type MsgPack struct{}

MsgPack describes content types like `application/msgpack` or `application/foo+msgpack`. https://msgpack.org/

func (MsgPack) Detect 

func (m MsgPack) Detect(contentType string) bool

Detect if the content type is YAML.

func (MsgPack) Marshal 

func (m MsgPack) Marshal(value interface{}) ([]byte, error)

Marshal the value to encoded YAML.

func (MsgPack) Unmarshal 

func (m MsgPack) Unmarshal(data []byte, value interface{}) error

Unmarshal the value from encoded YAML.

type Operation 

type Operation struct {
	Name          string   `json:"name"`
	Aliases       []string `json:"aliases,omitempty"`
	Short         string   `json:"short,omitempty"`
	Long          string   `json:"long,omitempty"`
	Method        string   `json:"method,omitempty"`
	URITemplate   string   `json:"uriTemplate"`
	PathParams    []*Param `json:"pathParams,omitempty"`
	QueryParams   []*Param `json:"queryParams,omitempty"`
	HeaderParams  []*Param `json:"headerParams,omitempty"`
	BodyMediaType string   `json:"bodyMediaType,omitempty"`
	Examples      []string `json:"examples,omitempty"`
	Hidden        bool     `json:"hidden,omitempty"`
}

Operation represents an API action, e.g. list-things or create-user

type Param 

type Param struct {
	Type        string      `json:"type"`
	Name        string      `json:"name"`
	DisplayName string      `json:"displayName,omitEmpty"`
	Description string      `json:"description,omitempty"`
	Style       Style       `json:"style,omitempty"`
	Explode     bool        `json:"explode,omitempty"`
	Default     interface{} `json:"default,omitempty"`
	Example     interface{} `json:"example,omitempty"`
}

Param represents an API operation input parameter.

func (Param) AddFlag 

func (p Param) AddFlag(flags *pflag.FlagSet) interface{}

AddFlag adds a new option flag to a command's flag set for this parameter.

func (Param) Parse 

func (p Param) Parse(value string) (interface{}, error)

Parse the parameter from a string input (e.g. command line argument)

func (Param) Serialize 

func (p Param) Serialize(value interface{}) []string

Serialize the parameter based on the type/style/explode configuration.

type Response 

type Response struct {
	Proto   string            `json:"proto"`
	Status  int               `json:"status"`
	Headers map[string]string `json:"headers"`
	Links   Links             `json:"links"`
	Body    interface{}       `json:"body"`
}

Response describes a parsed HTTP response which can be marshalled to enable printing and filtering/projection.

func GetParsedResponse 

func GetParsedResponse(req *http.Request) (Response, error)

GetParsedResponse makes a request and gets the parsed response back. It handles any auto-pagination or linking that needs to be done and may return a psuedo-responsse that is a combination of all responses.

func ParseResponse 

func ParseResponse(resp *http.Response) (Response, error)

ParseResponse takes an HTTP response and tries to parse it using the registered content types. It returns a map representing the request,

func (Response) Map 

func (r Response) Map() map[string]interface{}

Map returns a map representing this response matching the encoded JSON.

type ResponseFormatter 

type ResponseFormatter interface {
	Format(Response) error
}

ResponseFormatter will filter, prettify, and print out the results of a call. 

var Formatter ResponseFormatter

Formatter is the currently configured response output formatter.

type SirenParser 

type SirenParser struct{}

SirenParser parses Siren hypermedia links. 

func (s SirenParser) ParseLinks(resp *Response) error

ParseLinks processes the links in a parsed response.

type Style 

type Style int

Style is an encoding style for parameters. 

const (
	// StyleSimple corresponds to OpenAPI 3 simple parameters
	StyleSimple Style = iota

	// StyleForm corresponds to OpenAPI 3 form parameters
	StyleForm
)

type TLSConfig 

type TLSConfig struct {
	InsecureSkipVerify bool   `json:"insecure" mapstructure:"insecure"`
	Cert               string `json:"cert"`
	Key                string `json:"key"`
	CACert             string `json:"ca_cert" mapstructure:"ca_cert"`
}

TLSConfig contains the TLS setup for the HTTP client

type TerrificallySimpleJSONParser 

type TerrificallySimpleJSONParser struct{}

TerrificallySimpleJSONParser parses `self` links from JSON-like formats. 

func (t TerrificallySimpleJSONParser) ParseLinks(resp *Response) error

ParseLinks processes the links in a parsed response.

type Text 

type Text struct{}

Text describes content types like `text/plain` or `text/html`.

func (Text) Detect 

func (t Text) Detect(contentType string) bool

Detect if the content type is text.

func (Text) Marshal 

func (t Text) Marshal(value interface{}) ([]byte, error)

Marshal the value to a text string.

func (Text) Unmarshal 

func (t Text) Unmarshal(data []byte, value interface{}) error

Unmarshal the value from a text string.

type YAML 

type YAML struct{}

YAML describes content types like `application/yaml` or `application/foo+yaml`.

func (YAML) Detect 

func (y YAML) Detect(contentType string) bool

Detect if the content type is YAML.

func (YAML) Marshal 

func (y YAML) Marshal(value interface{}) ([]byte, error)

Marshal the value to encoded YAML.

func (YAML) Unmarshal 

func (y YAML) Unmarshal(data []byte, value interface{}) error

Unmarshal the value from encoded YAML.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.