manifest

Documentation

Index

• Constants
• type DevelopmentStatus
  • func (s DevelopmentStatus) Rank() int
• type Feature
• type InformationLoss
• type Manifest
  • func Load(path string) (*Manifest, error)
  • func (m *Manifest) Decode(r io.Reader) error
  • func (m *Manifest) Encode(w io.Writer) error
  • func (m Manifest) Supports(f Feature) bool
• type OS
  • func (os OS) AsImage() string
• type Versions
  • func (v Versions) String() string

Constants

const Filename = "manifest.toml"

Types

type DevelopmentStatus

type DevelopmentStatus string

const (
	Planning DevelopmentStatus = "planning"
	PreAlpha DevelopmentStatus = "pre-alpha"
	Alpha    DevelopmentStatus = "alpha"
	Beta     DevelopmentStatus = "beta"
	Stable   DevelopmentStatus = "stable"
	Mature   DevelopmentStatus = "mature"
	Inactive DevelopmentStatus = "inactive"
)

func (DevelopmentStatus) Rank

func (s DevelopmentStatus) Rank() int

Rank is an integer indicating driver stability. Higher is better.

type Feature

type Feature string

Feature describes which level of information driver can produce.

const (
	// AST is a basic feature required for the driver. Driver can parse files and return native language AST.
	AST Feature = "ast"
	// UAST feature indicates that driver properly converts AST to UAST without further annotating it.
	UAST Feature = "uast"
	// Roles feature indicates that driver annotates UAST with roles. All node types are annotated.
	Roles Feature = "roles"
)

type InformationLoss

type InformationLoss string

InformationLoss in terms of which kind of code generation would they allow.

const (
	// Lossless no information loss converting code to AST and then back to code
	// would. code == codegen(AST(code)).
	Lossless InformationLoss = "lossless"
	// FormatingLoss only superfluous formatting information is lost (e.g.
	// whitespace, indentation). Code generated from the AST could be the same
	// as the original code after passing a code formatter.
	// fmt(code) == codegen(AST(code)).
	FormatingLoss InformationLoss = "formating-loss"
	// SyntacticSugarLoss there is information loss about syntactic sugar. Code
	// generated from the AST could be the same as the original code after
	// desugaring it. desugar(code) == codegen(AST(code)).
	SyntacticSugarLoss InformationLoss = "syntactic-sugar-loss"
	// CommentLoss comments are not present in the AST.
	CommentLoss InformationLoss = "formating-loss"
)

type Manifest

type Manifest struct {
	Name            string            `toml:"name"` // human-readable name
	Language        string            `toml:"language"`
	Version         string            `toml:"version,omitempty"`
	Build           *time.Time        `toml:"build,omitempty"`
	Status          DevelopmentStatus `toml:"status"`
	InformationLoss []InformationLoss `toml:"loss"`
	Documentation   struct {
		Description string `toml:"description,omitempty"`
		Caveats     string `toml:"caveats,omitempty"`
	} `toml:"documentation,omitempty"`
	Runtime struct {
		OS             OS       `toml:"os"`
		NativeVersion  Versions `toml:"native_version"`
		NativeEncoding string   `toml:"native_encoding"`
		GoVersion      string   `toml:"go_version"`
	} `toml:"runtime"`
	Features []Feature `toml:"features"`
}

func Load

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

Load reads a manifest and decode the content into a new Manifest struct

func (*Manifest) Decode

func (m *Manifest) Decode(r io.Reader) error

Decode decodes reads r and decodes it into m

func (*Manifest) Encode

func (m *Manifest) Encode(w io.Writer) error

Encode encodes m in toml format and writes the restult to w

func (Manifest) Supports

func (m Manifest) Supports(f Feature) bool

Supports checks if driver supports specified feature.

type OS

type OS string

const (
	Alpine OS = "alpine"
	Debian OS = "debian"
)

func (OS) AsImage

func (os OS) AsImage() string

type Versions

type Versions []string

func (Versions) String

func (v Versions) String() string