config

package
v0.7.0 Latest Latest
Warning

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

Go to latest
Published: Apr 27, 2026 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var DefaultFiles = []string{"**/*.md", "**/*.markdown"}

DefaultFiles is the built-in list of glob patterns used for file discovery when no file arguments are given on the command line.

View Source
var ValidCategories = []string{
	"heading",
	"whitespace",
	"code",
	"list",
	"line",
	"link",
	"meta",
	"table",
}

ValidCategories lists the recognized rule category names.

Functions

func ApplyCategories

func ApplyCategories(
	rules map[string]RuleCfg,
	categories map[string]bool,
	ruleCategory func(ruleName string) string,
	explicit map[string]bool,
) map[string]RuleCfg

ApplyCategories disables rules whose category is disabled, unless the rule has been explicitly configured (present in the explicit rules map). ruleCategory maps a rule name to its category string. The explicit map contains rule names that were explicitly set in config (not just inherited from defaults).

func Discover

func Discover(startDir string) (string, error)

Discover walks up the directory tree from startDir looking for a .mdsmith.yml config file. It stops searching when it encounters a .git directory (the repository root) or reaches the filesystem root. Returns the path to the config file, or "" if none was found.

func Effective

func Effective(cfg *Config, filePath string, fmKinds []string) map[string]RuleCfg

Effective returns the effective rule configuration for a given file path. It starts with the top-level rules, applies kinds in effective-list order (fmKinds from front matter first, then kind-assignment matches), and finally applies glob overrides. Later entries take precedence.

func EffectiveAll added in v0.7.0

func EffectiveAll(
	cfg *Config, filePath string, fmKinds []string,
) (map[string]RuleCfg, map[string]bool, map[string]bool)

EffectiveAll returns the effective rule config, category settings, and explicit rule set for a file path while resolving effective kinds once and reusing that result across all three computations.

func EffectiveCategories

func EffectiveCategories(cfg *Config, filePath string, fmKinds []string) map[string]bool

EffectiveCategories returns the effective category settings for a given file path. It starts with the top-level categories, applies kinds in effective-list order, and then applies matching overrides. Categories not explicitly set default to true (enabled).

func EffectiveExplicitRules

func EffectiveExplicitRules(cfg *Config, filePath string, fmKinds []string) map[string]bool

EffectiveExplicitRules returns the set of rule names that were explicitly configured for a given file path. It includes rules from the top-level ExplicitRules, any rules set by matching kinds, and any rules set by matching overrides.

func InjectArchetypeRoots added in v0.6.0

func InjectArchetypeRoots(cfg *Config)

InjectArchetypeRoots copies cfg.Archetypes.Roots into every required-structure rule block (top-level, override, or kind) that does not already set its own archetype-roots. This is a no-op when no roots are configured at the top level. Rules with archetype-roots already specified are left untouched.

func IsIgnored

func IsIgnored(patterns []string, path string) bool

IsIgnored returns true if the file path matches any of the given ignore patterns. It checks the raw path, the cleaned path, and the base name.

func ParseSize added in v0.6.0

func ParseSize(s string) (int64, error)

ParseSize parses a human-readable size string into bytes. Accepted formats: "2MB", "500KB", "1GB", bare integer (bytes), "0" (unlimited). Case-insensitive. Uses binary units (1 KB = 1024, 1 MB = 1048576, 1 GB = 1073741824).

func ValidateFrontMatterKinds added in v0.7.0

func ValidateFrontMatterKinds(cfg *Config, filePath string, kinds []string) error

ValidateFrontMatterKinds returns an error if any of the supplied front-matter kind names is not declared in cfg.Kinds. filePath is used in the message.

func ValidateKinds added in v0.7.0

func ValidateKinds(cfg *Config) error

ValidateKinds returns an error if any kind named in a kind-assignment entry is not declared in cfg.Kinds. Front-matter kinds are validated at lint time via ValidateFrontMatterKinds (see engine).

Types

type ArchetypesCfg added in v0.6.0

type ArchetypesCfg struct {
	Roots []string `yaml:"roots"`
}

ArchetypesCfg configures archetype discovery. Roots are directories searched in order; earlier roots shadow later ones.

type Config

type Config struct {
	Rules          map[string]RuleCfg    `yaml:"rules"`
	Ignore         []string              `yaml:"ignore"`
	Overrides      []Override            `yaml:"overrides"`
	FrontMatter    *bool                 `yaml:"front-matter"`
	Categories     map[string]bool       `yaml:"categories"`
	Files          []string              `yaml:"files"`
	FollowSymlinks bool                  `yaml:"follow-symlinks"`
	MaxInputSize   string                `yaml:"max-input-size"`
	Archetypes     ArchetypesCfg         `yaml:"archetypes"`
	Kinds          map[string]KindBody   `yaml:"kinds,omitempty"`
	KindAssignment []KindAssignmentEntry `yaml:"kind-assignment,omitempty"`

	// LegacyNoFollowSymlinks captures the removed `no-follow-symlinks`
	// key. Its presence surfaces a deprecation warning via
	// Deprecations; its contents are otherwise ignored now that
	// symlinks are skipped by default. The `omitempty` tag keeps
	// round-tripped configs from re-emitting the deprecated key
	// unless a user explicitly supplied it.
	LegacyNoFollowSymlinks []string `yaml:"no-follow-symlinks,omitempty"`

	// ExplicitRules tracks rule names that were explicitly set in
	// the user config (not just inherited from defaults). This is
	// used for category override resolution: an explicitly enabled
	// rule takes precedence over a disabled category.
	// Not serialized to YAML.
	ExplicitRules map[string]bool `yaml:"-"`

	// FilesExplicit tracks whether the files key was explicitly set
	// in the user config. This distinguishes between an omitted key
	// (use defaults) and an explicitly empty list (no files).
	// Not serialized to YAML.
	FilesExplicit bool `yaml:"-"`

	// Deprecations lists human-readable warnings about deprecated
	// keys found in the loaded config. Callers (cmd/mdsmith) print
	// them to stderr.
	// Not serialized to YAML.
	Deprecations []string `yaml:"-"`
}

Config is the top-level configuration.

func Defaults

func Defaults() *Config

Defaults returns a Config with all registered rules using each rule's default enabled state and no custom settings.

func DumpDefaults

func DumpDefaults() *Config

DumpDefaults returns a Config with all registered rules using each rule's default enabled state. Enabled rules that implement Configurable have their DefaultSettings() included in RuleCfg.Settings. Categories are included with all set to true (enabled). This is consumed by `mdsmith init` to generate a default config file.

func Load

func Load(path string) (*Config, error)

Load reads and parses a config file at the given path.

func Merge

func Merge(defaults, loaded *Config) *Config

Merge merges a loaded config on top of defaults. The loaded config's rules override the defaults; any rule not mentioned in loaded keeps its default value. Ignore and Overrides come from the loaded config only. Categories from the loaded config are merged on top of defaults; any category not mentioned in loaded keeps its default value (true).

type KindAssignmentEntry added in v0.7.0

type KindAssignmentEntry struct {
	Files []string `yaml:"files"`
	Kinds []string `yaml:"kinds"`
}

KindAssignmentEntry assigns one or more kinds to files matching glob patterns. The glob syntax is the same as overrides: and ignore:.

type KindBody added in v0.7.0

type KindBody struct {
	Rules      map[string]RuleCfg `yaml:"rules"`
	Categories map[string]bool    `yaml:"categories"`
}

KindBody is a named bundle of rule settings. It has the same shape as Override minus the Files field; files are bound to kinds separately via front-matter kinds: or kind-assignment:.

type Override

type Override struct {
	Files      []string           `yaml:"files"`
	Rules      map[string]RuleCfg `yaml:"rules"`
	Categories map[string]bool    `yaml:"categories"`
}

Override applies rule settings to files matching glob patterns.

type RuleCfg

type RuleCfg struct {
	Enabled  bool
	Settings map[string]any
}

RuleCfg is a YAML union: can be bool (enable/disable) or map[string]any (settings).

func (RuleCfg) MarshalYAML

func (r RuleCfg) MarshalYAML() (any, error)

MarshalYAML implements custom YAML marshalling for RuleCfg. A disabled rule (Enabled=false, no Settings) serializes as `false`. An enabled rule with settings serializes as the settings mapping. An enabled rule with no settings serializes as `true`.

func (*RuleCfg) UnmarshalYAML

func (r *RuleCfg) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML implements custom YAML unmarshalling for RuleCfg. It handles three forms:

  • false -> Enabled=false, Settings=nil
  • true -> Enabled=true, Settings=nil
  • {key: val, ...} -> Enabled=true, Settings={key: val, ...}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL