utilities.go

// Copyright 2016-2020, 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 nodejs

import (
	"encoding/json"
	"fmt"
	"io"
	"regexp"
	"strings"
	"unicode"

	"github.com/pulumi/pulumi/sdk/v3/go/common/util/contract"

	"github.com/pulumi/pulumi/pkg/v3/codegen"
	"github.com/pulumi/pulumi/pkg/v3/codegen/schema"
)

// isReservedWord returns true if s is a reserved word as per ECMA-262.
func isReservedWord(s string) bool {
	switch s {
	case "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
		"do", "else", "export", "extends", "finally", "for", "function", "if", "import",
		"in", "instanceof", "new", "return", "super", "switch", "this", "throw", "try",
		"typeof", "var", "void", "while", "with", "yield":
		// Keywords
		return true

	case "enum", "await", "implements", "interface", "package", "private", "protected", "public":
		// Future reserved words
		return true

	case "null", "true", "false":
		// Null and boolean literals
		return true

	default:
		return false
	}
}

// isLegalIdentifierStart returns true if it is legal for c to be the first character of a JavaScript identifier as per
// ECMA-262.
func isLegalIdentifierStart(c rune) bool {
	return c == '$' || c == '_' ||
		unicode.In(c, unicode.Lu, unicode.Ll, unicode.Lt, unicode.Lm, unicode.Lo, unicode.Nl)
}

// isLegalIdentifierPart returns true if it is legal for c to be part of a JavaScript identifier (besides the first
// character) as per ECMA-262.
func isLegalIdentifierPart(c rune) bool {
	return isLegalIdentifierStart(c) || unicode.In(c, unicode.Mn, unicode.Mc, unicode.Nd, unicode.Pc)
}

// isLegalIdentifier returns true if s is a legal JavaScript identifier as per ECMA-262.
func isLegalIdentifier(s string) bool {
	if isReservedWord(s) {
		return false
	}

	reader := strings.NewReader(s)
	c, _, _ := reader.ReadRune()
	if !isLegalIdentifierStart(c) {
		return false
	}
	for {
		c, _, err := reader.ReadRune()
		if err != nil {
			return err == io.EOF
		}
		if !isLegalIdentifierPart(c) {
			return false
		}
	}
}

// makeValidIdentifier replaces characters that are not allowed in JavaScript identifiers with underscores. No attempt
// is made to ensure that the result is unique.
func makeValidIdentifier(name string) string {
	var builder strings.Builder
	for i, c := range name {
		if !isLegalIdentifierPart(c) {
			builder.WriteRune('_')
		} else {
			if i == 0 && !isLegalIdentifierStart(c) {
				builder.WriteRune('_')
			}
			builder.WriteRune(c)
		}
	}
	name = builder.String()
	if isReservedWord(name) {
		return "_" + name
	}
	return name
}

func makeSafeEnumName(name, typeName string) (string, error) {
	// Replace common single character enum names.
	safeName := codegen.ExpandShortEnumName(name)

	// If the name is one illegal character, return an error.
	if len(safeName) == 1 && !isLegalIdentifierStart(rune(safeName[0])) {
		return "", fmt.Errorf("enum name %s is not a valid identifier", safeName)
	}

	// Capitalize and make a valid identifier.
	safeName = makeValidIdentifier(title(safeName))

	// If there are multiple underscores in a row, replace with one.
	regex := regexp.MustCompile(`_+`)
	safeName = regex.ReplaceAllString(safeName, "_")

	// If the enum name starts with an underscore, add the type name as a prefix.
	if strings.HasPrefix(safeName, "_") {
		safeName = typeName + safeName
	}

	return safeName, nil
}

// escape returns the string escaped for a JS string literal
func escape(s string) string {
	// Seems the most fool-proof way of doing this is by using the JSON marshaler and then stripping the surrounding quotes
	escaped, err := json.Marshal(s)
	contract.AssertNoErrorf(err, "JSON(%q)", s)
	contract.Assertf(len(escaped) >= 2, "JSON(%s) expected a quoted string but returned %s", s, escaped)
	contract.Assertf(
		escaped[0] == byte('"') && escaped[len(escaped)-1] == byte('"'),
		"JSON(%s) expected a quoted string but returned %s", s, escaped)

	return string(escaped)[1:(len(escaped) - 1)]
}

func lookupNodePackageInfo(pkg *schema.Package) NodePackageInfo {
	nodePackageInfo := NodePackageInfo{}
	if pkg == nil {
		return nodePackageInfo
	}
	if languageInfo, ok := pkg.Language["nodejs"]; ok {
		if info, ok2 := languageInfo.(NodePackageInfo); ok2 {
			nodePackageInfo = info
		}
	}
	return nodePackageInfo
}

func nonEmptyStrings(candidates []string) []string {
	res := []string{}
	for _, c := range candidates {
		if c != "" {
			res = append(res, c)
		}
	}
	return res
}