transform

type CaseStep struct {
	Path string `yaml:"path"`
	// To is "upper" or "lower".
	To string `yaml:"to"`
}

type Change struct {
	Step string `json:"step"`
	Path string `json:"path"`
	From string `json:"from"`
	To   string `json:"to"`
	// Note explains anything surprising, such as a value left unmapped.
	Note string `json:"note,omitempty"`

	// Deliberate marks a step that ran, left the value unchanged, and meant to.
	//
	// Needed because "the value did not change" otherwise means two opposite things. A date conversion with
	// on_error: keep did its job and is reporting the result; a copy from a field the message does not carry did
	// nothing and is the commonest silent bug there is. Without this flag the second was being counted as a change,
	// which told somebody their step worked.
	//
	// A flag rather than an inspection of Note, because a copy always sets a note to record where the value came
	// from, so the presence of a note says nothing about whether anything happened.
	Deliberate bool `json:"deliberate,omitempty"`
}

type ClearStep struct {
	Path string `yaml:"path"`
}

type CopyStep struct {
	From string `yaml:"from"`
	To   string `yaml:"to"`
	// Default is used when the source is empty. Without it, copying an absent
	// value clears the target, which is occasionally wanted and usually not.
	Default string `yaml:"default,omitempty"`
}

type DateStep struct {
	Path string `yaml:"path"`
	// From and To are Java SimpleDateFormat patterns, the same notation the
	// scripts use, so that one channel does not need two date vocabularies.
	From string `yaml:"from"`
	To   string `yaml:"to"`
	// OnError chooses what happens when the value does not match From:
	// "keep" leaves it alone, "clear" empties it, "fail" stops the message.
	// The default is "fail", because a timestamp that silently did not convert
	// is accepted downstream and then misread.
	OnError string `yaml:"on_error,omitempty"`
}

type MapStep struct {
	Path  string            `yaml:"path"`
	Table map[string]string `yaml:"table"`

	// Use names a shared table instead of writing one inline.
	//
	// The reason to have both: an inline table is right for a mapping only this channel will ever need, and a
	// shared one is right for the sex codes that forty channels translate identically. Forcing everything into
	// a shared file would make a one-off mapping a two-file change; forcing everything inline is what makes a
	// site maintain forty copies of the same table.
	//
	// A shared table also carries provenance - who decided, when, and why each row exists - which an inline
	// map cannot, because a YAML map has nowhere to put a comment that survives being rewritten by the form.
	Use string `yaml:"use,omitempty"`

	// Default applies when the value is not in the table. When it is empty and
	// Strict is false the original value is kept, which is the safe choice: an
	// unmapped local code preserved is recoverable, an unmapped code silently
	// blanked is not.
	Default string `yaml:"default,omitempty"`
	// Strict makes an unmapped value an error rather than a pass-through. Worth
	// turning on for a field the receiver validates against a closed set.
	Strict bool `yaml:"strict,omitempty"`
	// contains filtered or unexported fields
}

type PadStep struct {
	Path  string `yaml:"path"`
	Width int    `yaml:"width"`
	With  string `yaml:"with,omitempty"`
	// Right pads on the right instead of the left.
	Right bool `yaml:"right,omitempty"`
	// Truncate shortens a value that is already longer than Width. Off by
	// default, because truncating an identifier produces one that matches the
	// wrong patient.
	Truncate bool `yaml:"truncate,omitempty"`
}

type Path struct {
	Segment      string
	Occurrence   int // 1-based; 0 means every occurrence
	Field        int
	Repetition   int // 1-based; 0 means every repetition
	Component    int // 0 means the field itself
	Subcomponent int // 0 means the component itself
	// contains filtered or unexported fields
}

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

type RemoveStep struct {
	Path string `yaml:"path"`
}

type ReplaceStep struct {
	Path string `yaml:"path"`
	// Pattern is a Go regular expression, which is RE2: no backtracking, so a
	// pattern cannot take exponential time on a hostile input.
	Pattern string `yaml:"pattern"`
	With    string `yaml:"with"`
	// All replaces every occurrence rather than the first.
	All bool `yaml:"all,omitempty"`
}

type SetStep struct {
	Path  string `yaml:"path"`
	Value string `yaml:"value"`
}

type Skip struct {
	// Step is the step's description, or its kind when it has none.
	Step string `json:"step"`

	// Path is what it addressed.
	Path string `json:"path,omitempty"`

	// Why says what happened.
	Why string `json:"why"`
}

type Step struct {
	// Description is free text explaining why this step exists. It is optional
	// but strongly encouraged, and the interface shows it.
	Description string `yaml:"description,omitempty"`

	// When is an optional condition. The step is skipped unless it holds.
	When string `yaml:"when,omitempty"`

	// Set writes a literal value.
	Set *SetStep `yaml:"set,omitempty"`
	// Copy moves a value from one path to another.
	Copy *CopyStep `yaml:"copy,omitempty"`
	// Clear empties a field.
	Clear *ClearStep `yaml:"clear,omitempty"`
	// Remove deletes a segment or element outright.
	Remove *RemoveStep `yaml:"remove,omitempty"`
	// Map translates a value through a lookup table.
	Map *MapStep `yaml:"map,omitempty"`
	// Replace performs a regular-expression substitution.
	Replace *ReplaceStep `yaml:"replace,omitempty"`
	// Pad left- or right-pads a value to a fixed width.
	Pad *PadStep `yaml:"pad,omitempty"`
	// Date reformats a timestamp.
	Date *DateStep `yaml:"date,omitempty"`
	// Trim removes surrounding whitespace.
	Trim *TrimStep `yaml:"trim,omitempty"`
	// Case changes a value to upper or lower case.
	Case *CaseStep `yaml:"case,omitempty"`
	// contains filtered or unexported fields
}

type TrimStep struct {
	Path string `yaml:"path"`
}