github.com/cloudwego/kitex@v0.9.0/tool/internal_pkg/util/util.go

// Copyright 2021 CloudWeGo Authors
//
// 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 util

import (
	"fmt"
	"go/build"
	"go/format"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
	"unicode"

	"github.com/cloudwego/kitex/tool/internal_pkg/log"
)

// StringSlice implements the flag.Value interface on string slices
// to allow a flag to be set multiple times.
type StringSlice []string

func (ss *StringSlice) String() string {
	return fmt.Sprintf("%v", *ss)
}

// Set implements the flag.Value interface.
func (ss *StringSlice) Set(value string) error {
	*ss = append(*ss, value)
	return nil
}

// FormatCode formats go source codes.
func FormatCode(code []byte) ([]byte, error) {
	formatCode, err := format.Source(code)
	if err != nil {
		return code, fmt.Errorf("format code error: %s", err)
	}
	return formatCode, nil
}

// GetGOPATH retrieves the GOPATH from environment variables or the `go env` command.
func GetGOPATH() string {
	goPath := os.Getenv("GOPATH")
	// If there are many path in GOPATH, pick up the first one.
	if GoPaths := strings.Split(goPath, ":"); len(GoPaths) >= 1 && strings.TrimSpace(GoPaths[0]) != "" {
		return strings.TrimSpace(GoPaths[0])
	}
	// GOPATH not set through environment variables, try to get one by executing "go env GOPATH"
	output, err := exec.Command("go", "env", "GOPATH").Output()
	if err != nil {
		log.Warn(err)
		os.Exit(1)
	}

	goPath = strings.TrimSpace(string(output))
	if len(goPath) == 0 {
		buildContext := build.Default
		goPath = buildContext.GOPATH
	}

	if len(goPath) == 0 {
		panic("GOPATH not found")
	}
	return goPath
}

// Exists reports whether a file exists.
func Exists(path string) bool {
	fi, err := os.Stat(path)
	if err != nil {
		return os.IsExist(err)
	}
	return !fi.IsDir()
}

// LowerFirst converts the first letter to upper case for the given string.
func LowerFirst(s string) string {
	rs := []rune(s)
	rs[0] = unicode.ToLower(rs[0])
	return string(rs)
}

// ReplaceString be used in string substitution.
func ReplaceString(s, old, new string, n int) string {
	return strings.Replace(s, old, new, n)
}

// SnakeString converts the string 's' to a snake string
func SnakeString(s string) string {
	data := make([]byte, 0, len(s)*2)
	j := false
	for _, d := range []byte(s) {
		if d >= 'A' && d <= 'Z' {
			if j {
				data = append(data, '_')
				j = false
			}
		} else if d != '_' {
			j = true
		}
		data = append(data, d)
	}
	return strings.ToLower(string(data))
}

// UpperFirst converts the first letter to upper case for the given string.
func UpperFirst(s string) string {
	rs := []rune(s)
	rs[0] = unicode.ToUpper(rs[0])
	return string(rs)
}

// NotPtr converts an pointer type into non-pointer type.
func NotPtr(s string) string {
	return strings.ReplaceAll(s, "*", "")
}

// SearchGoMod searches go.mod from the given directory (which must be an absolute path) to
// the root directory. When the go.mod is found, its module name and path will be returned.
func SearchGoMod(cwd string) (moduleName, path string, found bool) {
	for {
		path = filepath.Join(cwd, "go.mod")
		data, err := ioutil.ReadFile(path)
		if err == nil {
			re := regexp.MustCompile(`^\s*module\s+(\S+)\s*`)
			for _, line := range strings.Split(string(data), "\n") {
				m := re.FindStringSubmatch(line)
				if m != nil {
					return m[1], cwd, true
				}
			}
			return fmt.Sprintf("<module name not found in '%s'>", path), path, true
		}

		if !os.IsNotExist(err) {
			return
		}
		parentCwd := filepath.Dir(cwd)
		if parentCwd == cwd {
			break
		}
		cwd = parentCwd
	}
	return
}

func RunGitCommand(gitLink string) (string, string, error) {
	u, err := user.Current()
	if err != nil {
		return "", "Failed to get home dir", err
	}
	cachePath := JoinPath(u.HomeDir, ".kitex", "cache")

	branch := ""
	if strings.Contains(gitLink, ".git@") {
		strs := strings.Split(gitLink, ".git@")
		branch = strs[1]
		gitLink = strs[0] + ".git"
	}
	pullLink := gitLink

	gitLink = strings.TrimPrefix(gitLink, "git@")

	gitLink = strings.TrimSuffix(gitLink, ".git")

	repoLink := ""
	if strings.Contains(gitLink, "://") {
		repoLink = strings.Split(gitLink, "://")[1]
	} else {
		repoLink = strings.ReplaceAll(gitLink, ":", "/")
	}

	branchSuffix := ""
	if branch != "" {
		branchSuffix = "@" + branch
	}
	gitPath := JoinPath(cachePath, repoLink+branchSuffix)

	_, err = os.Stat(JoinPath(gitPath, ".git"))
	if err != nil && !os.IsExist(err) {
		err = os.MkdirAll(gitPath, os.ModePerm)
		if err != nil {
			return "", "Failed to create cache directory,please check your permission for ~/.kitex/cache", err
		}
		cmdClone := exec.Command("git", "clone", pullLink, ".")
		cmdClone.Dir = gitPath
		out, gitErr := cmdClone.CombinedOutput()
		if gitErr != nil {
			return "", string(out), gitErr
		}
		if branch != "" {
			cmdCheckout := exec.Command("git", "checkout", branch)
			cmdCheckout.Dir = gitPath
			out, gitErr = cmdCheckout.CombinedOutput()
			return gitPath, string(out), gitErr
		} else {
			return gitPath, "", nil
		}
	}

	cmdPull := exec.Command("git", "pull")
	cmdPull.Dir = gitPath
	out, gitErr := cmdPull.CombinedOutput()
	if gitErr != nil {
		return "", string(out), gitErr
	}

	return gitPath, "", nil
}

// CombineOutputPath read the output and path variables and render them into the final path
func CombineOutputPath(outputPath, ns string) string {
	if ns != "" {
		ns = strings.ReplaceAll(ns, ".", "/")
	}
	hasVarNs := strings.Contains(outputPath, "{namespace}")
	hasVarNsUnderscore := strings.Contains(outputPath, "{namespaceUnderscore}")
	if hasVarNs || hasVarNsUnderscore {
		if hasVarNs {
			outputPath = strings.ReplaceAll(outputPath, "{namespace}", ns)
		} else if hasVarNsUnderscore {
			outputPath = strings.ReplaceAll(outputPath, "{namespaceUnderscore}", strings.ReplaceAll(ns, "/", "_"))
		}
	} else {
		outputPath = JoinPath(outputPath, ns)
	}
	return outputPath
}

// JoinPath joins dirs as golang import format, such as xx/xx/xx
func JoinPath(elem ...string) string {
	if runtime.GOOS == "windows" {
		return strings.ReplaceAll(filepath.Join(elem...), "\\", "/")
	}
	return filepath.Join(elem...)
}

// DownloadFile Download file to local
func DownloadFile(remotePath, localPath string) error {
	resp, err := http.Get(remotePath)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("failed to download file, http status: %s", resp.Status)
	}

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(localPath, body, 0o644)
	if err != nil {
		return err
	}
	return nil
}

// IDLName returns the name of the IDL file.
func IDLName(filename string) string {
	return filepath.Base(filename)
}