diff --git a/pkg/api/kpm_pkg.go b/pkg/api/kpm_pkg.go index 5a696d77..5f14850a 100644 --- a/pkg/api/kpm_pkg.go +++ b/pkg/api/kpm_pkg.go @@ -14,6 +14,28 @@ type KclPackage struct { pkg *pkg.KclPkg } +// The KCL Type + +// An additional field 'Name' is added to the original 'KclType'. +// +// 'Name' is the name of the kcl type. +// +// 'RelPath' is the relative path to the package home path. +type KclType struct { + Name string + RelPath string + *gpyrpc.KclType +} + +// NewKclTypes returns a new KclType. +func NewKclTypes(name, path string, tys *gpyrpc.KclType) *KclType { + return &KclType{ + Name: name, + RelPath: path, + KclType: tys, + } +} + // GetKclPackage returns the kcl package infomation. // // 'pkgPath' is the root path of the package where the 'kcl.mod' is located in. @@ -72,22 +94,31 @@ func (pkg *KclPackage) GetPkgProfile() pkg.Profile { // It will return a map of schema types, the key is the relative path to the package home path. // // And, the value is a map of schema types, the key is the schema name, the value is the schema type. -func (pkg *KclPackage) GetAllSchemaTypeMapping() (map[string]map[string]*gpyrpc.KclType, error) { - return pkg.GetSchemaTypeMappingNamed("") +func (pkg *KclPackage) GetAllSchemaTypeMapping() (map[string]map[string]*KclType, error) { + return pkg.GetSchemaTypeMappingWithFilters([]KclTypeFilterFunc{IsSchemaType}) } // GetSchemaTypeMappingNamed returns the schema type filtered by schema name. // // If 'schemaName' is empty, it will return all the schema types. -func (pkg *KclPackage) GetSchemaTypeMappingNamed(schemaName string) (map[string]map[string]*gpyrpc.KclType, error) { - schemaTypes := make(map[string]map[string]*gpyrpc.KclType) +func (pkg *KclPackage) GetSchemaTypeMappingNamed(schemaName string) (map[string]map[string]*KclType, error) { + namedFilterFunc := func(kt *KclType) bool { + return IsSchemaNamed(kt, schemaName) + } + return pkg.GetSchemaTypeMappingWithFilters([]KclTypeFilterFunc{IsSchemaType, namedFilterFunc}) +} + +// GetSchemaTypeMappingWithFilters returns the schema type filtered by the filter functions. +func (pkg *KclPackage) GetSchemaTypeMappingWithFilters(fileterFuncs []KclTypeFilterFunc) (map[string]map[string]*KclType, error) { + schemaTypes := make(map[string]map[string]*KclType) err := filepath.Walk(pkg.GetPkgHomePath(), func(path string, info os.FileInfo, err error) error { if err != nil { return err } if info.IsDir() { - schemaTypeMap, err := kcl.GetSchemaTypeMapping(path, "", schemaName) + fileteredKtypeMap := make(map[string]*KclType) + schemaTypeMap, err := kcl.GetSchemaTypeMapping(path, "", "") if err != nil { return err } @@ -97,7 +128,22 @@ func (pkg *KclPackage) GetSchemaTypeMappingNamed(schemaName string) (map[string] return err } - schemaTypes[relPath] = schemaTypeMap + for kName, kType := range schemaTypeMap { + kTy := NewKclTypes(kName, relPath, kType) + filterPassed := true + for _, filterFunc := range fileterFuncs { + if !filterFunc(kTy) { + filterPassed = false + break + } + } + if filterPassed { + fileteredKtypeMap[kName] = kTy + } + } + if len(fileteredKtypeMap) > 0 { + schemaTypes[relPath] = fileteredKtypeMap + } } return nil @@ -110,45 +156,24 @@ func (pkg *KclPackage) GetSchemaTypeMappingNamed(schemaName string) (map[string] return schemaTypes, nil } -// GetAllSchemaType returns all the schema types of the package. -// -// It will return a map of schema types, the key is the relative path to the package home path. -// -// And, the value is a slice of schema types. -func (pkg *KclPackage) GetAllSchemaType() (map[string][]*gpyrpc.KclType, error) { - return pkg.GetSchemaTypeNamed("") -} - -// GetSchemaTypeNamed returns the schema type filtered by schema name. -// -// If 'schemaName' is empty, it will return all the schema types. -func (pkg *KclPackage) GetSchemaTypeNamed(schemaName string) (map[string][]*gpyrpc.KclType, error) { - schemaTypes := make(map[string][]*gpyrpc.KclType) - err := filepath.Walk(pkg.GetPkgHomePath(), func(path string, info os.FileInfo, err error) error { - if err != nil { - return err - } - - if info.IsDir() { - schemaType, err := kcl.GetSchemaType(path, "", schemaName) - if err != nil { - return err - } - - relPath, err := filepath.Rel(pkg.GetPkgHomePath(), path) - if err != nil { - return err - } +type KclTypeFilterFunc func(kt *KclType) bool - schemaTypes[relPath] = schemaType - } +// IsSchema returns true if the type is schema. +func IsSchema(kt *KclType) bool { + return kt.Type == "schema" +} - return nil - }) +// IsSchemaType returns true if the type is schema type. +func IsSchemaType(kt *KclType) bool { + return IsSchema(kt) && kt.SchemaName == kt.Name +} - if err != nil { - return nil, err - } +// IsSchemaInstance returns true if the type is schema instance. +func IsSchemaInstance(kt *KclType) bool { + return IsSchema(kt) && kt.SchemaName != kt.Name +} - return schemaTypes, nil +// IsSchemaNamed returns true if the type is schema and the name is equal to the given name. +func IsSchemaNamed(kt *KclType, name string) bool { + return IsSchema(kt) && kt.Name == name } diff --git a/pkg/api/kpm_pkg_test.go b/pkg/api/kpm_pkg_test.go index 40b2a580..57a5e584 100644 --- a/pkg/api/kpm_pkg_test.go +++ b/pkg/api/kpm_pkg_test.go @@ -37,23 +37,15 @@ func TestPackageApi(t *testing.T) { schemas, err := pkg.GetAllSchemaTypeMapping() assert.Equal(t, err, nil) assert.Equal(t, len(schemas), 3) - assert.Equal(t, len(schemas["."]), 6) + assert.Equal(t, len(schemas["."]), 2) assert.Equal(t, len(schemas[filepath.Join("sub")]), 1) assert.Equal(t, len(schemas[filepath.Join("sub", "sub1")]), 2) // All schema types under the root path assert.Equal(t, schemas[filepath.Join(".")]["SchemaInMainK"].Type, "schema") assert.Equal(t, schemas[filepath.Join(".")]["SchemaInMainK"].SchemaName, "SchemaInMainK") - assert.Equal(t, schemas[filepath.Join(".")]["schema_in_main_k"].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")]["schema_in_main_k"].SchemaName, "SchemaInMainK") - assert.Equal(t, schemas[filepath.Join(".")]["schema_in_sub_k"].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")]["schema_in_sub_k"].SchemaName, "SchemaInSubK") assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].Type, "schema") assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") - assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name"].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name"].SchemaName, "SchemaWithSameName") - assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name_in_sub"].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name_in_sub"].SchemaName, "SchemaWithSameName") // All schema types under the root_path/sub path assert.Equal(t, schemas[filepath.Join("sub")]["SchemaInSubK"].Type, "schema") @@ -78,9 +70,8 @@ func TestGetAllSchemaTypesMappingNamed(t *testing.T) { schemas, err := pkg.GetSchemaTypeMappingNamed("SchemaWithSameName") assert.Equal(t, err, nil) - assert.Equal(t, len(schemas), 3) + assert.Equal(t, len(schemas), 2) assert.Equal(t, len(schemas["."]), 1) - assert.Equal(t, len(schemas[filepath.Join("sub")]), 0) assert.Equal(t, len(schemas[filepath.Join("sub", "sub1")]), 1) // // All schema types under the root path @@ -92,7 +83,8 @@ func TestGetAllSchemaTypesMappingNamed(t *testing.T) { assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") } -func TestGetAllSchemaTypes(t *testing.T) { +func TestGetSchemaTypeMappingWithFilters(t *testing.T) { + pkg_path := filepath.Join(getTestDir("test_kpm_package"), "kcl_pkg") kcl_pkg_path, err := GetKclPkgPath() @@ -102,60 +94,44 @@ func TestGetAllSchemaTypes(t *testing.T) { err = pkg.pkg.ResolveDepsMetadata(kcl_pkg_path, true) assert.Equal(t, err, nil) - schemas, err := pkg.GetAllSchemaType() + filterFunc := func(kt *KclType) bool { + return kt.Type != "schema" + } + schemas, err := pkg.GetSchemaTypeMappingWithFilters([]KclTypeFilterFunc{filterFunc}) assert.Equal(t, err, nil) - assert.Equal(t, len(schemas), 3) - assert.Equal(t, len(schemas["."]), 6) - assert.Equal(t, len(schemas[filepath.Join("sub")]), 1) - assert.Equal(t, len(schemas[filepath.Join("sub", "sub1")]), 2) - - // All schema types under the root path - assert.Equal(t, schemas[filepath.Join(".")][0].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][0].SchemaName, "SchemaInMainK") - assert.Equal(t, schemas[filepath.Join(".")][1].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][1].SchemaName, "SchemaWithSameName") - assert.Equal(t, schemas[filepath.Join(".")][2].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][2].SchemaName, "SchemaInMainK") - assert.Equal(t, schemas[filepath.Join(".")][3].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][3].SchemaName, "SchemaInSubK") - assert.Equal(t, schemas[filepath.Join(".")][4].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][4].SchemaName, "SchemaWithSameName") - assert.Equal(t, schemas[filepath.Join(".")][5].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][5].SchemaName, "SchemaWithSameName") + assert.Equal(t, len(schemas), 0) - // All schema types under the root_path/sub path - assert.Equal(t, schemas[filepath.Join("sub")][0].Type, "schema") - assert.Equal(t, schemas[filepath.Join("sub")][0].SchemaName, "SchemaInSubK") - - // All schema types under the root_path/sub/sub1 path - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][0].Type, "schema") - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][0].SchemaName, "SchemaInSubSub1K") - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][1].Type, "schema") - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][1].SchemaName, "SchemaWithSameName") -} - -func TestGetAllSchemaTypesNamed(t *testing.T) { - pkg_path := filepath.Join(getTestDir("test_kpm_package"), "kcl_pkg") - kcl_pkg_path, err := GetKclPkgPath() - - assert.Equal(t, err, nil) - pkg, err := GetKclPackage(pkg_path) - assert.Equal(t, err, nil) - err = pkg.pkg.ResolveDepsMetadata(kcl_pkg_path, true) + filterFunc = func(kt *KclType) bool { + return kt.SchemaName == "SchemaWithSameName" + } + schemas, err = pkg.GetSchemaTypeMappingWithFilters([]KclTypeFilterFunc{filterFunc}) assert.Equal(t, err, nil) + assert.Equal(t, len(schemas), 2) + assert.Equal(t, len(schemas[filepath.Join(".")]), 3) + assert.Equal(t, len(schemas[filepath.Join("sub", "sub1")]), 1) + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].Type, "schema") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name"].Type, "schema") + assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name"].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name_in_sub"].Type, "schema") + assert.Equal(t, schemas[filepath.Join(".")]["schema_with_same_name_in_sub"].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].Type, "schema") + assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") - schemas, err := pkg.GetSchemaTypeNamed("SchemaWithSameName") + filterFunc = func(kt *KclType) bool { + return kt.SchemaName == "SchemaWithSameName" && kt.Name == "SchemaWithSameName" + } + schemas, err = pkg.GetSchemaTypeMappingWithFilters([]KclTypeFilterFunc{filterFunc}) assert.Equal(t, err, nil) - assert.Equal(t, len(schemas), 3) - assert.Equal(t, len(schemas["."]), 1) - assert.Equal(t, len(schemas[filepath.Join("sub")]), 0) + assert.Equal(t, len(schemas), 2) + assert.Equal(t, len(schemas[filepath.Join(".")]), 1) assert.Equal(t, len(schemas[filepath.Join("sub", "sub1")]), 1) - - // // All schema types under the root path - assert.Equal(t, schemas[filepath.Join(".")][0].Type, "schema") - assert.Equal(t, schemas[filepath.Join(".")][0].SchemaName, "SchemaWithSameName") - - // // All schema types under the root_path/sub/sub1 path - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][0].Type, "schema") - assert.Equal(t, schemas[filepath.Join("sub", "sub1")][0].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].Type, "schema") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].Name, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].RelPath, ".") + assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].Type, "schema") + assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].SchemaName, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join(".")]["SchemaWithSameName"].Name, "SchemaWithSameName") + assert.Equal(t, schemas[filepath.Join("sub", "sub1")]["SchemaWithSameName"].RelPath, filepath.Join("sub", "sub1")) }