formatter

type EditorConfig ¶

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

EditorConfig resolves .editorconfig settings for individual files.

EditorConfig resolution is per-file: the properties that apply depend on the file's path (glob sections) and on the .editorconfig files found walking up from its directory (stopping at root = true). The zero value is not usable; use NewEditorConfig.

Safe for concurrent use.

func NewEditorConfig() *EditorConfig

func (e *EditorConfig) Apply(opts *Options, path string)

type ErrSkipped ¶

type ErrSkipped struct {
	Reason string
}

ErrSkipped indicates the formatter cannot process this file but it is not a syntax error. The file should be reported to the user with the reason but not counted as a failure or formatted.

func (e *ErrSkipped) Error() string

type Formatter ¶

type Formatter interface {
	// Format returns the canonically formatted version of src.
	// If src is already canonical, Format returns src unchanged (byte-equal).
	// Returns an error if src cannot be parsed (unparseable input is not
	// a formatting issue — it's a syntax error handled by the validator).
	Format(src []byte, opts Options) ([]byte, error)
}

Formatter transforms source bytes into canonically formatted output.

Implementations must be stateless and safe for concurrent use. Implementations must preserve all comments present in the source.

type IndentStyle ¶

type IndentStyle int

IndentStyle selects between spaces and tabs.

const (
	// IndentDefault means the formatter uses its own convention.
	IndentDefault IndentStyle = iota
	// IndentSpaces uses spaces for indentation.
	IndentSpaces
	// IndentTabs uses tabs for indentation.
	IndentTabs
)

type LineEnding ¶

type LineEnding int

LineEnding selects the line terminator.

const (
	// LineEndingDefault uses the formatter's convention (typically LF).
	LineEndingDefault LineEnding = iota
	// LineEndingLF uses \n.
	LineEndingLF
	// LineEndingCRLF uses \r\n.
	LineEndingCRLF
)

type Options ¶

type Options struct {
	// IndentStyle selects spaces or tabs. Zero value = format default.
	IndentStyle IndentStyle

	// IndentWidth is spaces per indent level. Ignored when IndentStyle is Tabs.
	// Zero value = format default.
	IndentWidth int

	// FinalNewline ensures the file ends with exactly one newline.
	FinalNewline bool

	// LineEnding selects the line terminator for output.
	LineEnding LineEnding

	// SortKeys sorts object/map keys alphabetically when true.
	SortKeys bool

	// MaxLineWidth is the target maximum line width. 0 = no limit.
	// Formatters use this as a hint, not a hard constraint.
	MaxLineWidth int

	// QuoteStyle controls quoting of string scalars.
	// Only applies to formats with multiple quoting conventions (YAML).
	// JSON always uses double quotes per spec; this field is ignored for JSON.
	QuoteStyle QuoteStyle

	// XMLWhitespaceSensitivity controls XML whitespace handling.
	// Ignore: reformat all indentation (default for config files).
	// Preserve: only modify existing indentation, never insert newlines.
	XMLWhitespaceSensitivity XMLWhitespace

	// XMLSelfClosingSpace adds a space before /> in self-closing tags.
	// true: <br /> ; false: <br/>
	XMLSelfClosingSpace bool

	// TrailingCommas controls trailing commas on multiline collections.
	// Only applies to formats that permit them (JSONC).
	TrailingCommas TrailingCommas

	// IndentSequences controls whether YAML sequences used as mapping values
	// receive an additional indentation level.
	IndentSequences SequenceIndent
}

Options controls formatting behavior. Each formatter uses the fields that apply to its format and ignores the rest. Zero values mean "use the format-specific default."

Options are resolved by the CLI before being passed to a formatter:

CLI flags > .cfv.toml [format.<type>] > .cfv.toml [format] > format-specific config > .editorconfig > hardcoded defaults

func DefaultFormatOptions() Options

func LoadFixtureOptions(path string, baseOpts Options) Options

{"IndentStyle": 2, "IndentWidth": 4}

type PrettierConfig ¶

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

PrettierConfig resolves .prettierrc settings for individual files.

Resolution is per-file: cfv walks up from the file's directory and uses the nearest directory containing a supported .prettierrc variant. Unlike .editorconfig, prettier configs are not merged across directory levels — the closest file found entirely determines the result.

The zero value is not usable; use NewPrettierConfig.

Safe for concurrent use.

func NewPrettierConfig() *PrettierConfig

func (p *PrettierConfig) Apply(opts *Options, path string)

type QuoteStyle ¶

type QuoteStyle int

QuoteStyle controls string scalar quoting.

const (
	// QuotePreserve keeps the original quoting style from the source.
	QuotePreserve QuoteStyle = iota
	// QuoteDouble forces double-quoted strings.
	QuoteDouble
	// QuoteSingle forces single-quoted strings.
	QuoteSingle
)

type SequenceIndent ¶

type SequenceIndent int

SequenceIndent controls indentation of YAML sequences under mapping keys.

const (
	// SequenceIndentDefault means the formatter uses its own convention.
	SequenceIndentDefault SequenceIndent = iota
	// SequenceIndentEnabled indents sequences one level under mapping keys.
	SequenceIndentEnabled
	// SequenceIndentDisabled keeps sequence indicators aligned with the key's
	// value indentation.
	SequenceIndentDisabled
)

type Taplo ¶

type Taplo struct {
	Formatting TaploFormatting `toml:"formatting"`
}

Taplo is a parsed taplo.toml. It only applies to TOML files.

func LoadTaplo(startDir string) *Taplo

func (t *Taplo) Apply(opts *Options)

type TaploFormatting ¶

type TaploFormatting struct {
	IndentString       *string `toml:"indent_string"`
	ColumnWidth        *int    `toml:"column_width"`
	TrailingNewline    *bool   `toml:"trailing_newline"`
	ReorderKeys        *bool   `toml:"reorder_keys"`
	CRLF               *bool   `toml:"crlf"`
	ArrayTrailingComma *bool   `toml:"array_trailing_comma"`
}

TaploFormatting mirrors the [formatting] table of a taplo.toml, limited to the options cfv can represent. A nil field means the option is unset.

Options cfv has no equivalent for (align_entries, align_comments, compact_arrays, compact_inline_tables, array_auto_expand, array_auto_collapse) are ignored, so cfv may still diverge from taplo on those specific behaviors.

type TrailingCommas ¶

type TrailingCommas int

TrailingCommas controls trailing commas on multiline collections.

const (
	// TrailingCommasPreserve matches the style already used by the file:
	// a file with any trailing comma gets them everywhere, a file with
	// none keeps none.
	TrailingCommasPreserve TrailingCommas = iota
	// TrailingCommasAll always adds trailing commas. It is the JSONC default,
	// matching Prettier's trailingComma: "all" behavior.
	TrailingCommasAll
	// TrailingCommasNone always removes trailing commas.
	TrailingCommasNone
)

type XMLWhitespace ¶

type XMLWhitespace int

XMLWhitespace controls XML whitespace sensitivity.

const (
	// XMLWhitespaceIgnore treats all whitespace as insignificant.
	// The formatter inserts newlines and indentation freely.
	// Default for config files (POM, .csproj, plist).
	XMLWhitespaceIgnore XMLWhitespace = iota
	// XMLWhitespacePreserve only modifies existing indentation.
	// Never inserts or removes newlines. Safe for XHTML/SVG.
	XMLWhitespacePreserve
)

type Yamlfmt ¶

type Yamlfmt struct {
	Formatter YamlfmtFormatter `yaml:"formatter"`
}

Yamlfmt is a parsed .yamlfmt config. It only applies to YAML files.

func LoadYamlfmt(startDir string) *Yamlfmt

func (y *Yamlfmt) Apply(opts *Options)

type YamlfmtFormatter ¶

type YamlfmtFormatter struct {
	Indent        *int    `yaml:"indent"`
	LineEnding    *string `yaml:"line_ending"`
	MaxLineLength *int    `yaml:"max_line_length"`
}

YamlfmtFormatter mirrors the formatter: table of a .yamlfmt config, limited to the options cfv can represent. A nil field means the option is unset.

Options cfv has no equivalent for (include_document_start, retain_line_breaks, pad_line_comments, and other yamlfmt-only knobs) are ignored.