parser

type AnsibleConfig ¶

type AnsibleConfig struct {
	Inventory string
}

func LoadConfig(fsys fs.FS, dir string) (AnsibleConfig, error)

type AnsibleProject ¶

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

func ParseProject(fsys fs.FS, root string, opts ...Option) (*AnsibleProject, error)

func (p *AnsibleProject) ListTasks() ResolvedTasks

func (p *AnsibleProject) Path() string

type GalaxyManifest ¶

type GalaxyManifest struct {
	Namespace string `yaml:"namespace"`
	Name      string `yaml:"name"`
}

type Mapping ¶

type Mapping struct {
	Fields *orderedmap.OrderedMap[string, *Node]
}

func (m *Mapping) MarshalYAML() (any, error)

type Module ¶

type Module struct {
	*Node

	Name string
}

Module represents a logical module in a playbook or task. It wraps a Node and provides module-specific utility methods.

All the data and metadata for the module is stored in the embedded Node.

func (m *Module) IsFreeForm() bool

# Free-form
- command: echo "Hello"
  # IsFreeForm() -> true

# Structured
- ansible.builtin.yum:
    name: vim
    state: present
  # IsFreeForm() -> false

type Node ¶

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

func (n *Node) AsBool() (bool, bool)

func (n *Node) AsString() (string, bool)

func (n *Node) BoolValue(path string) iacTypes.BoolValue

func (n *Node) IsBool() bool

func (n *Node) IsKnown() bool

func (n *Node) IsList() bool

func (n *Node) IsMap() bool

func (n *Node) IsNil() bool

func (n *Node) IsString() bool

func (n *Node) MarshalYAML() (any, error)

func (n *Node) Metadata() iacTypes.Metadata

func (n *Node) NodeAt(path string) *Node

func (n *Node) Render(variables vars.Vars) (*Node, error)

func (n *Node) StringValue(path string) iacTypes.StringValue

func (n *Node) Subtree(r Range) *Node

func (n *Node) ToList() []*Node

func (n *Node) ToMap() map[string]*Node

func (n *Node) UnmarshalYAML(node *yaml.Node) error

func (n *Node) Value() any

type NodeValue ¶

type NodeValue interface {
	MarshalYAML() (any, error)
	// contains filtered or unexported methods
}

type Option ¶

type Option func(p *Parser)

func WithExtraVars(v map[string]any) Option

func WithInventories(inventories ...string) Option

func WithPlaybooks(playbooks ...string) Option

type Parser ¶

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

func New(fsys fs.FS, root string, opts ...Option) *Parser

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

type Play ¶

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

Play represents a single play in an Ansible playbook.

An Ansible playbook is a list of such plays, where each play defines settings and tasks for a specific group of hosts.

Example playbook YAML:

• name: My first play hosts: myhosts tasks:
• name: Ping my hosts ping:

This play contains a name, target hosts, and a list of tasks.

func (p *Play) Hosts() string

func (p *Play) UnmarshalYAML(node *yaml.Node) error

func (p *Play) Variables() vars.Vars

type Playbook ¶

type Playbook struct {
	Src   fsutils.FileSource
	Plays []*Play
	Tasks []*Task
}

Playbook represents a sequence of plays in an Ansible playbook.

A playbook is typically loaded from a YAML file and contains a list of plays that are executed in order.

The playbook corresponds to a YAML list, for example:

• name: First play hosts: all tasks:

• ...

• name: Second play hosts: dbservers tasks:

• ...

type Range ¶

type Range struct {
	Start int
	End   int
}

func (r Range) Covers(other Range) bool

func (r Range) Overlaps(o Range) bool

type ResolvedTask ¶

type ResolvedTask struct {
	Name   string
	Fields orderedmap.OrderedMap[string, *Node]
	Vars   vars.Vars

	Metadata iacTypes.Metadata
	Range    Range
}

ResolvedTask represents an Ansible task with all variables resolved.

It holds only the essential data needed for execution and ensures the original Task remains unmodified.

func (t *ResolvedTask) GetFieldsByRange(r Range) map[string]*Node

func (t *ResolvedTask) MarshalYAML() (any, error)

func (t *ResolvedTask) ResolveModule(keys []string, strict bool) (Module, error)

type ResolvedTasks ¶

type ResolvedTasks []*ResolvedTask

func (t ResolvedTasks) FilterByState(exclude ...string) ResolvedTasks

func (t ResolvedTasks) GetModules(keys ...string) []Module

type Role ¶

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

Role represent project role

type RoleDefinition ¶

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

RoleDefinition represents a role reference within a play.

It typically contains the role name and optional parameters that customize how the role is applied.

Example usage in a playbook:

roles:
  - common
  - role: webserver
    vars:
      http_port: 80

func (r *RoleDefinition) UnmarshalYAML(node *yaml.Node) error

type RoleIncludeModule ¶

type RoleIncludeModule struct {
	Name         string
	TasksFrom    string
	DefaultsFrom string
	VarsFrom     string
}

RoleIncludeModule represents the "include_role" or "import_role" module

type RoleMeta ¶

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

func (m *RoleMeta) UnmarshalYAML(node *yaml.Node) error

type Scalar ¶

type Scalar struct {
	Val any
}

func (s *Scalar) MarshalYAML() (any, error)

type Sequence ¶

type Sequence struct {
	Items []*Node
}

func (s *Sequence) MarshalYAML() (any, error)

type Task ¶

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

Task represents a single Ansible task.

A task defines a single unit of work, which may include running a module, calling a role, or including other task files.

Tasks can contain parameters, conditions (when), loops, and other Ansible constructs.

Example task:

• name: Install nginx apt: name: nginx state: present

func (t *Task) UnmarshalYAML(node *yaml.Node) error

func (t *Task) Variables() vars.Vars