kclvm

package module
v0.4.2-alpha.9 Latest Latest
Warning

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

 Go to latest Published: Jun 24, 2022 License: Apache-2.0 Imports: 8 Imported by: 0

README

kclvm-go: KCLVM binding for Go

GoDoc Coverage Status license

$ go version
go version go1.17.8 darwin/arm64
$ which kclvm
$ kclvm -m kclvm --version
kclvm version is 0.4.1; checksum: ***

Run Test and hello.k

$ go test ./...
$ go run ./cmds/kcl-go
$ go run ./cmds/kcl-go run hello.k

Run KCL Code with kclvm-go

package main

import (
	"fmt"

	"kusionstack.io/kclvm-go"
)

func main() {
	yaml := kclvm.MustRun("hello.k", kclvm.WithCode(k_code)).First().YAMLString()
	fmt.Println(yaml)
}

const k_code = `
import kcl_plugin.hello

name = "kcl"
age = 1
two = hello.add(1, 1)

schema Person:
    name: str = "kcl"
    age: int = 1

x0 = Person {}
x1 = Person {
    age = 101
}
`

Output:

$ go run ./examples/hello/main.go 
age: 1
name: kcl
two: 2
x0:
    age: 1
    name: kcl
x1:
    age: 101
    name: kcl

Develop Guide

License

Apache License Version 2.0

Documentation

Overview

KCLVM binding for Go 

┌─────────────────┐         ┌─────────────────┐           ┌─────────────────┐
│     kcl files   │         │   KCLVM-Go-API  │           │  KCLResultList  │
│  ┌───────────┐  │         │                 │           │                 │
│  │    1.k    │  │         │                 │           │                 │
│  └───────────┘  │         │                 │           │  ┌───────────┐  │         ┌───────────────┐
│  ┌───────────┐  │         │  ┌───────────┐  │           │  │ KCLResult │──┼────────▶│x.Get("a.b.c") │
│  │    2.k    │  │         │  │ Run(path) │  │           │  └───────────┘  │         └───────────────┘
│  └───────────┘  │────┐    │  └───────────┘  │           │                 │
│  ┌───────────┐  │    │    │                 │           │  ┌───────────┐  │         ┌───────────────┐
│  │    3.k    │  │    │    │                 │           │  │ KCLResult │──┼────────▶│x.Get("k", &v) │
│  └───────────┘  │    │    │                 │           │  └───────────┘  │         └───────────────┘
│  ┌───────────┐  │    ├───▶│  ┌───────────┐  │──────────▶│                 │
│  │setting.yml│  │    │    │  │RunFiles() │  │           │  ┌───────────┐  │         ┌───────────────┐
│  └───────────┘  │    │    │  └───────────┘  │           │  │ KCLResult │──┼────────▶│x.JSONString() │
└─────────────────┘    │    │                 │           │  └───────────┘  │         └───────────────┘
                       │    │                 │           │                 │
┌─────────────────┐    │    │                 │           │  ┌───────────┐  │         ┌───────────────┐
│     Options     │    │    │  ┌───────────┐  │           │  │ KCLResult │──┼────────▶│x.YAMLString() │
│WithOptions      │    │    │  │MustRun()  │  │           │  └───────────┘  │         └───────────────┘
│WithOverrides    │────┘    │  └───────────┘  │           │                 │
│WithWorkDir      │         │                 │           │                 │
│WithDisableNone  │         │                 │           │                 │
└─────────────────┘         └─────────────────┘           └─────────────────┘
Example 
const k_code = `
import kcl_plugin.hello

name = "kcl"
age = 1

two = hello.add(1, 1)

schema Person:
    name: str = "kcl"
    age: int = 1

x0 = Person {}
x1 = Person {
	age = 101
}
`

yaml := kclvm.MustRun("testdata/main.k", kclvm.WithCode(k_code)).First().YAMLString()
fmt.Println(yaml)

fmt.Println("----")

result := kclvm.MustRun("./testdata/main.k").First()
fmt.Println(result.JSONString())

fmt.Println("----")
fmt.Println("x0.name:", result.Get("x0.name"))
fmt.Println("x1.age:", result.Get("x1.age"))

fmt.Println("----")

var person struct {
	Name string
	Age  int
}
fmt.Printf("person: %+v\n", result.Get("x1", &person))

Output:

Index

Examples

Constants

View Source 
const KclvmAbiVersion = scripts.KclvmAbiVersion

KclvmAbiVersion is the current kclvm ABI version.

Variables

This section is empty.

Functions

func FormatCode 

func FormatCode(code interface{}) ([]byte, error)

FormatCode returns the formatted code.

Example 
out, err := kclvm.FormatCode(`a  =  1+2`)
if err != nil {
	log.Fatal(err)
}
fmt.Println(string(out))

Output:

a = 1 + 2

func FormatPath 

func FormatPath(path string) (changedPaths []string, err error)

FormatPath formats files from the given path path: if path is `.` or empty string, all KCL files in current directory will be formatted, not recursively if path is `path/file.k`, the specified KCL file will be formatted if path is `path/to/dir`, all KCL files in the specified dir will be formatted, not recursively if path is `path/to/dir/...`, all KCL files in the specified dir will be formatted recursively

the returned changedPaths are the changed file paths (relative path)

Example 
changedPaths, err := kclvm.FormatPath("testdata/fmt")
if err != nil {
	log.Fatal(err)
}
fmt.Println(changedPaths)

Output:

func InitKclvmPath 

func InitKclvmPath(kclvmRoot string)

InitKclvmPath init kclvm path.

func InitKclvmRuntime 

func InitKclvmRuntime(n int)

InitKclvmRuntime init kclvm process.

func LintPath 

func LintPath(path string) (results []string, err error)

LintPath lint files from the given path

Example 
// import abc # unable to import
// import a
// import a # reimport

results, err := kclvm.LintPath("testdata/lint/import.k")
if err != nil {
	log.Fatal(err)
}
for _, s := range results {
	fmt.Println(s)
}

Output:

Unable to import abc.
a is reimported multiple times.
a imported but unused.

func ListDepFiles 

func ListDepFiles(workDir string, opt *ListDepFilesOption) (files []string, err error)

ListDepFiles return the depend files from the given path

func ListDownStreamFiles 

func ListDownStreamFiles(workDir string, opt *ListDepsOption) ([]string, error)

ListDownStreamFiles return a list of downstream depend files from the given changed path list.

func ListUpStreamFiles 

func ListUpStreamFiles(workDir string, opt *ListDepsOption) (deps []string, err error)

ListUpStreamFiles return a list of upstream depend files from the given path list

func OverrideFile 

func OverrideFile(file string, specs, importPaths []string) (bool, error)

OverrideFile rewrites a file with override spec file: string. The File that need to be overridden specs: []string. List of specs that need to be overridden. 

Each spec string satisfies the form: <pkgpath>:<field_path>=<filed_value> or <pkgpath>:<field_path>-
When the pkgpath is '__main__', it can be omitted.

importPaths. List of import statements that need to be added

func ValidateCode 

func ValidateCode(data, code string, opt *ValidateOptions) (ok bool, err error)

ValidateCode validate data match code

Types

type KCLResult 

type KCLResult = kcl.KCLResult
Example 
const k_code = `
import kcl_plugin.hello

name = "kcl"
age = 1
	
two = hello.add(1, 1)
	
schema Person:
    name: str = "kcl"
    age: int = 1

x0 = Person {name = "kcl-go"}
x1 = Person {age = 101}
`

result := kclvm.MustRun("testdata/main.k", kclvm.WithCode(k_code)).First()

fmt.Println("x0.name:", result.Get("x0.name"))
fmt.Println("x1.age:", result.Get("x1.age"))

Output:

x0.name: kcl-go
x1.age: 101

func EvalCode 

func EvalCode(code string) (*KCLResult, error)

type KCLResultList 

type KCLResultList = kcl.KCLResultList

func MustRun 

func MustRun(path string, opts ...Option) *KCLResultList

MustRun is like Run but panics if return any error.

Example 
yaml := kclvm.MustRun("testdata/main.k", kclvm.WithCode(`name = "kcl"`)).First().YAMLString()
fmt.Println(yaml)

Output:

name: kcl
Example (RawYaml) 
const code = `
b = 1
a = 2
`
yaml := kclvm.MustRun("testdata/main.k", kclvm.WithCode(code)).GetRawYamlResult()
fmt.Println(yaml)

yaml_sorted := kclvm.MustRun("testdata/main.k", kclvm.WithCode(code), kclvm.WithSortKeys(true)).GetRawYamlResult()
fmt.Println(yaml_sorted)

Output:

b: 1
a: 2

a: 2
b: 1
Example (SchemaType) 
const code = `
schema Person:
	name: str = ""

x = Person()
`
json := kclvm.MustRun("testdata/main.k", kclvm.WithCode(code)).First().JSONString()
fmt.Println(json)

json_with_type := kclvm.MustRun("testdata/main.k", kclvm.WithCode(code), kclvm.WithIncludeSchemaTypePath(true)).First().JSONString()
fmt.Println(json_with_type)

Output:

{
    "x": {
        "name": ""
    }
}
{
    "x": {
        "@type": "Person",
        "name": ""
    }
}
Example (Settings) 
yaml := kclvm.MustRun("./testdata/app0/kcl.yaml").First().YAMLString()
fmt.Println(yaml)

Output:

func Run 

func Run(path string, opts ...Option) (*KCLResultList, error)

Run evaluates the KCL program with path and opts, then returns the object list.

Example (GetField) 
// run kcl.yaml
x, err := kclvm.Run("./testdata/app0/kcl.yaml")
assert(err == nil, err)

// print deploy_topology[1].zone
fmt.Println(x.First().Get("deploy_topology.1.zone"))

Output:

R000A

func RunFiles 

func RunFiles(paths []string, opts ...Option) (*KCLResultList, error)

RunFiles evaluates the KCL program with multi file path and opts, then returns the object list.

Example 
result, _ := kclvm.RunFiles([]string{"./testdata/app0/kcl.yaml"})
fmt.Println(result.First().YAMLString())

Output:

type KclType 

type KclType = kcl.KclType

func GetSchemaType 

func GetSchemaType(file, code, schemaName string) ([]*KclType, error)

GetSchemaType returns schema types from a kcl file or code.

file: string 

The kcl filename

code: string 

The kcl code string

schema_name: string 

The schema name got, when the schema name is empty, all schemas are returned.

type ListDepFilesOption 

type ListDepFilesOption = list.Option

type ListDepsOption 

type ListDepsOption = list.DepOption

type Option 

type Option = kcl.Option

func WithCode 

func WithCode(codes ...string) Option

WithCode returns a Option which hold a kcl source code list.

func WithDisableNone 

func WithDisableNone(disableNone bool) Option

WithDisableNone returns a Option which hold a disable none switch.

func WithIncludeSchemaTypePath 

func WithIncludeSchemaTypePath(includeSchemaTypePath bool) Option

WithIncludeSchemaTypePath returns a Option which hold a includeSchemaTypePath switch.

func WithKFilenames 

func WithKFilenames(filenames ...string) Option

WithKFilenames returns a Option which hold a filenames list.

func WithOptions 

func WithOptions(key_value_list ...string) Option

WithOptions returns a Option which hold a key=value pair list for option function.

Example 
const code = `
name = option("name")
age = option("age")
`
x, err := kclvm.Run("hello.k", kclvm.WithCode(code),
	kclvm.WithOptions("name=kcl", "age=1"),
)
if err != nil {
	log.Fatal(err)
}

fmt.Println(x.First().YAMLString())

Output:

age: 1
name: kcl

func WithOverrides 

func WithOverrides(override_list ...string) Option

WithOverrides returns a Option which hold a override list.

func WithPrintOverridesAST 

func WithPrintOverridesAST(printOverridesAST bool) Option

WithPrintOverridesAST returns a Option which hold a printOverridesAST switch.

func WithSettings 

func WithSettings(filename string) Option

WithSettings returns a Option which hold a settings file.

func WithSortKeys 

func WithSortKeys(sortKeys bool) Option

WithSortKeys returns a Option which hold a sortKeys switch.

func WithWorkDir 

func WithWorkDir(workDir string) Option

WithWorkDir returns a Option which hold a work dir.

type ValidateOptions 

type ValidateOptions = validate.ValidateOptions

Source Files

View all Source files

Directories

Path Synopsis
cmds
kcl-go
Kusion Configuration Language (KCL) is a declarative configuration language inspired by Python3 designed for Cloud-Native scenes used in Kusion.
 Kusion Configuration Language (KCL) is a declarative configuration language inspired by Python3 designed for Cloud-Native scenes used in Kusion.
kcl-go/command
examples
hello
pkg
3rdparty/grpc_gateway_util
ast
compiler/parser
Package parser implements a parser for KCL source files.
 Package parser implements a parser for KCL source files.
kcl
Package kcl defines the top-level interface for the Kusion Configuration Language (KCL).
 Package kcl defines the top-level interface for the Kusion Configuration Language (KCL).
kclvm_runtime
langserver
logger
service
settings
spec/gpyrpc
tools/format
tools/genpb
tools/ktest
Package ktest defines helper functions for kcl-test.
 Package ktest defines helper functions for kcl-test.
tools/lint
tools/list
tools/override
tools/validate
utils
Package scripts provides usefull script for kclvm-go.
 Package scripts provides usefull script for kclvm-go.

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.