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

ast

package
v1.3.1 Latest Latest
Warning

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

Go to latest
Published: Feb 8, 2020 License: MIT Imports: 5 Imported by: 794

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Dump

func Dump(i interface{}) string

Dump turns ast into a stable string format for assertions in tests

Types

type Argument

type Argument struct {
	Name     string
	Value    *Value
	Position *Position `dump:"-"`
}

type ArgumentDefinition

type ArgumentDefinition struct {
	Description  string
	Name         string
	DefaultValue *Value
	Type         *Type
	Directives   DirectiveList
	Position     *Position `dump:"-"`
}

type ArgumentDefinitionList

type ArgumentDefinitionList []*ArgumentDefinition

func (ArgumentDefinitionList) ForName

type ArgumentList

type ArgumentList []*Argument

func (ArgumentList) ForName

func (l ArgumentList) ForName(name string) *Argument

type ChildValue

type ChildValue struct {
	Name     string
	Value    *Value
	Position *Position `dump:"-"`
}

type ChildValueList

type ChildValueList []*ChildValue

func (ChildValueList) ForName

func (v ChildValueList) ForName(name string) *Value

type Definition

type Definition struct {
	Kind        DefinitionKind
	Description string
	Name        string
	Directives  DirectiveList
	Interfaces  []string      // object and input object
	Fields      FieldList     // object and input object
	Types       []string      // union
	EnumValues  EnumValueList // enum

	Position *Position `dump:"-"`
	BuiltIn  bool      `dump:"-"`
}

ObjectDefinition is the core type definition object, it includes all of the definable types but does *not* cover schema or directives.

@vektah: Javascript implementation has different types for all of these, but they are more similar than different and don't define any behaviour. I think this style of "some hot" struct works better, at least for go.

Type extensions are also represented by this same struct.

func (*Definition) IsAbstractType

func (d *Definition) IsAbstractType() bool

func (*Definition) IsCompositeType

func (d *Definition) IsCompositeType() bool

func (*Definition) IsInputType

func (d *Definition) IsInputType() bool

func (*Definition) IsLeafType

func (d *Definition) IsLeafType() bool

func (*Definition) OneOf

func (d *Definition) OneOf(types ...string) bool

type DefinitionKind

type DefinitionKind string
const (
	Scalar      DefinitionKind = "SCALAR"
	Object      DefinitionKind = "OBJECT"
	Interface   DefinitionKind = "INTERFACE"
	Union       DefinitionKind = "UNION"
	Enum        DefinitionKind = "ENUM"
	InputObject DefinitionKind = "INPUT_OBJECT"
)

type DefinitionList

type DefinitionList []*Definition

func (DefinitionList) ForName

func (l DefinitionList) ForName(name string) *Definition

type Directive

type Directive struct {
	Name      string
	Arguments ArgumentList
	Position  *Position `dump:"-"`

	// Requires validation
	ParentDefinition *Definition
	Definition       *DirectiveDefinition
	Location         DirectiveLocation
}

func (*Directive) ArgumentMap

func (d *Directive) ArgumentMap(vars map[string]interface{}) map[string]interface{}

type DirectiveDefinition

type DirectiveDefinition struct {
	Description string
	Name        string
	Arguments   ArgumentDefinitionList
	Locations   []DirectiveLocation
	Position    *Position `dump:"-"`
}

type DirectiveDefinitionList

type DirectiveDefinitionList []*DirectiveDefinition

func (DirectiveDefinitionList) ForName

type DirectiveList

type DirectiveList []*Directive

func (DirectiveList) ForName

func (l DirectiveList) ForName(name string) *Directive

func (DirectiveList) ForNames added in v1.2.0

func (l DirectiveList) ForNames(name string) []*Directive

type DirectiveLocation

type DirectiveLocation string
const (
	// Executable
	LocationQuery              DirectiveLocation = `QUERY`
	LocationMutation           DirectiveLocation = `MUTATION`
	LocationSubscription       DirectiveLocation = `SUBSCRIPTION`
	LocationField              DirectiveLocation = `FIELD`
	LocationFragmentDefinition DirectiveLocation = `FRAGMENT_DEFINITION`
	LocationFragmentSpread     DirectiveLocation = `FRAGMENT_SPREAD`
	LocationInlineFragment     DirectiveLocation = `INLINE_FRAGMENT`

	// Type System
	LocationSchema               DirectiveLocation = `SCHEMA`
	LocationScalar               DirectiveLocation = `SCALAR`
	LocationObject               DirectiveLocation = `OBJECT`
	LocationFieldDefinition      DirectiveLocation = `FIELD_DEFINITION`
	LocationArgumentDefinition   DirectiveLocation = `ARGUMENT_DEFINITION`
	LocationInterface            DirectiveLocation = `INTERFACE`
	LocationUnion                DirectiveLocation = `UNION`
	LocationEnum                 DirectiveLocation = `ENUM`
	LocationEnumValue            DirectiveLocation = `ENUM_VALUE`
	LocationInputObject          DirectiveLocation = `INPUT_OBJECT`
	LocationInputFieldDefinition DirectiveLocation = `INPUT_FIELD_DEFINITION`
)

type Dumpable

type Dumpable interface {
	Dump() string
}

type EnumValueDefinition

type EnumValueDefinition struct {
	Description string
	Name        string
	Directives  DirectiveList
	Position    *Position `dump:"-"`
}

type EnumValueList

type EnumValueList []*EnumValueDefinition

func (EnumValueList) ForName

func (l EnumValueList) ForName(name string) *EnumValueDefinition

type Field

type Field struct {
	Alias        string
	Name         string
	Arguments    ArgumentList
	Directives   DirectiveList
	SelectionSet SelectionSet
	Position     *Position `dump:"-"`

	// Require validation
	Definition       *FieldDefinition
	ObjectDefinition *Definition
}

func (*Field) ArgumentMap

func (f *Field) ArgumentMap(vars map[string]interface{}) map[string]interface{}

func (*Field) GetPosition

func (s *Field) GetPosition() *Position

type FieldDefinition

type FieldDefinition struct {
	Description  string
	Name         string
	Arguments    ArgumentDefinitionList // only for objects
	DefaultValue *Value                 // only for input objects
	Type         *Type
	Directives   DirectiveList
	Position     *Position `dump:"-"`
}

type FieldList

type FieldList []*FieldDefinition

func (FieldList) ForName

func (l FieldList) ForName(name string) *FieldDefinition

type FragmentDefinition

type FragmentDefinition struct {
	Name string
	// Note: fragment variable definitions are experimental and may be changed
	// or removed in the future.
	VariableDefinition VariableDefinitionList
	TypeCondition      string
	Directives         DirectiveList
	SelectionSet       SelectionSet

	// Require validation
	Definition *Definition

	Position *Position `dump:"-"`
}

type FragmentDefinitionList

type FragmentDefinitionList []*FragmentDefinition

func (FragmentDefinitionList) ForName

type FragmentSpread

type FragmentSpread struct {
	Name       string
	Directives DirectiveList

	// Require validation
	ObjectDefinition *Definition
	Definition       *FragmentDefinition

	Position *Position `dump:"-"`
}

func (*FragmentSpread) GetPosition

func (s *FragmentSpread) GetPosition() *Position

type InlineFragment

type InlineFragment struct {
	TypeCondition string
	Directives    DirectiveList
	SelectionSet  SelectionSet

	// Require validation
	ObjectDefinition *Definition

	Position *Position `dump:"-"`
}

func (*InlineFragment) GetPosition

func (s *InlineFragment) GetPosition() *Position

type Operation

type Operation string
const (
	Query        Operation = "query"
	Mutation     Operation = "mutation"
	Subscription Operation = "subscription"
)

type OperationDefinition

type OperationDefinition struct {
	Operation           Operation
	Name                string
	VariableDefinitions VariableDefinitionList
	Directives          DirectiveList
	SelectionSet        SelectionSet
	Position            *Position `dump:"-"`
}

type OperationList

type OperationList []*OperationDefinition

func (OperationList) ForName

func (l OperationList) ForName(name string) *OperationDefinition

type OperationTypeDefinition

type OperationTypeDefinition struct {
	Operation Operation
	Type      string
	Position  *Position `dump:"-"`
}

type OperationTypeDefinitionList

type OperationTypeDefinitionList []*OperationTypeDefinition

func (OperationTypeDefinitionList) ForType

type Position

type Position struct {
	Start  int     // The starting position, in runes, of this token in the input.
	End    int     // The end position, in runes, of this token in the input.
	Line   int     // The line number at the start of this item.
	Column int     // The column number at the start of this item.
	Src    *Source // The source document this token belongs to
}

type QueryDocument

type QueryDocument struct {
	Operations OperationList
	Fragments  FragmentDefinitionList
	Position   *Position `dump:"-"`
}

type Schema

type Schema struct {
	Query        *Definition
	Mutation     *Definition
	Subscription *Definition

	Types      map[string]*Definition
	Directives map[string]*DirectiveDefinition

	PossibleTypes map[string][]*Definition
	Implements    map[string][]*Definition
}

func (*Schema) AddImplements

func (s *Schema) AddImplements(name string, iface *Definition)

func (*Schema) AddPossibleType

func (s *Schema) AddPossibleType(name string, def *Definition)

func (*Schema) GetImplements

func (s *Schema) GetImplements(def *Definition) []*Definition

GetImplements returns all the interface and union definitions that the given definition satisfies

func (*Schema) GetPossibleTypes

func (s *Schema) GetPossibleTypes(def *Definition) []*Definition

GetPossibleTypes will enumerate all the definitions for a given interface or union

type SchemaDefinition

type SchemaDefinition struct {
	Description    string
	Directives     DirectiveList
	OperationTypes OperationTypeDefinitionList
	Position       *Position `dump:"-"`
}

type SchemaDefinitionList

type SchemaDefinitionList []*SchemaDefinition

type SchemaDocument

type SchemaDocument struct {
	Schema          SchemaDefinitionList
	SchemaExtension SchemaDefinitionList
	Directives      DirectiveDefinitionList
	Definitions     DefinitionList
	Extensions      DefinitionList
	Position        *Position `dump:"-"`
}

func (*SchemaDocument) Merge

func (d *SchemaDocument) Merge(other *SchemaDocument)

type Selection

type Selection interface {
	GetPosition() *Position
	// contains filtered or unexported methods
}

type SelectionSet

type SelectionSet []Selection

type Source

type Source struct {
	// Name is the filename of the source
	Name string
	// Input is the actual contents of the source file
	Input string
	// BuiltIn indicate whether the source is a part of the specification
	BuiltIn bool
}

Source covers a single *.graphql file

type Type

type Type struct {
	NamedType string
	Elem      *Type
	NonNull   bool
	Position  *Position `dump:"-"`
}

func ListType

func ListType(elem *Type, pos *Position) *Type

func NamedType

func NamedType(named string, pos *Position) *Type

func NonNullListType

func NonNullListType(elem *Type, pos *Position) *Type

func NonNullNamedType

func NonNullNamedType(named string, pos *Position) *Type

func (*Type) Dump

func (v *Type) Dump() string

func (*Type) IsCompatible

func (t *Type) IsCompatible(other *Type) bool

func (*Type) Name

func (t *Type) Name() string

func (*Type) String

func (t *Type) String() string

type Value

type Value struct {
	Raw      string
	Children ChildValueList
	Kind     ValueKind
	Position *Position `dump:"-"`

	// Require validation
	Definition         *Definition
	VariableDefinition *VariableDefinition
	ExpectedType       *Type
}

func (*Value) Dump

func (v *Value) Dump() string

func (*Value) String

func (v *Value) String() string

func (*Value) Value

func (v *Value) Value(vars map[string]interface{}) (interface{}, error)

type ValueKind

type ValueKind int
const (
	Variable ValueKind = iota
	IntValue
	FloatValue
	StringValue
	BlockValue
	BooleanValue
	NullValue
	EnumValue
	ListValue
	ObjectValue
)

type VariableDefinition

type VariableDefinition struct {
	Variable     string
	Type         *Type
	DefaultValue *Value
	Position     *Position `dump:"-"`

	// Requires validation
	Definition *Definition
	Used       bool `dump:"-"`
}

type VariableDefinitionList

type VariableDefinitionList []*VariableDefinition

func (VariableDefinitionList) ForName

Jump to

Keyboard shortcuts

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