Help us shape the future of Go! Take the 2026 Go Developer Survey

tablo

package module
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: Oct 21, 2026 License: MIT Imports: 22 Imported by: 0

README

tablo

The Tableaux backend: a Go library and a plumbing command that load, validate, audit and derive a Tableaux project from a Git repository and serve every abstract view as data.

The name plays on Tableaux: it spells the pronunciation.

Place in the family

Project Role
tableaux The language: method, syntax, schemas, corpus, mockups
tablo The backend: library and plumbing command
tabloio The command line: textual output and Git input
tablotui The terminal user interface
tableaud The local daemon: HTML views with progressive disclosure

The split follows Git's own: tablo is plumbing that reads a repository and emits data, and the three front ends are porcelain that presents it. A front end never reads a task file itself.

What it does

  • Load a project's .tableaux directory from a worktree or from any Git ref.
  • Validate every file against the schemas and the rules in the method.
  • Derive what the files leave to Git and to inheritance: resolved junctions, requirement conditions, authorisation, review, roll-up, history and subproject status.
  • Audit the discrepancies between files and history as actionable findings.
  • Serve every abstract view as JSON through the tablo command, with a role filter and focusing parameters.
tablo validate                       # diagnostics for the working tree
tablo audit --ref v1.0               # findings at a tag
tablo tableau --json                 # the global tableau as data
tablo queue --person ada@example.org --json
tablo trailer reviewed 9f31 design   # the trailer line a porcelain commits

Layout

The module is github.com/nbyoung/tablo. Its shape is the template every front end in the family copies.

.
├── go.mod                     # the module; the go directive pins the toolchain
├── doc.go                     # package tablo: the library
├── version.go                 # Version and the tableaux versions the module accepts
├── version_test.go
├── params.go                  # the views, the levels, the roles and the parameters a view takes
├── errors.go                  # the usage, not-found and read errors, which fix the exit code
├── envelope.go                # the envelope every command's data travels in, and its JSON
├── envelope.schema.yaml       # the envelope's schema, embedded
├── yaml.go                    # the same envelope as YAML
├── trailer.go                 # the four commit trailers as Git writes them
├── snapshot.go                # Open, Load and the snapshot: the one place that joins the internal packages
├── view/                      # package view: the data of each view, the types a front end names
├── cmd/tablo/main.go          # command tablo: the plumbing command
├── internal/model/            # the typed model of a project as its files state it, with positions
├── internal/git/              # the one place that runs the git executable
├── internal/load/             # the Loader: one project from the working tree or a revision, and its links
├── internal/validate/         # the Validator: the rules of the method's RULES.md over a loaded project
├── internal/history/          # the one pass over the Git history that the Derivation reads
├── internal/derive/           # the Derivation: the facts the files leave to Git and to inheritance
├── internal/views/            # the views: one function per view over the derived facts, and the builders they share
├── internal/audit/            # the Audit: a finding per diagnostic, proposed task, stale status and sole review, with who resolves it
├── internal/cli/              # the command's argument parser, plain forms and usage text
├── internal/corpustest/       # the copy of the conformance corpus at a locked tableaux commit, its build, its labels and its rules: a test helper
├── internal/conformance/      # the conformance test: the command run over every corpus entry, and the entries that wait for a fix
├── schemas/                   # the tableaux schema files, embedded into the binary
├── .tableaux/                 # this project's plan
├── .github/workflows/
│   ├── ci.yml                 # format, vet, lint and test on every push and pull request; the corpus; macOS and Windows
│   └── release.yml            # build and publish on a tag
├── .goreleaser.yaml           # the six targets and the release archives
└── .golangci.yml              # the lint set

schemas/ holds a copy of the schema files that the tableaux schema-files task produces; schemas/README.md records the commit copied, and schemas/embed.go embeds the five files into the binary.

A prototype under prototype/ is the function gate's demonstration. It goes when its task records implementation: the design's account of what it kept from the prototype and git log -- prototype/<id> keep what it showed, and the trunk builds what it ships.

Build and test

Go builds the module with no other tool; the version in go.mod decides which toolchain go fetches.

go build ./...                       # the library and the command
go test ./...                        # the tests
go run ./cmd/tablo version           # prints the version
gofmt -l . && go vet ./...           # what CI checks first
golangci-lint run                    # the lint set in .golangci.yml

CI runs those four checks on every push and pull request. Its job corpus runs the conformance test on the tableaux repository at the locked commit, and its job platforms runs go vet, the tests and the corpus in place on macOS and Windows. Contributors work from the sibling checkout beside the tableaux repository; a personal go.work there builds the family together and stays uncommitted.

go test ./... also runs the conformance test, which needs git and sh and no network. internal/corpustest carries a copy of the tableaux conformance corpus at the commit internal/corpustest/corpus.lock.yaml names, builds its entries in a temporary directory, and internal/conformance runs the built command over each of them. Four environment variables steer it. TABLO_CORPUS names another corpus directory in place of the copy, such as the corpus/ of a tableaux checkout, and adds the tableaux-tooling entry that only a checkout can read. TABLO_BIN names a built command in place of the one the test builds, such as the binary of a release archive. TABLO_KEEP keeps the temporary directory and prints its path, and each mismatch then shows the full command line. TABLO_REPORT names a file that receives the coverage report. sh internal/corpustest/corpus.sh refresh <tableaux checkout> [<commit>] renews the copy and its lock.

Release

A tag v<major>.<minor>.<patch> releases. The release workflow runs GoReleaser from .goreleaser.yaml, which cross-compiles cmd/tablo with CGO_ENABLED=0 for Linux, macOS and Windows on amd64 and arm64 and publishes one archive per target and a checksum file to the GitHub release for the tag. No user installs Go: they fetch one file from the release page.

git tag v0.2.0 && git push origin v0.2.0

Version in version.go names the release the next tag makes; bump it in the same change that tags.

Versions accepted

version.yaml in a project states the tableaux language version its files follow. The module accepts a project whose major version equals its own and whose minor version does not exceed it, as the method's version rule states. This module accepts major 0 and minor up to 4, so 0.0.x, 0.1.x, 0.2.x, 0.3.x and 0.4.x pass and 0.5.0 and 1.0.0 do not. Accepts in the root package applies the rule and the loader task calls it.

Dependencies

The owner decided at the function gate, after every prototype wrote its own YAML reader, that the implementation takes two libraries, which make three modules:

Module Version Purpose
gopkg.in/yaml.v3 v3 Parse project files; yaml.Node keeps the line and column of every value
github.com/santhosh-tekuri/jsonschema/v6 v6 Validate files against the embedded JSON Schema 2020-12 schemas

The schema module brings a third, golang.org/x/text v0.14.0 (BSD-3-Clause), as an indirect requirement that the binary links: it holds the message catalogue of the schema module, whose wording the Validator never prints.

All three are pure Go, so the six release targets still build with CGO_ENABLED=0. go.mod requires all three; go fetches the modules from the module proxy, and no one installs anything by hand. The prototypes under prototype/ predate the decision and keep their stand-in readers.

Plan

The project's plan is the Tableaux project in .tableaux/. The Tableaux tooling plan in the tableaux repository pins this project as the submodule subprojects/tablo and tracks its root task through a recursive junction, states the review policy every task here inherits, and proposes Go as the implementation language.

Licence

MIT.

Documentation

Overview

Package tablo is the Tableaux backend: a library that loads, validates, audits and derives a Tableaux project from a Git repository and serves every abstract view as data. Command tablo, in cmd/tablo, is a thin shell over the library: plumbing that reads a repository and emits data.

A caller opens a Repository once and loads a Snapshot per change: Load reads the files and the history once, and the snapshot then derives every view from memory. View returns one view's Envelope, Validate the diagnostics and CheckTrailer the check of a commit trailer; the command encodes the same envelope as JSON or YAML, so the two cannot disagree. Linked returns the snapshot of a subproject that the load already read, with its own source and views; Resolve resolves a ref in a snapshot's own repository, a linked one's included; and AuthorTime gives the time of the commit read, with its zone. The data of each view has its types in package view.

The library reads neither the environment nor the clock: the caller passes the viewer and the date staleness counts from in Params. Where the caller names no viewer, DefaultViewer applies the rule of the command's --viewer to the value of GIT_AUTHOR_EMAIL that the caller reads and passes: 

p.Viewer = tablo.DefaultViewer(ctx, dir, os.Getenv("GIT_AUTHOR_EMAIL"))

Index

Constants

View Source 
const (
	AcceptedMajor = model.AcceptedMajor
	AcceptedMinor = model.AcceptedMinor
)

The tableaux language versions the module accepts. The method's version rule accepts a project whose major version equals the tool's own and whose minor version does not exceed it; the patch version never matters. The rule itself lives in internal/model, where the Loader applies it.

View Source 
const SchemaVersion = "tablo/1"

SchemaVersion names the output schema: the envelope and every command's data.

View Source 
const Version = "0.2.0"

Version is the tablo release version. The tag v<Version> releases it, so a release bumps this constant first.

Variables

View Source 
var EnvelopeSchema []byte

EnvelopeSchema is envelope.schema.yaml, the JSON Schema of the envelope.

Functions

func Accepts 

func Accepts(v string) bool

Accepts reports whether the module accepts a project whose version.yaml states the tableaux language version v, written as major.minor.patch. A malformed version is not accepted.

func DefaultViewer 

func DefaultViewer(ctx context.Context, dir, author string) string

DefaultViewer returns the viewer when the caller names none, by the rule of 4ed9 decision 18 (a): author, when it is not empty; else the user.email that Git's configuration gives in dir, the repository's and the user's; else nobody, "". A value that is no email address stands for nobody, and so does a directory Git cannot read. The library reads no environment: the caller passes the value of GIT_AUTHOR_EMAIL as author. 

viewer := tablo.DefaultViewer(ctx, dir, os.Getenv("GIT_AUTHOR_EMAIL"))

func ParseVersion 

func ParseVersion(v string) (major, minor, patch int, ok bool)

ParseVersion splits a tableaux language version into its numbers. It accepts exactly the form version.schema.yaml accepts: three decimal integers without leading zeros, joined by dots. ok is false otherwise.

Types

type Brief 

type Brief struct{ Task, Gate string }

A Brief names the one queue item the queue view writes as a brief.

type Diagnostic 

type Diagnostic struct {
	Severity string `json:"severity"` // "error", "warning" or "information"
	Code     string `json:"code"`     // the rule id of corpus/RULES.md
	Path     string `json:"path,omitempty"`
	Line     int    `json:"line,omitempty"`
	Col      int    `json:"col,omitempty"`
	Task     string `json:"task,omitempty"`
	Gate     string `json:"gate,omitempty"`
	Commit   string `json:"commit,omitempty"`
	Trailer  string `json:"trailer,omitempty"`
	Message  string `json:"message"`
}

A Diagnostic is one finding of the loader or the validator. Path is relative to the directory -C names, starts with .tableaux/ and uses / on every host; Line and Col are 1-based. A field that does not apply is empty or zero and the encodings omit it.

type Envelope 

type Envelope struct {
	Schema      string       `json:"schema"`
	Command     string       `json:"command"`
	Source      *Source      `json:"source"`
	Project     *ProjectInfo `json:"project"`
	Viewer      *Viewer      `json:"viewer"`
	Params      Resolved     `json:"params"`
	Data        any          `json:"data"` // a view's typed data (A5 to A8), or nil
	Diagnostics []Diagnostic `json:"diagnostics"`
}

An Envelope is the result of one command: what the library returns and what the command encodes. Field order is the key order of the output.

func (*Envelope) ExitCode 

func (e *Envelope) ExitCode() int

ExitCode returns 1 when a diagnostic is an error, else 0.

func (*Envelope) JSON 

func (e *Envelope) JSON() []byte

JSON returns the JSON encoding: a two-space indent, no HTML escaping, one final newline, and the keys in the declaration order of the Go types. A nil list of diagnostics or roles encodes as []. It panics when Data does not marshal, which is a fault of the view that built it.

func (*Envelope) YAML 

func (e *Envelope) YAML() []byte

YAML returns the YAML respelling of JSON(): the same document, every string double-quoted, no library involved in writing it.

type Level 

type Level string

Level is "glance", "detail" or "provenance". 

const (
	LevelGlance     Level = "glance"
	LevelDetail     Level = "detail"
	LevelProvenance Level = "provenance"
)

The three levels, from the least to the most a view shows.

type LinkError 

type LinkError struct {
	URL, Commit     string // the link: an absolute URL as written or the path cleaned, and its commit
	Problem, Detail string
}

A LinkError reports a subproject field whose link leads to no project (4ed9 decision 18 b): the url names a link of the load, and the Loader found no project there. Problem is the reason's name, as RULES.md's J8 and J9 read it: "outside", "missing", "no clone", "bad commit", "commit absent", "no project", "too deep" or, for an unpinned requirement whose clone holds no branch to read, "no trunk". Detail says more.

func (*LinkError) Error 

func (e *LinkError) Error() string

Error names the link and why it leads to no project.

type NotFoundError 

type NotFoundError struct{ Kind, Name string }

A NotFoundError reports a well-formed ref, task or gate that the repository or the project lacks: the command exits 3. Kind is "ref", "task" or "gate".

func (*NotFoundError) Error 

func (e *NotFoundError) Error() string

Error names what is missing.

type Options 

type Options struct {
	Trunk   string            // the branch the caller names; read when version.yaml and origin/HEAD name none
	Replace map[string]string // an absolute subproject URL to the directory of its local clone
}

Options are what a caller states about a repository beyond its files.

type Params 

type Params struct {
	Task       string   // a task id
	Person     string   // an email
	Viewer     string   // whoever runs the tool; "" is an observer
	Role       Role     // the role whose level the view opens at
	Level      Level    // the level, overriding the role's
	Window     *int     // tableau, context: columns either side of the next gates; nil is 1
	Columns    []string // tableau, context: the gate keys to show, in place of a window
	Historical bool     // tableau, context: show the marks of historical junctions
	Proposed   bool     // authority: proposed tasks only
	Brief      *Brief   // queue: write this one item as a brief
	Stale      int      // audit: days after which a status is stale; 0 is 7
	Now        string   // audit: the date staleness counts from, YYYY-MM-DD; required
	Minimum    string   // audit: the lowest severity listed, "error", "warning" or "information"; "" is "warning"
	From       string   // history: the ref the range starts after; "" is the whole history
}

Params focus a view. The zero value asks for every default. Check returns a *UsageError when p sets a field v does not take or holds a malformed value, by the rules of the command table. Narrow returns p without the fields v does not take, for a front end that carries one state across views.

func (Params) Check 

func (p Params) Check(v View) error

Check returns a *UsageError when p sets a field v does not take or holds a malformed value, or sets fields that exclude each other: --window with --columns, --task with --person on context, and --brief with --level or --role. It reads no environment, so it does not require a person or a viewer; the resolution of defaults does.

func (Params) Narrow 

func (p Params) Narrow(v View) Params

Narrow returns p without the fields v does not take. It keeps Viewer, Role and Level, which every view takes, and it changes nothing else: a malformed value or a conflict between fields v takes stays for Check to report. For a name that is no view it returns the zero value.

type ProjectInfo 

type ProjectInfo struct {
	Tableaux string `json:"tableaux"`
	Root     string `json:"root"`
	Title    string `json:"title"`
	Owner    string `json:"owner"`
}

ProjectInfo names the project: the language version version.yaml states, the root task, its title and its assignee.

type ReadError 

type ReadError struct {
	Op  string
	Err error
}

A ReadError reports a repository that cannot be read: the command exits 3. Op names what failed and Err says why.

func (*ReadError) Error 

func (e *ReadError) Error() string

Error joins the operation and its cause.

func (*ReadError) Unwrap 

func (e *ReadError) Unwrap() error

Unwrap returns the cause.

type Repository 

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

A Repository is a long-lived handle on one project directory, safe for concurrent use. Resolve returns the full id of the commit a ref names. Load reads the project and its history once: the ref "" reads the files from the working tree and the history from HEAD; a commit-ish reads both from that commit; a tree reads the files alone, for Validate. A project that fails validation still loads, and the snapshot carries the diagnostics.

func Open 

func Open(ctx context.Context, dir string, opt Options) (*Repository, error)

Open finds the Git repository that holds dir and returns a handle on the project whose .tableaux lies in dir, or nearest above it. It reads no project file. The error is a *ReadError.

func (*Repository) Load 

func (r *Repository) Load(ctx context.Context, ref string) (*Snapshot, error)

Load reads the project at ref and its history, validates it and derives its facts. The error is a *NotFoundError for a ref that names no commit or tree, or a *ReadError.

func (*Repository) Resolve 

func (r *Repository) Resolve(ctx context.Context, ref string) (string, error)

Resolve returns the full id of the commit ref names. The error is a *NotFoundError for a ref that names no commit, or a *ReadError.

type Resolved 

type Resolved struct {
	View View
	Params
}

Resolved holds a command's parameters with every default written in. It marshals the keys its command takes, each present and null when unset, in the order task, person, window, columns, historical, proposed, brief, stale, now, minimum, role, level; for a command that is no view it marshals {}.

func (Resolved) MarshalJSON 

func (r Resolved) MarshalJSON() ([]byte, error)

MarshalJSON writes the keys View takes, each present, in the fixed order.

type Role 

type Role string

Role is "owner", "authority", "assignee", "contributor", "agent", "reviewer" or "observer". 

const (
	RoleOwner       Role = "owner"
	RoleAuthority   Role = "authority"
	RoleAssignee    Role = "assignee"
	RoleContributor Role = "contributor"
	RoleAgent       Role = "agent"
	RoleReviewer    Role = "reviewer"
	RoleObserver    Role = "observer"
)

The seven roles, in the order README.md lists them; observer is the role of an email that holds none.

type Snapshot 

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

A Snapshot is one project at one source. It is immutable and safe for concurrent use, and it computes each derived fact once.

func (*Snapshot) AuthorTime 

func (s *Snapshot) AuthorTime() string

AuthorTime returns the author time of the commit the load read, with the zone Git records, as git log --format=%aI prints it: 2026-09-01T21:30:00-07:00. Its day is Source.Date. It is "" where Date is nil: a tree, an unborn branch, or a commit the pass lacks.

func (*Snapshot) CheckTrailer 

func (s *Snapshot) CheckTrailer(t Trailer) error

CheckTrailer returns a *UsageError when t is malformed and a *NotFoundError when t names a task the project lacks or, for a reviewed trailer, a gate that gates.yaml lacks or that does not apply to the task.

func (*Snapshot) Checkouts 

func (s *Snapshot) Checkouts() []string

Checkouts returns the directories of the submodule checkouts whose HEAD gave a pin of this load, absolute and sorted: what a watcher polls beside the working tree, since a moved checkout changes what the project reads (4f60 decision 9). It is empty for a load at a ref.

func (*Snapshot) Diagnostics 

func (s *Snapshot) Diagnostics() []Diagnostic

Diagnostics returns what the Loader and the Validator report, sorted and never nil.

func (*Snapshot) GateKeys 

func (s *Snapshot) GateKeys() []string

GateKeys returns the gate keys of gates.yaml, in order.

func (*Snapshot) HasTask 

func (s *Snapshot) HasTask(id string) bool

HasTask reports whether the project holds the task.

func (*Snapshot) Linked 

func (s *Snapshot) Linked(url, commit string) (*Snapshot, error)

Linked returns the snapshot of the project a subproject field links to, as this load read it (4ed9 decision 18 b): at the commit the link fixes, from a submodule's checkout or store, from a directory of the same repository, or from the clone that Options.Replace or Git's configuration names for an absolute URL. It runs no second walk of the repository: the project, its passes and its facts are the ones Load already holds. The snapshot has its own source, project, diagnostics and views; its Checkouts are those of the links it holds in turn.

url is the field's url: an absolute URL as written, or a path, which Linked cleans as the Loader does, so that "./firmware" and "firmware" name one link. commit is "" unless the files link one absolute URL at more than one commit; then it names the one wanted. The error is a *NotFoundError of kind "subproject" for a url that names no link of the load, a *LinkError for a link that leads to no project, and a *UsageError for a url linked at several commits with none named.

func (*Snapshot) Project 

func (s *Snapshot) Project() *ProjectInfo

Project returns the project's name and owner, or nil when the files give no root task.

func (*Snapshot) Resolve 

func (s *Snapshot) Resolve(ctx context.Context, ref string) (string, error)

Resolve returns the full id of the commit ref names in the snapshot's own repository (4ed9 decision 20), as Repository.Resolve does for the repository Open opened. A snapshot that Load returns resolves there. One that Linked returns resolves wherever the parent's load read the link: a submodule's checkout or store, the same repository for a directory, or the clone that Options.Replace or Git's configuration names for an absolute URL. The error is a *NotFoundError of kind "ref" for a ref that names no commit, or a *ReadError.

func (*Snapshot) Source 

func (s *Snapshot) Source() Source

Source returns what Load read.

func (*Snapshot) Validate 

func (s *Snapshot) Validate() *Envelope

Validate returns the validate command's envelope.

func (*Snapshot) View 

func (s *Snapshot) View(ctx context.Context, v View, p Params) (*Envelope, error)

View checks and resolves p for v, derives the view and returns its envelope. The error is a *UsageError, a *NotFoundError or a *ReadError; an invalid project is no error: the envelope then has nil Data.

func (*Snapshot) Viewer 

func (s *Snapshot) Viewer(email string) Viewer

Viewer returns the roles the email holds anywhere in the project, in README.md's order; an observer when it holds none or is "".

type Source 

type Source struct {
	Ref      string      `json:"ref"`      // the name given; for the working tree, the branch HEAD names, or HEAD
	Dir      string      `json:"dir"`      // the project's directory, relative to the repository's root; "." at the root
	Worktree bool        `json:"worktree"` // the files come from disk and the history from HEAD
	Commit   *string     `json:"commit"`   // the commit in full
	Date     *string     `json:"date"`     // the commit's author date, YYYY-MM-DD
	From     *SourceFrom `json:"from"`     // the start of a range, for history alone
	Trunk    SourceTrunk `json:"trunk"`
	OnTrunk  bool        `json:"on_trunk"`
}

A Source states what a command read. Dir is the directory that holds the project's .tableaux, relative to the repository's root with / on every host, and "." at the root: the nearest at or above the directory -C names, or that directory itself when none is. Commit and Date are nil when the source is a bare tree.

type SourceFrom 

type SourceFrom struct {
	Ref    string `json:"ref"`
	Commit string `json:"commit"`
}

A SourceFrom is the start of a range: the ref as given and its commit.

type SourceTrunk 

type SourceTrunk struct {
	Name     *string `json:"name"`
	Resolved string  `json:"resolved"`
}

A SourceTrunk names the trunk and how it resolves: "stated", "inferred", "caller" or "undetermined". Name is nil when it is undetermined.

type Trailer 

type Trailer struct {
	Kind  string // "authorised", "reviewed", "reaffirmed" or "model"
	Task  string // for the three task trailers
	Gate  string // for reviewed
	Model string // for model: printable ASCII with no space
}

A Trailer is one of the four commit trailers of SYNTAX.md. Line returns it as Git writes it, with no newline, or a *UsageError when a field is missing, extra or malformed.

func (Trailer) Line 

func (t Trailer) Line() (string, error)

Line returns the trailer as one line of a commit message: "Authorised: <id>", "Reviewed: <id> <gate>", "Reaffirmed: <id>" or "Model: <identifier>". It checks the syntax of each field and reads no project; a task or gate the project lacks is for Snapshot.CheckTrailer.

type UsageError 

type UsageError struct{ Msg string }

A UsageError reports parameters a command or a view does not accept: the command exits 2. Msg names the option or the value at fault.

func (*UsageError) Error 

func (e *UsageError) Error() string

Error returns the message.

type View 

type View string

A View names one of the ten views by its command name. 

const (
	Gates      View = "gates"
	Task       View = "task"
	Authority  View = "authority"
	Assignment View = "assignment"
	Queue      View = "queue"
	Blockage   View = "blockage"
	Tableau    View = "tableau"
	Context    View = "context"
	History    View = "history"
	Audit      View = "audit"
)

The ten views, each named as its mockup file is named.

type Viewer 

type Viewer struct {
	Email *string `json:"email"`
	Roles []Role  `json:"roles"`
}

A Viewer is whoever runs the tool, with the roles the email holds anywhere in the project. Email is nil for nobody, an observer.

Source Files

View all Source files

Directories

Path Synopsis
cmd
tablo command
Command tablo is the Tableaux plumbing command.
 Command tablo is the Tableaux plumbing command.
internal
audit
Package audit turns the Validator's diagnostics and three facts of the Derivation into findings: each names its task, its gate, its commits, the act that resolves it and the person who takes it, and holds the facts of the Derivation it rests on.
 Package audit turns the Validator's diagnostics and three facts of the Derivation into findings: each names its task, its gate, its commits, the act that resolves it and the person who takes it, and holds the facts of the Derivation it rests on.
cli
Package cli is the tablo command: the argument parser, the plain forms and the usage text, over the root package that does the work.
 Package cli is the tablo command: the argument parser, the plain forms and the usage text, over the root package that does the work.
conformance
Package conformance holds the conformance test of tablo: it runs the built command over every entry of the tableaux conformance corpus and compares what the command emits with the entry's expected.yaml, the findings by rule and location and then each derived fact the file states.
 Package conformance holds the conformance test of tablo: it runs the built command over every entry of the tableaux conformance corpus and compares what the command emits with the entry's expected.yaml, the findings by rule and location and then each derived fact the file states.
corpustest
Package corpustest gives a test the tableaux conformance corpus: a copy of the corpus at one locked tableaux commit, embedded into the package, the entries built from it in a work directory, the labels that name their commits and the rules RULES.md lists.
 Package corpustest gives a test the tableaux conformance corpus: a copy of the corpus at one locked tableaux commit, embedded into the package, the entries built from it in a work directory, the labels that name their commits and the rules RULES.md lists.
derive
Package derive gives every fact a view shows that no file states: each junction resolved through the ancestors with the supplier of every field, each requirement's condition, each task's authorisation, each status's date and recorder, each review, each parent's roll-up, each task's events, and each recursive junction's status from the subproject at its pin.
 Package derive gives every fact a view shows that no file states: each junction resolved through the ancestors with the supplier of every field, each requirement's condition, each task's authorisation, each status's date and recorder, each review, each parent's roll-up, each task's events, and each recursive junction's status from the subproject at its pin.
git
Package git is the one place that runs the git executable: it discovers a repository, runs a command in it, lists trees and the index, and reads blobs in one batch.
 Package git is the one place that runs the git executable: it discovers a repository, runs a command in it, lists trees and the index, and reads blobs in one batch.
history
Package history is the one place that reads a project's history.
 Package history is the one place that reads a project's history.
load
Package load is the Loader: it reads one Tableaux project, from the working tree or from any Git revision, and returns it as an immutable model with every project its files link to.
 Package load is the Loader: it reads one Tableaux project, from the working tree or from any Git revision, and returns it as an immutable model with every project its files link to.
model
Package model holds the typed model of a Tableaux project as its files state it: the version, the gating, every task and status as written, every subproject a file links to, and the position of every value.
 Package model holds the typed model of a Tableaux project as its files state it: the version, the gating, every task and status as written, every subproject a file links to, and the position of every value.
validate
Package validate is the Validator: it applies the rules of the method's RULES.md to a project the Loader read and returns diagnostics, each with a rule id, a severity and a position.
 Package validate is the Validator: it applies the rules of the method's RULES.md to a project the Loader read and returns diagnostics, each with a rule id, a severity and a position.
views
Package views builds each view's data from the derived facts.
 Package views builds each view's data from the derived facts.
Package schemas embeds the tableaux schema files that the module validates a project against.
 Package schemas embeds the tableaux schema files that the module validates a project against.
Package view holds the data of each view as tablo emits it: the Go types that an envelope's Data holds and that marshal to its JSON.
 Package view holds the data of each view as tablo emits it: the Go types that an envelope's Data holds and that marshal to its JSON.

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.