text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>(s statement) QueryRowsPartialCtx(_ context.Context, v any, args ...any) error {
return s.QueryRowsPartial(v, args...)
}
<|fim_prefix|>// copy from core/stores/sqlx/sqlconn.go
package mocksql
import (
"context"
"database/sql"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
type (
// MockConn de... | fim | zeromicro/go-zero | go |
<|fim_suffix|>rr)
return err
}
defer rows.Close()
return scanner(rows)
}
<|fim_prefix|>// copy from core/stores/sqlx/stmt.go
package mocksql
import (
"database/sql"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/timex"
)
const slowThreshold = time.Millisecond * 5... | fim | zeromicro/go-zero | go |
<|fim_suffix|> b.WriteString(mapping.Repr(v))
}
} else {
b.WriteRune(ch)
}
}
if argIndex < numArgs {
return "", fmt.Errorf("%d ? in sql, but more arguments provided", argIndex)
}
return b.String(), nil
}
func logSqlError(stmt string, err error) {
if err != nil && err != ErrNotFound {
logx.Errorf(... | fim | zeromicro/go-zero | go |
package util
import (
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestMatchFiles(t *testing.T) {
dir, err := filepath.Abs("./")
assert.Nil(t, err)
files, err := MatchFiles("./*.sql")
assert.Nil(t, err)
assert.Equal(t, []string{filepath.Join(dir, "studeat.sql"), filepath.Join(dir, "... | fim | zeromicro/go-zero | go |
<|fim_suffix|>urns the match values by globbing patterns
func MatchFiles(in string) ([]string, error) {
dir, pattern := filepath.Split(in)
abs, err := filepath.Abs(dir)
if err != nil {
return nil, err
}
files, err := os.ReadDir(abs)
if err != nil {
return nil, err
}
var res []string
for _, file := range f... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package util
import "st<|fim_suffix|>tring {
return strings.NewReplacer("\r", "", "\n", "").Replace(s)
}
<|fim_middle|>rings"
// TrimNewLine trims \r and \n chars.
func TrimNewLine(s string) s<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|> out = append(out, item)
}
return out
}
<|fim_prefix|>package util
// TrimStringSlice returns a copy slice without empty string item
func TrimStringSlice(list [<|fim_middle|>]string) []string {
var out []string
for _, item := range list {
if len(item) == 0 {
continue
}
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>iterator func(key, value any)) {
next := m.kv.Front()
for next != nil {
value := next.Value.(KV)
iterator(value[0], value[1])
next = next.Next()
}
}
func (m *SortedMap) RangeIf(iterator func(key, value any) bool) {
next := m.kv.Front()
for next != nil {
value := next.Value.(KV)
loop := ite... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sortedmap
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_SortedMap(t *testing.T) {
sm := New()
t.Run("SetExpression", func(t *testing.T) {
_, _, err := sm.SetExpression("")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("foo")
assert... | fim | zeromicro/go-zero | go |
<|fim_suffix|> io.Copy(f, resp.Body)
return err
}
<|fim_prefix|>package downloader
import (
"io"
"net/http"
"os"
)
func Download(url, filename string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.<|fim_middle|>Body.Close()
f, err := os.Create(filename)
if err != nil {
retu... | fim | zeromicro/go-zero | go |
<|fim_suffix|>(GoctlExperimental) {
goctlEnv.SetKV(GoctlExperimental, ExperimentalOn)
}
goctlEnv.SetKV(GoctlVersion, version.BuildVersion)
protocVer, _ := protoc.Version()
goctlEnv.SetKV(ProtocVersion, protocVer)
protocGenGoVer, _ := protocgengo.Version()
goctlEnv.SetKV(ProtocGenGoVersion, protocGenGoVer)
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package goctl
import (
"path/filepath"
"runtime"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
func Install(cacheDir, name string... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package golang
import (
"go/build"
"os"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
// GoBin returns a path of GOBIN.
func GoBin() string {
def := build.Default
goroot := os.Getenv("GOPATH")
bin := <|fim_suffix|>Join(goroot, "bin")
if !pathx.FileExists(bin) {
gopat... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ce([]byte(code))
if err != nil {
return code
}
return string(ret)
}
<|fim_prefix|>package golang
import goformat "go/format"
func F<|fim_middle|>ormatCode(code string) string {
ret, err := goformat.Sour<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package golang
import (
"os"
"os/exec"
)
func<|fim_suffix|> cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
return err
}
<|fim_middle|> Install(git string) error {
cmd := exec.Command("go", "install", git)
env := os.Environ()
env = append(env, "GO111MODULE=on")
cmd.Env = env
<|en... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tring, error) {
wd := projectCtx.WorkDir
d := projectCtx.Dir
same, err := pathx.SameFile(wd, d)
if err != nil {
return "", "", err
}
trim := strings.TrimPrefix(projectCtx.WorkDir, projectCtx.Dir)
if same {
trim = strings.TrimPrefix(strings.ToLower(projectCtx.WorkDir), strings.ToLower(projectCt... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package golang
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestGetParentPackage(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
def... | fim | zeromicro/go-zero | go |
<|fim_suffix|>..error) {
if len(err) == 0 {
t.Fatalf("expected errors, got 0 error")
return
}
for _, e := range err {
fmt.Printf("<%s>: %v\n", source, e)
assert.Error(t, e)
}
}
// Error is used to assert error.
func Error(t *testing.T, err ...error) {
if len(err) == 0 {
t.Fatalf("expected errors, got 0 ... | fim | zeromicro/go-zero | go |
package ast
import (
"fmt"
"io"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
// Node represents a node in the AST.
type Node interface {
// Pos returns the position of the first character belonging to the node.
Pos() token.Position... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"strings"
"github.c<|fim_suffix|>mment.Text
if util.IsEmptyStringOrWhiteSpace(comment) {
continue
}
list = append(list, comment)
}
return list
}
// String joins and returns the comment text.
func (cg CommentGroup) String() string {
return cg.Join(" ")
}
// Join joins... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// ImportStmt represents an import statement.
type ImportStmt interface {
Stmt
importNode()
}
// ImportLiteralStmt represents an import literal statement.
type ImportLiteralStmt struct {
// Import is the import token.... | fim | zeromicro/go-zero | go |
package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// InfoStmt is the info statement.
type InfoStmt struct {
// Info is the info keyword.
Info *TokenNode
// LParen is the left parenthesis.
LParen *TokenNode
// Values is the info values.
Values []*KVExpr
// RParen is the right pa... | fim | zeromicro/go-zero | go |
<|fim_suffix|>oken.Position {
return i.Key.Pos()
}
func (i *KVExpr) exprNode() {}
<|fim_prefix|>package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// KVExpr is a key value expression.
type KVExpr struct {
// Key is the key of the key value expression.
Key *TokenNode
// Colon is th... | fim | zeromicro/go-zero | go |
<|fim_suffix|> x.Interface()
switch v := v.(type) {
case string:
// print strings in quotes
p.printf("%q", v)
return
}
// default
p.printf("%v", v)
}
}
<|fim_prefix|>package ast
import (
"fmt"
"go/token"
"io"
"os"
"reflect"
apitoken "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/to... | fim | zeromicro/go-zero | go |
<|fim_suffix|>okenNode
}
func (a *AtHandlerStmt) HasHeadCommentGroup() bool {
return a.AtHandler.HasHeadCommentGroup()
}
func (a *AtHandlerStmt) HasLeadingCommentGroup() bool {
return a.Name.HasLeadingCommentGroup()
}
func (a *AtHandlerStmt) CommentGroup() (head, leading CommentGroup) {
return a.AtHandler.HeadCom... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// SyntaxStmt represents a syntax statement.
type SyntaxStmt struct {
// Syntax is the syntax token.
Syntax *TokenNode
// Assign is the assign token.
Assign *TokenNode
// Value is the syntax value.
Value *TokenNode
... | fim | zeromicro/go-zero | go |
package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
/*******************TypeStmt Begin********************/
// TypeStmt is the interface for type statement.
type TypeStmt interface {
Stmt
typeNode()
}
// TypeLiteralStmt is the type statement for type literal.
type TypeLiteralStmt st... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"bytes"
"fmt"
"io"
"strings"
"text/tabwriter"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
const (
NilIndent = ""
WhiteSpace = " "
Indent = "\t"
NewLine = "\n"
)
const (
_ WriteMode = 1 << iot... | fim | zeromicro/go-zero | go |
<|fim_suffix|>rror {
p := parser.New("", source)
result := p.Parse()
if err := p.CheckErrors(); err != nil {
return err
}
result.FormatForUnitTest(w)
return nil
}
<|fim_prefix|>package format
import (
"bytes"
"io"
"os"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/parser"
)
// File formats th... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package format
import (
"bytes"
_ "embed"
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/parser"
)
type formatData struct {
input string
expected stri... | fim | zeromicro/go-zero | go |
package importstack
import "errors"
// ErrImportCycleNotAllowed defines an error for circular importing
var ErrImportCycleNotAllowed = errors.New("import cycle not allowed")
// ImportStack a stack of import paths
type ImportStack []string
func New() *ImportStack {
return &ImportStack{}
}
func (s *ImportStack) Pus... | fim | zeromicro/go-zero | go |
<|fim_suffix|>e.Request.Pos(), "missing response type")
} else {
return ast.SyntaxError(astRoute.Route.Path.Pos(), "missing response type")
}
}
if err := a.fillRouteType(&route); err != nil {
return err
}
group.Routes = append(group.Routes, route)
name := item.Name.Format("")
if le... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
"bytes"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
)
func Test_Parse(t *testing.T) {
t.Run(
"valid", func(t ... | fim | zeromicro/go-zero | go |
package parser
import (
"fmt"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/importstack"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/placeholder"
"github.com... | fim | zeromicro/go-zero | go |
package parser
import (
"errors"
"strings"
)
type errorManager struct {
errors []string
}
func newErrorManager() *errorManager {
return &errorManager{}
}
func (e *errorManager) add(err error) {
if err == nil {
return
}
e.errors = append(e.errors, err.Error())
}
func (e *errorManager) error() error {
if l... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ken.Position
checkExprName string
errorManager *errorManager
}
func (b *filterBuilder) check(nodes ...*ast.TokenNode) {
for _, node := range nodes {
fileNodeText := fmt.Sprintf("%s/%s", b.filename, node.Token.Text)
if pos, ok := b.m[fileNodeText]; ok && pos != node.Token.Position {
b.errorMana... | fim | zeromicro/go-zero | go |
<|fim_suffix|>token.RPAREN, token.IDENT) {
return nil
}
}
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseAtServerKVExpression() *ast.KVExpr {
var expr = &ast.KVExpr{}
// token IDENT
if !p.advanceIfPeekTokenIs(t... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
_ "embed"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
//go:embed ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>pack<|fim_suffix|>/ PlaceHolder is the placeholder.
var PlaceHolder Type
<|fim_middle|>age placeholder
// Type is the placeholder type.
type Type struct{}
/<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package scanner
import (
"bytes"
"errors"
"fmt"
"log"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
initMode mode = iota
// document mode bg
documentHalfOpen
documentOpen
docu... | fim | zeromicro/go-zero | go |
<|fim_suffix|>t: `:`,
Position: position(5, 9),
},
{
Type: token.STRING,
Text: `"type desc here"`,
Position: position(5, 11),
},
{
Type: token.IDENT,
Text: `author`,
Position: position(6, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(6, 1... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package token
import "fmt"
// IllegalPosition is a position<|fim_suffix|>lumn)
}
return fmt.Sprint(p.Filename, " ", p.Line, ":", p.Column)
}
<|fim_middle|> that is not valid.
var IllegalPosition = Position{}
// Position represents a rune position in the source code.
type Position struct {
Filename s... | fim | zeromicro/go-zero | go |
<|fim_suffix|>Holder,
"byte": placeholder.PlaceHolder,
"rune": placeholder.PlaceHolder,
"any": placeholder.PlaceHolder,
}
// LookupKeyword returns the keyword type if the given ident is keyword.
func LookupKeyword(ident string) (Type, bool) {
tp, ok := keywords[ident]
return tp, ok
}
// NewIll... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package protoc
import (
"archive/zip"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/downloader"
"github.com/zeromicro/go-zero/tools/goctl/pkg/goctl"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/uti... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package protocgengo
import (
"strings"
"time"
"gith<|fim_suffix|>ent the older version process from blocking.
func Version() (string, error) {
path, err := env.LookUpProtocGenGo()
if err != nil {
return "", err
}
versionC := make(chan string)
go func(c chan string) {
version, _ := execx.Run(... | fim | zeromicro/go-zero | go |
package protocgengogrpc
import (
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/goctl"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
)
const (
Name = "protoc-gen-go-grpc"
url = "google.go... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package main
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/plugin"
)
func main() {
plugin, err := plugin.NewPlugin()
if err != nil {
panic(err)
}
if plugin.Api != nil {
fmt.Pri<|fim_suffix|>+v \n", plugin.Api)
}
fmt.Println("Enjoy anything you want.")
}
<|fim_middle|>ntf("api: %... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package plugin
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/api/parser"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goc... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package plugin
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestGetPluginAndArgs(t *testing.T) {
bin, args := getPluginAndArgs("android")
assert.Equal(t, "android", bin)
assert.Equal(t, "", args)
bin, args = getPluginAndArgs("android=")
assert.Equal(t, <|fim_suffix|>cn-east-2.... | fim | zeromicro/go-zero | go |
<|fim_suffix|> Cmd = cobrax.NewCommand("quickstart", cobrax.WithRunE(run))
)
func init() {
Cmd.Flags().StringVarPWithDefaultValue(&varStringServiceType, "service-type", "t", "mono")
}
<|fim_prefix|>package quickstart
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
const (
serviceTypeMono = "mono... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package quickstart
import (
_ "embed"
"os"
"path/filepath"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/service"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const protoName = "greet.proto"
var (
//go:embed idl/greet.proto
protocContent string
//go:em... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package quickstart
import (
_ "embed"
"os"
"path/filepath"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/tools/goctl/api/gogen"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package quickstart
import (
"fmt"
"os"
"path/filepath"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/ctx"
"github.com/zeromicro/g<|fim_suffix|>projectDir)
for {
fmt.Scan... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package quickstart
import (
"os"
"os/exec"
"runtime"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
func goStart(dir string) {
execCommand(dir, "go run .")
}
func goModTidy(dir string) int {
log.Debug(">> go mod tidy")
return execCommand(dir, "go mod tidy"<|fim_suffix|>exec.Command("cmd.exe"... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package cli
import (
"errors"
"fmt"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/rpc/generator"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package cli
import (
"errors"
"os"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/rpc/generator"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
errInvalidGrpcOutput = errors.New("ZRPC: ... | fim | zeromicro/go-zero | go |
package rpc
import (
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
"github.com/zeromicro/go-zero/tools/goctl/rpc/cli"
)
var (
// Cmd describes a rpc command.
Cmd = cobrax.NewCommand("rpc", cobrax.WithRunE(func(command *cobra... | fim | zeromicro/go-zero | go |
<|fim_suffix|>f len(dir) > 0 {
cmd.Dir = dir
}
stdout := new(bytes.Buffer)
stderr := new(bytes.Buffer)
if len(in) > 0 {
cmd.Stdin = in[0]
}
cmd.Stdout = stdout
cmd.Stderr = stderr
err := cmd.Run()
if err != nil {
if stderr.Len() > 0 {
return "", errors.New(strings.TrimSuffix(stderr.String(), pathx.NL)... | fim | zeromicro/go-zero | go |
package generator
import (
"os"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/ctx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
type ZRpcContext struct {
// Src is the sour... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRpcGenerateWithModule(t *testing.T) {
tests := []struct {
name string
moduleName string
expectedMod string
serviceName string
... | fim | zeromicro/go-zero | go |
<|fim_suffix|> assert.Error(t, err)
})
// case go mod
t.Run("GOMOD", func(t *testing.T) {
workDir := projectDir
name := filepath.Base(projectDir)
_, err = execx.Run("go mod init "+name, workDir)
if err != nil {
logx.Error(err)
return
}
projectDir = filepath.Join(workDir, projectName)
ctx := &ZR... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
_ "embed"
"fmt"
"path/filepath"
"sort"
"strings"
"github.com/emicklei/proto"
"github.com/zeromicro/go-zero/core/collection"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tool... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/emicklei/proto"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/ze... | fim | zeromicro/go-zero | go |
<|fim_suffix|>LoadTemplate(category, configTemplateFileFile, configTemplate)
if err != nil {
return err
}
return os.WriteFile(fileName, []byte(text), os.ModePerm)
}
<|fim_prefix|>package generator
import (
_ "embed"
"os"
"path/filepath"
conf "github.com<|fim_middle|>/zeromicro/go-zero/tools/goctl/config"
"... | fim | zeromicro/go-zero | go |
package generator
import (
"log"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/env"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
)
// Generator defines the environment needs of rpc service generation
type Generator struct {
log console.Console
c... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
_ "embed"
"fmt"
"path/filepath"
"strings"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/ze... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
_ "embed"
"fmt"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/core/collection"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromic<|fim_suffix|> cfg *conf.Config) error {
dir := ctx.GetLogic()
pkgMap := parser.BuildProtoPackageMap(prot... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
_ "embed"
"fmt"
"path/filepath"
"strings"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/ze... | fim | zeromicro/go-zero | go |
<|fim_suffix|>= len(pp)
}
}
}
if bestRel != "" {
return bestRel
}
if rel, err := filepath.Rel(pwd, f); err == nil {
return rel
}
return f
}
func (g *Generator) setPbDir(ctx DirContext, c *ZRpcContext) error {
pbDir, err := findPbFile(c.GoOutput, c.Src, false)
if err != nil {
return err
}
if len(pb... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func Test_findPbFile(t *testing.T) {
dir := t.TempDir()
protoFile := filepath.Join(dir, "greet.proto")
err := os.WriteFile(protoFile,... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
_ "embed"
"fmt"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/core/collection"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/... | fim | zeromicro/go-zero | go |
<|fim_suffix|>erator) GenSvc(ctx DirContext, _ parser.Proto, cfg *conf.Config) error {
dir := ctx.GetSvc()
svcFilename, err := format.FileNamingFormat(cfg.NamingFormat, "service_context")
if err != nil {
return err
}
fileName := filepath.Join(dir.Filename, svcFilename+".go")
text, err := pathx.LoadTemplate(cat... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"path/filepath"
"strings"
conf "github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/ctx"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/zeromicro/go-zer... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"testing"
"github.com/emicklei/proto"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
)
func TestServiceNameDetermination(t *testing.T) {
tests := []struct {
name string
protoName string
packageName ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ilepath.Dir(out)
err = pathx.MkdirIfNotExist(dir)
if err != nil {
return err
}
err = util.With("t").Parse(text).SaveTo(map[string]string{
"package": serviceName.Untitle(),
"serviceName": serviceName.Title(),
}, out, false)
return err
}
<|fim_prefix|>package generator
import (
_ "embed"
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>r
import (
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestProtoTmpl(t *testing.T) {
_ = Clean()
// exists dir
err := ProtoTmpl(pathx.MustTempDir())
assert.Nil(t, err)
// not exist dir
dir := filepath.Join(pathx.... | fim | zeromicro/go-zero | go |
<|fim_suffix|>eFile = "template.tpl"
)
var templates = map[string]string{
callTemplateFile: callTemplateText,
configTemplateFileFile: configTemplate,
etcTemplateFileFile: etcTemplate,
logicTemplateFileFile: logicTemplate,
logicFuncTemplateFileFile: logicFunctionTemplate,
m... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package generator
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/test<|fim_suffix|>
data, err := os.ReadFile(mainTpl)
if err != nil {
return
}
assert.Equal(t, templates[mainTemplateFile], string(data))
err = RevertTemplate("test")
if err != nil {
assert.Equal(t, "test: no su... | fim | zeromicro/go-zero | go |
package generator
import (
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/rpc/parser"
)
// rpcTypeRef holds the resolved Go type reference for an RPC request/response type.
type rpcTypeRef struct {
// GoRef is the qualified Go type name, e.g. "pb.GetReq", "common.TypesReq", "emptypb.Empty".
GoRef str... | fim | zeromicro/go-zero | go |
<|fim_suffix|>comment *proto.Comment) string {
if comment == nil {
return ""
}
return "// " + strings.TrimSpace(comment.Message())
}
<|fim_prefix|>package parser
import (
"strings"
"github.com/emicklei/proto"
)
// GetComment returns content with prefi<|fim_middle|>x //
func GetComment(<|endoftext|> | fim | zeromicro/go-zero | go |
package parser
import (
"fmt"
"os"
"path/filepath"
"strings"
"github.com/emicklei/proto"
)
// Import embeds proto.Import
type Import struct {
*proto.Import
}
// ImportedProto holds the package information of a transitively imported proto file.
type ImportedProto struct {
// Src is the absolute path to the pr... | fim | zeromicro/go-zero | go |
<|fim_suffix|>has no imports, so the result should be empty.
absDir, err := filepath.Abs(".")
assert.NoError(t, err)
protos, err := ParseImportedProtos("./test_option.proto", []string{absDir})
assert.NoError(t, err)
assert.Empty(t, protos)
}
func TestIsWellKnownProto(t *testing.T) {
assert.True(t, isWellKnownPr... | fim | zeromicro/go-zero | go |
<|fim_suffix|>"
// Message embeds proto.Message
type Message struct {
*proto.Message
}
<|fim_prefix|>package parser
import "githu<|fim_middle|>b.com/emicklei/proto<|endoftext|> | fim | zeromicro/go-zero | go |
package parser
import "github.com/emicklei/proto"
// Option embeds proto.Option
type Option struct {
*proto.Option
}
<|endoftext|> | fim | zeromicro/go-zero | go |
package parser
import "github.com/emicklei/proto"
// Package defines the protobuf package.
type Package struct {
*proto.Package
}
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
"errors"
"go/token"
"os"
"path/filepath"
"strings"
"unicode"
"unicode/utf8"
"github.com/emicklei/proto"
)
type (
// DefaultProtoParser types an empty struct
DefaultProtoParser struct{}
)
var ErrGoPackage = errors.New(`option go_package = "" field is not filled in`)
/... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
"sort"
"testing"
"github.com/stretchr/testify/assert"
)
func TestDefaultProtoParse(t *testing.T) {
p := NewDefaultProtoParser()
data, err := p.Parse("./test.proto")
assert.Nil(t, err)
assert.Equal(t, "base.proto", func() string {
ip := data.Import[0]
return ip.Filenam... | fim | zeromicro/go-zero | go |
package parser
// Proto describes a proto file,
type Proto struct {
Src string
Name string
Package Package
PbPackage string
GoPackage string
Import []Import
Message []Message
Service Services
// ImportedProtos holds the metadata for all transitively imported... | fim | zeromicro/go-zero | go |
<|fim_suffix|>
type RPC struct {
*proto.RPC
}
<|fim_prefix|>package parser
import "g<|fim_middle|>ithub.com/emicklei/proto"
// RPC embeds proto.RPC<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
"errors"
"github.com/emicklei/proto"
)
type (
// Services is a slice of Service.
Services []Service
// Serv<|fim_suffix|>t {
*proto.Service
RPC []*RPC
}
)
func (s Services) validate(filename string, multipleOpt ...bool) error {
if len(s) == 0 {
return errors.New("... | fim | zeromicro/go-zero | go |
<|fim_suffix|>nd(e.list, data...)
}
func (e *Executor[T, Y]) Run(t *testing.T, do func(T) Y) {
if do == nil {
panic("execution body is nil")
return
}
for _, v := range e.list {
t.Run(v.Name, func(t *testing.T) {
inner := do
e.equalFn(t, v.Want, inner(v.Input))
})
}
}
func (e *Executor[T, Y]) RunE(t ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package test
import (
"errors"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func TestExecutor_Run(t *testing.T) {
executor := NewExecutor[string, string]()
executor.Add([]Data[string, string]{
{
Name: "empty",
},
{
Name: "snake_case",
Input: "A_B_C",
Want: "a_b_c... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package tpl
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
var (
varStringHome string
varStringCategory string
varStringName string
// Cmd describes a template command.
Cmd = cobrax.NewCommand("template")
initCmd = cobrax.NewCommand("init", cobrax.WithRunE(genTem... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tlHome(path)
}
defer func() {
if err == nil {
fmt.Println(color.Green.Sprintf("%s template are reverted!", filename))
}
}()
switch category {
case docker.Category():
return docker.RevertTemplate(filename)
case kube.Category():
return kube.RevertTemplate(filename)
case gogen.Category():
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package config
import "github.com/zeromicro/g<|fim_suffix|>onfigure for goctl update
type Config struct {
logx.LogConf
ListenOn string
FileDir string
FilePath string
}
<|fim_middle|>o-zero/core/logx"
// Config defines a service c<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package main
import (
"flag"
"net/http"
"os"
"path"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/core/hash"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/tools/goctl/update/config"
"githu<|fim_suffix|>ile, &c)
fs := http.FileServer(http.Dir(c... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package upgrade
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
// Cmd describes an<|fim_suffix|>.NewCommand("upgrade", cobrax.WithRunE(upgrade))
<|fim_middle|> upgrade command.
var Cmd = cobrax<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>stall github.com/zeromicro/go-zero/tools/goctl@latest
func upgrade(_ *cobra.Command, _ []string) error {
cmd := `go install github.com/zeromicro/go-zero/tools/goctl@latest`
if runtime.GOOS == "windows" {
cmd = `go install github.com/zeromicro/go-zero/tools/goctl@latest`
}
info, err := execx.Run(cmd,... | fim | zeromicro/go-zero | go |
<|fim_suffix|>at string, a ...any) {
fmt.Println(color.LightCyan.Sprintf(format, a...))
}
func (i *ideaConsole) Success(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Println("[SUCCESS]: ", msg)
}
func (i *ideaConsole) Warning(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Print... | fim | zeromicro/go-zero | go |
package ctx
import (
"errors"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
var errModuleCheck = errors.New("the work directory must be found in the go mod or the $GOPATH")
// ProjectContext is a structure for the project,
// which contains WorkDir, Name, Path and Dir
type ProjectContext... | fim | zeromicro/go-zero | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.