cmds

Documentation

Index

• Variables
• type CsvCommand
  • func NewCsvCommand() (*CsvCommand, error)
  • func (c *CsvCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, ...) error
• type CsvSettings
• type ExampleCommand
  • func NewExampleCommand() (*ExampleCommand, error)
  • func (c *ExampleCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, ...) error
• type ExampleSettings
• type ExtensionFlag
• type JsonCommand
  • func NewJsonCommand() (*JsonCommand, error)
  • func (j *JsonCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, ...) error
• type JsonSettings
• type YamlCommand
  • func NewYamlCommand() (*YamlCommand, error)
  • func (y *YamlCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, ...) error
• type YamlSettings

Variables

var DocsCmd = &cobra.Command{
	Use:   "docs [flags] file [file...]",
	Short: "Work with help documents",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		ctx := cmd.Context()
		gp, _, err := cli.CreateGlazedProcessorFromCobra(cmd)
		cobra.CheckErr(err)

		for _, arg := range args {

			s, err := os.ReadFile(arg)
			cobra.CheckErr(err)

			var metaData types.Row
			inputReader := bytes.NewReader(s)
			_, err = frontmatter.Parse(inputReader, &metaData)
			cobra.CheckErr(err)

			metaData.Set("path", arg)

			err = gp.AddRow(ctx, metaData)
			cobra.CheckErr(err)
		}

		err = gp.Close(ctx)
		if _, ok := err.(*cmds.ExitWithoutGlazeError); ok {
			os.Exit(0)
		}
		cobra.CheckErr(err)
	},
}

var MarkdownCmd = &cobra.Command{
	Use:   "markdown",
	Short: "Convert markdown data",
}

Types

type CsvCommand

type CsvCommand struct {
	*cmds.CommandDescription
}

func NewCsvCommand

func NewCsvCommand() (*CsvCommand, error)

func (*CsvCommand) RunIntoGlazeProcessor

func (c *CsvCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, gp middlewares.Processor) error

type CsvSettings

type CsvSettings struct {
	InputFiles       []string `glazed.parameter:"input-files"`
	Delimiter        string   `glazed.parameter:"delimiter"`
	Comment          string   `glazed.parameter:"comment"`
	FieldsPerRecord  int      `glazed.parameter:"fields-per-record"`
	TrimLeadingSpace bool     `glazed.parameter:"trim-leading-space"`
	LazyQuotes       bool     `glazed.parameter:"lazy-quotes"`
}

type ExampleCommand

type ExampleCommand struct {
	*cmds.CommandDescription
}

func NewExampleCommand

func NewExampleCommand() (*ExampleCommand, error)

func (*ExampleCommand) RunIntoGlazeProcessor

func (c *ExampleCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, gp middlewares.Processor) error

RunIntoGlazeProcessor is called to actually execute the command.

parsedLayers contains the result of parsing each layer that has been registered with the command description. These layers can be glazed structured data flags, database connection parameters, application specification parameters.

ps is a convenience map containing *all* parsed flags.

gp is a GlazeProcessor that can be used to emit rows. Each row is an ordered map.

type ExampleSettings

type ExampleSettings struct {
	Count int  `glazed.parameter:"count"`
	Test  bool `glazed.parameter:"test"`
}

type ExtensionFlag

type ExtensionFlag struct {
	FlagName string
	FlagDesc string
	Extender goldmark.Extender
}

type JsonCommand

type JsonCommand struct {
	*cmds.CommandDescription
}

func NewJsonCommand

func NewJsonCommand() (*JsonCommand, error)

func (*JsonCommand) RunIntoGlazeProcessor

func (j *JsonCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, gp middlewares.Processor) error

type JsonSettings

type JsonSettings struct {
	InputIsArray bool     `glazed.parameter:"input-is-array"`
	Sanitize     bool     `glazed.parameter:"sanitize"`
	FromMarkdown bool     `glazed.parameter:"from-markdown"`
	TailMode     bool     `glazed.parameter:"tail"`
	InputFiles   []string `glazed.parameter:"input-files"`
}

type YamlCommand

type YamlCommand struct {
	*cmds.CommandDescription
}

func NewYamlCommand

func NewYamlCommand() (*YamlCommand, error)

func (*YamlCommand) RunIntoGlazeProcessor

func (y *YamlCommand) RunIntoGlazeProcessor(ctx context.Context, parsedLayers *layers.ParsedLayers, gp middlewares.Processor) error

type YamlSettings

type YamlSettings struct {
	InputIsArray bool     `glazed.parameter:"input-is-array"`
	Sanitize     bool     `glazed.parameter:"sanitize"`
	FromMarkdown bool     `glazed.parameter:"from-markdown"`
	InputFiles   []string `glazed.parameter:"input-files"`
}