mirror of https://github.com/pulumi/pulumi.git
146 lines
4.4 KiB
Go
146 lines
4.4 KiB
Go
// Copyright 2016-2018, Pulumi Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package tokens
|
|
|
|
import (
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/util/contract"
|
|
)
|
|
|
|
// Name is an identifier. It conforms to NameRegexpPattern.
|
|
type Name string
|
|
|
|
func (nm Name) String() string { return string(nm) }
|
|
|
|
// Q turns a Name into a qualified name; this is legal, since Name's is a proper subset of QName's grammar.
|
|
func (nm Name) Q() QName { return QName(nm) }
|
|
|
|
var (
|
|
NameRegexp = regexp.MustCompile(NameRegexpPattern)
|
|
nameFirstCharRegexp = regexp.MustCompile("^" + nameFirstCharRegexpPattern + "$")
|
|
nameRestCharRegexp = regexp.MustCompile("^" + nameRestCharRegexpPattern + "$")
|
|
)
|
|
|
|
var NameRegexpPattern = nameFirstCharRegexpPattern + nameRestCharRegexpPattern
|
|
|
|
const (
|
|
nameFirstCharRegexpPattern = "[A-Za-z0-9_.-]"
|
|
nameRestCharRegexpPattern = "[A-Za-z0-9_.-]*"
|
|
)
|
|
|
|
// IsName checks whether a string is a legal Name.
|
|
func IsName(s string) bool {
|
|
return s != "" && NameRegexp.FindString(s) == s
|
|
}
|
|
|
|
// QName is a qualified identifier. The "/" character optionally delimits different pieces of the name. Each element
|
|
// conforms to NameRegexpPattern. For example, "pulumi/pulumi/stack".
|
|
type QName string
|
|
|
|
func (nm QName) String() string { return string(nm) }
|
|
|
|
// QNameDelimiter is what delimits Namespace and Name parts.
|
|
const QNameDelimiter = "/"
|
|
|
|
var (
|
|
QNameRegexp = regexp.MustCompile(QNameRegexpPattern)
|
|
QNameRegexpPattern = "(" + NameRegexpPattern + "\\" + QNameDelimiter + ")*" + NameRegexpPattern
|
|
)
|
|
|
|
// IsQName checks whether a string is a legal QName.
|
|
func IsQName(s string) bool {
|
|
return s != "" && QNameRegexp.FindString(s) == s
|
|
}
|
|
|
|
// IntoQName converts an arbitrary string into a QName, converting the string to a valid QName if
|
|
// necessary. The conversion is deterministic, but also lossy.
|
|
func IntoQName(s string) QName {
|
|
output := []string{}
|
|
for _, s := range strings.Split(s, QNameDelimiter) {
|
|
if s == "" {
|
|
continue
|
|
}
|
|
segment := []byte(s)
|
|
if !nameFirstCharRegexp.Match([]byte{segment[0]}) {
|
|
segment[0] = '_'
|
|
}
|
|
for i := 1; i < len(s); i++ {
|
|
if !nameRestCharRegexp.Match([]byte{segment[i]}) {
|
|
segment[i] = '_'
|
|
}
|
|
}
|
|
output = append(output, string(segment))
|
|
}
|
|
result := strings.Join(output, QNameDelimiter)
|
|
if result == "" {
|
|
result = "_"
|
|
}
|
|
return QName(result)
|
|
}
|
|
|
|
// Name extracts the Name portion of a QName (dropping any namespace).
|
|
func (nm QName) Name() Name {
|
|
ix := strings.LastIndex(string(nm), QNameDelimiter)
|
|
var nmn string
|
|
if ix == -1 {
|
|
nmn = string(nm)
|
|
} else {
|
|
nmn = string(nm[ix+1:])
|
|
}
|
|
contract.Assertf(IsName(nmn), "QName %q has invalid name %q", nm, nmn)
|
|
return Name(nmn)
|
|
}
|
|
|
|
// Namespace extracts the namespace portion of a QName (dropping the name); this may be empty.
|
|
func (nm QName) Namespace() QName {
|
|
ix := strings.LastIndex(string(nm), QNameDelimiter)
|
|
var qn string
|
|
if ix == -1 {
|
|
qn = ""
|
|
} else {
|
|
qn = string(nm[:ix])
|
|
}
|
|
contract.Assertf(IsQName(qn), "QName %q has invalid namespace %q", nm, qn)
|
|
return QName(qn)
|
|
}
|
|
|
|
// PackageName is a qualified name referring to an imported package.
|
|
type PackageName QName
|
|
|
|
func (nm PackageName) String() string { return string(nm) }
|
|
|
|
// ModuleName is a qualified name referring to an imported module from a package.
|
|
type ModuleName QName
|
|
|
|
func (nm ModuleName) String() string { return string(nm) }
|
|
|
|
// ModuleMemberName is a simple name representing the module member's identifier.
|
|
type ModuleMemberName Name
|
|
|
|
func (nm ModuleMemberName) String() string { return string(nm) }
|
|
|
|
// ClassMemberName is a simple name representing the class member's identifier.
|
|
type ClassMemberName Name
|
|
|
|
func (nm ClassMemberName) Name() Name { return Name(nm) }
|
|
func (nm ClassMemberName) String() string { return string(nm) }
|
|
|
|
// TypeName is a simple name representing the type's name, without any package/module qualifiers.
|
|
type TypeName Name
|
|
|
|
func (nm TypeName) String() string { return string(nm) }
|