sham

type Array ¶

type Array struct {
	Range *Range
	Inner Node
}

Array represents a list of values that can be generated. An array has two potential parts: an inner node and a range. The inner node defines the structure of the array elements, and the range defines how many elements should be present. The range is optional. If omitted, one element will be generated.

func (a Array) Generate() interface{}

type FormattedString ¶

type FormattedString struct {
	Raw    string
	Format string
	Params []Generator
}

FormattedString represents a string literal with values that can be interpolated into the string. In the Sham language, formatted strings are enclosed in backticks, and the interpolated values are enclosed by curly braces. Interpolated values must be valid, registered terminal generators.

func (f FormattedString) Generate() interface{}

type Generator ¶

type Generator interface {
	Generate() interface{}
}

Generator represents the core functionality behind Sham's data generation. Any type that implements this interface can be used to generate data. Implementors can be either data structures containing more data, or simpler functions that directly generate a sinlge piece of data. These latter objects are referred to as terminal generators since they are generally found as leaves in the AST.

type GeneratorFunc ¶

type GeneratorFunc func() interface{}

GeneratorFunc is a simple function type that implements the Generator interface. This type can be used to provide single functions as Generators.

func (f GeneratorFunc) Generate() interface{}

type KV ¶

type KV struct {
	Key   string
	Value Node
}

KV represents a single key-value pair in an Object.

type Literal ¶

type Literal struct {
	Value interface{}
}

Literal represents a literal value. No data generation is involved here, but rather values are returned as-is.

func (l Literal) Generate() interface{}

type Node ¶

type Node interface {
	Generator
}

Node represents a single element in the abstract syntax tree. A valid Sham AST must be able to generate data. As such, every node in tree must be implement the Generator interface. There are two main type of nodes: structural and terminal. Terminal nodes are leaves that generate values. Structural nodes generate the data structures that hold these values.

type Object ¶

type Object struct {
	Values []KV
}

Object represents a key-value data structure. In order to maintain the key order in the schema, the pairs are stored in a slice and converted to an ordered map during the generation process. If a key is provided multiple times, the last value will be used during generation.

func (m *Object) AppendPair(k string, v Node)

func (m Object) Generate() interface{}

type OrderedMap ¶

type OrderedMap struct {
	Values map[string]interface{}
	Keys   []string
}

func NewOrderedMap() *OrderedMap

func (m *OrderedMap) MarshalJSON() ([]byte, error)

func (m *OrderedMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (m *OrderedMap) Set(k string, v interface{})

type Parser ¶

type Parser struct {
	TerminalGenerators map[string]Generator
	// contains filtered or unexported fields
}

Parser maintains the internal state of the language parser. This struct takes a slice of tokens as input and produces an AST if and only if the token stream represents a valid Sham schema. Part of the internal state is the terminalGenerator map. This map of terminal generators must be set prior to the initiating the parsing method. If a terminal generator is referenced in the schema, but not defined in the terminal generator map, then the parsing process will be halted with an error.

To ensure the parser begins with the proper state, one of the constructor functions should be used.

func NewDefaultParser(d []byte) *Parser

func NewParser(d []byte) *Parser

func (p *Parser) Parse() (Schema, error)

func (p *Parser) RegisterGenerators(gs map[string]Generator)

type QuoteType ¶

type QuoteType byte

const (
	QuoteSingle   QuoteType = '\''
	QuoteDouble   QuoteType = '"'
	QuoteBacktick QuoteType = '`'
)

type Range ¶

type Range struct {
	Min int
	Max int
}

Range is an inclusive range of integers. Ranges have two uses within the a Sham schema. If provided as the first argument in an array, the range will be used to determine the number of elements to populate the array. If provided in the position of a terminal generator, then a random integer will be generated for the value.

func (r Range) Generate() interface{}

func (r Range) GetValue() int

type Regex ¶

type Regex struct {
	Pattern string
	// contains filtered or unexported fields
}

Regex holds a compiled regex. While any valid regular expression can be provided, only a subset will actually generate data. Every node in a parsed regex leads to a possible choice. During data generation, a random path through the parsed expression is taken. Therefore, a complciated expression has the potential to lead to wildly different performance on repeated generations.

TODO: fully document nodes that can generate data

func NewRegex(pattern string) (Regex, error)

func (r Regex) Generate() interface{}

type Scanner ¶

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

Scanner maintains of the state of the tokenization process. This scanner maintains an internal buffer to minimize allocations as the Scanner reads through the source.

func NewScanner(b []byte) *Scanner

func (s *Scanner) Scan() (tok TokenType, lit string)

type Schema ¶

type Schema struct {
	Root Node
}

Schema represents a Sham schema and holds the root of the AST. The root of the AST must either be a single terminal node, or a structural node.

func (s Schema) Generate() interface{}

type TerminalGenerator ¶

type TerminalGenerator struct {
	Name string
	// contains filtered or unexported fields
}

TerminalGenerator represents a function that can generate data.

func (t TerminalGenerator) Generate() interface{}

type Token ¶

type Token struct {
	Type  TokenType
	Value string
}

func Tokenize(source []byte) ([]Token, error)

type TokenType ¶

type TokenType int

const (
	TokInvalid TokenType = iota
	TokEOF
	TokWS
	// Structural tokens
	TokLBrace
	TokRBrace
	TokLBracket
	TokRBracket
	TokLParen
	TokRParen
	TokColon
	TokComma

	TokString
	TokFString
	TokRegex
	TokInteger
	TokFloat
	TokIdent

	TokNull
	TokTrue
	TokFalse
)

func (t TokenType) String() string