text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ndlerTestImports(group spec.Group, route spec.Route, parentPkg string) string {
imports := []string{
//fmt.Sprintf("\"%s\"", pathx.JoinPackages(parentPkg, getLogicFolderPath(group, route))),
fmt.Sprintf("\"%s\"", pathx.JoinPackages(parentPkg, contextDir)),
fmt.Sprintf("\"%s\"", pathx.JoinPackages(p... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package gogen
import (
_ "embed"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
)
//go:embed integration_test.tpl
var integratio... | fim | zeromicro/go-zero | go |
<|fim_suffix|> 0 {
resp := responseGoTypeName(route, typesPacket)
responseString = "(resp " + resp + ", err error)"
returnString = "return"
} else {
responseString = "error"
returnString = "return nil"
}
if len(route.RequestTypeName()) > 0 {
requestString = "req *" + requestGoTypeName(route, typesPacket)... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package gogen
import (
_ "embed"
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/zeromicro/go-zero/... | fim | zeromicro/go-zero | go |
<|fim_suffix|>/go-zero/tools/goctl/vars"
)
//go:embed main.tpl
var mainTemplate string
func genMain(dir, rootPkg, projectPkg string, cfg *config.Config, api *spec.ApiSpec) error {
name := strings.ToLower(api.Service.Name)
filename, err := format.FileNamingFormat(cfg.NamingFormat, name)
if err != nil {
return err... | fim | zeromicro/go-zero | go |
<|fim_suffix|>trings.TrimSuffix(strings.ToLower(item), "middleware") + "_middleware"
filename, err := format.FileNamingFormat(cfg.NamingFormat, middlewareFilename)
if err != nil {
return err
}
name := strings.TrimSuffix(item, "Middleware") + "Middleware"
err = genFile(fileGenConfig{
dir: di... | fim | zeromicro/go-zero | go |
<|fim_suffix|> if g.sseEnabled {
sse = "\n rest.WithSSE(),"
}
if len(g.prefix) > 0 {
prefix = fmt.Sprintf(`
rest.WithPrefix("%s"),`, g.prefix)
}
var timeout string
if len(g.timeout) > 0 {
duration, err := time.ParseDuration(g.timeout)
if err != nil {
return err
}
timeout = fmt.Sprintf... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package gogen
import (
"testing"
"time"
"github.com/zeromicro/go-zero/tools/goctl/ap<|fim_suffix|>, "1 * time.Nanosecond"},
{100 * time.Nanosecond, "100 * time.Nanosecond"},
{500 * time.Microsecond, "500 * time.Microsecond"},
{2 * time.Millisecond, "2 * time.Millisecond"},
{time.Second, "1000... | fim | zeromicro/go-zero | go |
package gogen
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func TestSSEGeneration(t *testing.T) {
// Create a temporary directory for test
dir := t.TempDir()
// Create a test API file with SSE annotation
apiContent := `syntax = "v1"
type SseReq {
Message str... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package gogen
import (
_ "embed"
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/ver<|fim_suffix|>i *spec.ApiSpec) error {
filename, err := format.FileNamingFormat(cfg.NamingFo... | fim | zeromicro/go-zero | go |
package gogen
import (
_ "embed"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
)
//go:embed svc_test.tpl
var svcTestTemplate string
func gen... | fim | zeromicro/go-zero | go |
<|fim_suffix|>eturn nil
}
<|fim_prefix|>package gogen
import (
_ "embed"
"fmt"
"io"
"os"
"path"
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
apiutil "github.com/zeromicro/go-zero/tools/goctl/api/util"
"github.com/zeromicro/go-zero/tools... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package g<|fim_suffix|>y
}
// Clean cleans the generated deployment files.
func Clean() error {
return pathx.Clean(category)
}
// GenTemplates generates api template files.
func GenTemplates() error {
return pathx.InitTemplates(category, templates)
}
// RevertTemplate reverts the given template file ... | fim | zeromicro/go-zero | go |
package gogen
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestGenTemplates(t *testing.T) {
err := pathx.InitTemplates(category, templates)
assert.Nil(t, err)
dir, err := pathx.GetTemplateDir(category)
assert.Nil(t,... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package gogen
import (
"bytes"
"fmt"
"io"
"strings"
"text/template"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/api/util"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro... | fim | zeromicro/go-zero | go |
<|fim_suffix|>esPacket
groupProperty = "group"
groupTypeDefault="types"
)
<|fim_prefix|>package gogen
const (
internal = "internal/"
typesPacket = "types"
configDir = internal + "config"
contextDir = internal + "svc"
handlerDir = internal + "handler"
logicDir = inter<|fim_middle|>nal + "... | fim | zeromicro/go-zero | go |
<|fim_suffix|>nPrefix()
packetName := strings.TrimSuffix(api.Service.Name, "-api")
logx.Must(pathx.MkdirIfNotExist(dir))
logx.Must(genPacket(dir, packetName, api))
logx.Must(genComponents(dir, packetName, api))
fmt.Println(color.Green.Render("Done."))
return nil
}
<|fim_prefix|>package javagen
import (
"errors... | fim | zeromicro/go-zero | go |
<|fim_suffix|> superClassName,
"HasProperty": len(strings.TrimSpace(propertiesString)) > 0,
"version": version.BuildVersion,
})
if err != nil {
return err
}
_, err = fp.WriteString(formatSource(buffer.String()))
return err
}
func (c *componentsContext) checkStruct(ty spec.Type) (spec.Def... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package javagen
import (
"bytes"
_ "embed"
"fmt"
"strings"
"text/template"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
apiutil "github.com/zeromicro/go-zero/tools/goctl/api/util"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
//go:embed pa... | fim | zeromicro/go-zero | go |
<|fim_suffix|>rue
case "float64":
return "double", true
case "bool":
return "boolean", true
}
return "", false
}
<|fim_prefix|>package javagen
import (
"errors"
"fmt"
"io"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicr... | fim | zeromicro/go-zero | go |
package javagen
const modelDir = "model"
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>eturn e
}
return nil
}
<|fim_prefix|>package ktgen
import (
"errors"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/api/parser"
)
var (
// VarStringDir describes a directory.
VarStringDir string
// VarStringAPI describes an API.
VarStringAPI string
// VarStringPKG describe... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ktgen
import (
"fmt"
"log"
"strings"
"text/template"
"github.com/iancoleman/strcase"
"github.com/zeromicro/go-zero/tools/goctl/api/util"
)
var funcsMap = template.FuncMap{
"lowCamelCase": lowCamelCase,
"routeToFuncName": routeToFuncName,
"parseType": parseType,
"add": ... | fim | zeromicro/go-zero | go |
package ktgen
import (
_ "embed"
"fmt"
"os"
"path/filepath"
"text/template"
"github.com/iancoleman/strcase"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
)
var (
//go:embed apibase.tpl
apiBaseTemplate string
//go:embed api.tpl
apiTemplate string
)
func genBase(dir, pkg string, api *spec.ApiSpec) er... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tle(dirName),
}); err != nil {
return err
}
err = gogen.DoGenProjectWithModule(apiFilePath, abs, VarStringModule, VarStringStyle, false)
return err
}
<|fim_prefix|>package new
import (
_ "embed"
"errors"
"html/template"
"os"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/z... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package new
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/zeromicro/go-zero/tools/goctl/api/gogen"
"github.com/zeromicro/go-zero/tools/goctl/config"
)
func TestDoGenProjectWithModule_Integration(t *testing.T) {
tes... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ates the template files to the templates built in current goctl.
func Update() error {
err := Clean()
if err != nil {
return err
}
return pathx.InitTemplates(category, templates)
}
<|fim_prefix|>package new
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
categor... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"fmt"
"path"
"sort"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
const (
prefixKey = "prefix"
groupKey = "group"
)
// Api describes syntax for api
type Api struct {
LinePrefix string
Syntax *SyntaxExpr
Import []*ImportExpr
importM map[st... | fim | zeromicro/go-zero | go |
<|fim_suffix|>= nil {
group = g.Text()
}
}
for _, r := range each.ServiceApi.ServiceRoute {
handler := r.GetHandler()
if !handler.IsNotNil() {
return fmt.Errorf("%s handler not exist near line %d", nestedApi.LinePrefix, r.Route.Method.Line())
}
handlerKey := handler.Text()
if len(group) >... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func Test_ImportCycle(t *testing.T) {
const (
mainFilename = "main.api"
subAFilename = "a.api"
subBFilename... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/antlr"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
)
type (
// TokenStream defines a token
TokenStream interface {
GetStart() antlr.Token
GetStop() ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import "github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
// ImportExpr defines import syntax for api
type ImportExpr struct {
Import Expr
Value Expr
DocExpr []Expr
CommentExpr Expr
}
// VisitImportSpec implements from api.BaseApiParserVisitor
func (v *ApiVi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import "errors"
// ErrImportCycleNotAll<|fim_suffix|>-1]
}
<|fim_middle|>owed defines an error for circular importing
var ErrImportCycleNotAllowed = errors.New("import cycle not allowed")
// importStack a stack of import paths
type importStack []string
func (s *importStack) push(p string) ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import "github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
// InfoExpr defines info syntax for api
type InfoExpr struct {
Info Expr
Lp Expr
Rp Expr
Kvs []*KvExpr
}
// VisitInfoSpec implements from api.BaseApiParserVisitor
func (v *ApiVisitor) VisitInfoSpec(ctx *api.Inf... | fim | zeromicro/go-zero | go |
<|fim_suffix|>KvExpr are equal
func (k *KvExpr) Equal(v any) bool {
if v == nil {
return false
}
kv, ok := v.(*KvExpr)
if !ok {
return false
}
if !EqualDoc(k, kv) {
return false
}
return k.Key.Equal(kv.Key) && k.Value.Equal(kv.Value)
}
// Doc returns the document of KvExpr, like // some text
func (k *... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
// Holder define<|fim_suffix|> Holder PlaceHolder
// PlaceHolder defines an empty struct
type PlaceHolder struct{}
<|fim_middle|>s a default instance for PlaceHolder
var<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|> if !ok {
return false
}
if !a.ServiceToken.Equal(api.ServiceToken) {
return false
}
if !a.Name.Equal(api.Name) {
return false
}
if !a.Lbrace.Equal(api.Lbrace) {
return false
}
if !a.Rbrace.Equal(api.Rbrace) {
return false
}
var expecting, acutal []*ServiceRoute
expecting = appen... | fim | zeromicro/go-zero | go |
package ast
import "github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
// SyntaxExpr describes syntax for api
type SyntaxExpr struct {
Syntax Expr
Assign Expr
Version Expr
DocExpr []Expr
CommentExpr Expr
}
// VisitSyntaxLit implements from api.BaseApiParserVisitor
func (v *ApiVisi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ast
import (
"fmt"
"sort"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
type (
// TypeExpr describes an expression for TypeAlias and TypeStruct
TypeExpr interface {
Doc() []Expr
Format() error
Equal(v any) bool
NameExpr() Expr
}
// TypeAlias describes alias ... | fim | zeromicro/go-zero | go |
package api // ApiParser
import "github.com/zeromicro/antlr"
type BaseApiParserVisitor struct {
*antlr.BaseParseTreeVisitor
}
func (v *BaseApiParserVisitor) VisitApi(ctx *ApiContext) any {
return v.VisitChildren(ctx)
}
func (v *BaseApiParserVisitor) VisitSpec(ctx *SpecContext) any {
return v.VisitChildren(ctx)
}
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>37, 238, 3, 2, 2, 2, 238, 236, 3, 2, 2, 2, 238, 239, 3, 2,
2, 2, 239, 240, 3, 2, 2, 2, 240, 241, 5, 59, 30, 2, 241, 242, 5, 59, 30,
2, 242, 243, 5, 59, 30, 2, 243, 244, 5, 59, 30, 2, 244, 246, 3, 2, 2, 2,
245, 224, 3, 2, 2, 2, 245, 226, 3, 2, 2, 2, 245, 234, 3, 2, 2, 2, 246,
56, 3, 2, 2, 2, 247, 256, ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api // ApiParser
import (
"fmt"
"reflect"
"strconv"
"github.com/zeromicro/antlr"
)
// Suppress unused import errors
var _ = fmt.Printf
var _ = reflect.Copy
var _ = strconv.Itoa
var parserATN = []uint16{
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 27, 356,
4, 2, 9, 2, 4, ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>en { return s.importToken }
func (s *ImportBlockContext) SetImportToken(v antlr.Token) { s.importToken = v }
func (s *ImportBlockContext) ID() antlr.TerminalNode {
return s.GetToken(ApiParserParserID, 0)
}
func (s *ImportBlockContext) AllImportBlockValue() []IImportBlockValueContext {
var ts = s.GetT... | fim | zeromicro/go-zero | go |
<|fim_suffix|>yContext {
var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitBodyContext)(nil)).Elem(), 0)
if t == nil {
return nil
}
return t.(ITypeLitBodyContext)
}
func (s *TypeLitContext) ID() antlr.TerminalNode {
return s.GetToken(ApiParserParserID, 0)
}
func (s *TypeLitContext) GetRuleContext() antl... | fim | zeromicro/go-zero | go |
package api
import (
"reflect"
"github.com/zeromicro/antlr"
)
// Part 3
// The apiparser_parser.go file was split into multiple files because it
// was too large and caused a possible memory overflow during goctl installation.
// ITypeBlockBodyContext is an interface to support dynamic dispatch.
type ITypeBlockBo... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api
import (
"reflect"
"github.com/zeromicro/antlr"
)
// Part 4
// The apiparser_parser.go file was split into multiple files because it
// was too large and caused a possible memory overflow during goctl installation.
// ITypeBlockAliasContext is an interface to support dynamic dispatch.
ty... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api
import (
"reflect"
"github.com/zeromicro/antlr"
)
// Part 5
// The apiparser_parser.go file was split into multiple files because it
// was too large and caused a possible memory overflow during goctl installation.
func (p *ApiParserParser) DataType() (localctx IDataTypeContext) {
local... | fim | zeromicro/go-zero | go |
<|fim_suffix|>)
p.EnterRule(localctx, 54, ApiParserParserRULE_serviceApi)
var _la int
defer func() {
p.ExitRule()
}()
defer func() {
if err := recover(); err != nil {
if v, ok := err.(antlr.RecognitionException); ok {
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHan... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tate(301)
var _m = p.Match(ApiParserParserT__1)
localctx.(*BodyContext).lp = _m
}
p.SetState(303)
p.GetErrorHandler().Sync(p)
_la = p.GetTokenStream().LA(1)
if _la == ApiParserParserID {
{
p.SetState(302)
p.Match(ApiParserParserID)
}
}
{
p.SetState(305)
var _m = p.Match(ApiPa... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api
import (
"fmt"
"reflect"
"github.com/zeromicro/antlr"
)
// Part 8
// The apiparser_parser.go file was split into multiple files because it
// was too large and caused a possible memory overflow during goctl installation.
func (s *KvLitContext) Accept(visitor antlr.ParseTreeVisitor) any ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>dy(ctx *BodyContext) any
// Visit a parse tree produced by ApiParserParser#replybody.
VisitReplybody(ctx *ReplybodyContext) any
// Visit a parse tree produced by ApiParserParser#kvLit.
VisitKvLit(ctx *KvLitContext) any
// Visit a parse tree produced by ApiParserParser#serviceName.
VisitServiceNam... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api
import (
"fmt"
"net/http"
"regexp"
"strings"
"unicode"
"github.com/zeromicro/antlr"
)
const (
versionRegex = `(?m)"v[1-9][0-9]*"`
importValueRegex = `(?m)"\/?(?:[^/]+\/)*[^/]+.api"`
tagRegex = `(?m)\x60[a-z]+:".+"\x60`
)
var (
holder = struct{}{}
kind = map[string]... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package api
import (
"testing"
"github.com/stretchr/te<|fim_suffix|>`, true},
{`"/foo/bar.api"`, true},
{`"../foo/bar.api"`, true},
{`"../../foo/bar.api"`, true},
{`"//bar.api"`, false},
{`"/foo/foo_bar.api"`, true},
}
for _, tt := range tests {
t.Run(tt.value, func(t *testing.T) {
a... | fim | zeromicro/go-zero | go |
<|fim_prefix|>// DO NOT EDIT.
// Tool: split apiparser_parser.go
// The apiparser_parser.go file was split into multiple files because it
// was too large and caused a possible memory overflow during goctl installation.
package api
import (
"bufio"
"bytes"
"fmt"
"go/format"
"log"
"os"
"path/filepath"
"testing"... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package test
import (
"fmt"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
normalAPI = `
syntax="v1"
info (
foo: bar
)
type Foo {
Bar int
}... | fim | zeromicro/go-zero | go |
<|fim_suffix|>json:\"vMap\"`"),
DocExpr: []ast.Expr{
ast.NewTextExpr("// vMap"),
},
},
{
Name: ast.NewTextExpr("VArray"),
DataType: &ast.Array{
ArrayExpr: ast.NewTextExpr("[]int"),
LBrack: ast.NewTextExpr("["),
RBrack: ast.NewTextExpr("]"),
Lite... | fim | zeromicro/go-zero | go |
<|fim_suffix|>testify/assert"
)
var files = []string{
"example",
"empty",
"syntax",
"info",
"types",
"service",
}
func TestGrammar(t *testing.T) {
for _, file := range files {
t.Run(file, func(t *testing.T) {
_, err := parser.Parse("./apis/" + file + ".api")
assert.Nil(t, err)
})
}
}
<|fim_prefix|>p... | fim | zeromicro/go-zero | go |
<|fim_suffix|>.Nil(t, err)
list := v.([]*ast.ImportExpr)
for _, each := range list {
assert.True(t, each.Equal(&ast.ImportExpr{
Import: ast.NewTextExpr("import"),
Value: ast.NewTextExpr(`"foo.api"`),
DocExpr: []ast.Expr{
ast.NewTextExpr("// comment block"),
},
CommentExpr: ast.NewTextE... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
var infoAccept = func(p *api.ApiParserParser, visitor *ast.ApiVisitor) any {
return p.InfoSpec().Acce... | fim | zeromicro/go-zero | go |
package test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
func TestBody(t *testing.T) {
fn := func(p *api.ApiParserParser, v *ast.ApiVisitor) any {
return p.Body().Accept(... | fim | zeromicro/go-zero | go |
package test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
var syntaxAccept = func(p *api.ApiParserParser, visitor *ast.ApiVisitor) any {
return p.SyntaxLit().Accept(visitor)... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
)
var fieldAccept = func(p *api.ApiParserParser, visitor *ast.ApiVisitor) any {
return p.Field().Accept... | fim | zeromicro/go-zero | go |
package parser
import (
"fmt"
"path/filepath"
"unicode"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/ast"
"github.com/zeromicro/go-zero/tools/goctl/api/parser/g4/gen/api"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/pkg/env"
apiParser "github.com/zer... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package parser
import (
_ "embed"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
)
//go:embed testdata/test.api
var testApi string
func TestPar<|fim_suffix|>}
<|fim_middle|>seContent(t *testing.T) {
sp, err := ParseContent(testApi)
assert.Nil(t... | fim | zeromicro/go-zero | go |
package spec_test
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
)
func ExampleMember_GetEnumOptions() {
member := spec.Member{
Tag: `json:"foo,options=foo|bar|options|123"`,
}
fmt.Println(member.GetEnumOptions())
// Output:
// [foo bar options 123]
}
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package spec
import (
"errors"
"path"
"slices"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
const (
bodyTagKey = "json"
formTagKey = "form"
pathTagKey = "path"
headerTagKey = "header"
defaultSummaryKey = "summary"
)
var definedKeys = []string{bodyTagK... | fim | zeromicro/go-zero | go |
package spec
// Name returns a basic string, such as int32,int64
func (t PrimitiveType) Name() string {
return t.RawName
}
// Comments returns the comments of struct
func (t PrimitiveType) Comments() []string {
return nil
}
// Documents returns the documents of struct
func (t PrimitiveType) Documents() []string {
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package spec
// RoutePrefixKey is the prefix keyword for the routes.
const RoutePrefixKey = "prefix"
type (
// Doc describes document
Doc []string
// Annotation defines key-value
Annotation struct {
Properties map[string]string
}
// ApiSyntax describes the syntax grammar
ApiSyntax struct {
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tructtag.Parse(tag)
if err != nil {
return nil, err
}
var result Tags
for _, item := range tags.Tags() {
result.tags = append(result.tags, &Tag{Key: item.Key, Name: item.Name, Options: item.Options})
}
return &result, nil
}
// Get gets tag value by specified key
func (t *Tags) Get(key string) ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package spec
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestTags_Get(t *testing.T) {
tags := &Tags{
tags: []*Tag{
{Key: "json", Name: "foo", Options: []string{"omitempty"}},
{Key: "xml", Name: "bar", Options: nil},
},
}
tag, err := tags.Get("json")
assert.NoError(t,... | fim | zeromicro/go-zero | go |
<|fim_suffix|>the spec.
func (s *ApiSpec) Validate() error {
if len(s.Service.Name) == 0 {
return ErrMissingService
}
if len(s.Service.Groups) == 0 {
return ErrMissingService
}
return nil
}
<|fim_prefix|>package spec
import "errors"
var ErrMissingService = errors.New("missing service")
// Validate validates... | fim | zeromicro/go-zero | go |
package swagger
import (
"strconv"
"github.com/zeromicro/go-zero/tools/goctl/util"
"google.golang.org/grpc/metadata"
)
func getBoolFromKVOrDefault(properties map[string]string, key string, def bool) bool {
return getOrDefault(properties, key, def, func(str string, def bool) bool {
res, err := strconv.ParseBool... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_getBoolFromKVOrDefault(t *testing.T) {
properties := map[string]string{
"enabled": `"true"`,
"disabled": `"false"`,
"invalid": `"notabool"`,
"empty_value": `""`,
}
assert.True(t, getBoolFromKVOr... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import "github.com/zeromicro/go-zero/tools/goctl/api/spec"
func fillAllStructs(api *spec.ApiSpec) {
var (
tps []spec.Type
structTypes = make(map[string]spec.DefineStruct)
groups []spec.Group
)
for _, tp := range api.Types {
structTypes[tp.Name()] = tp.(spec.Define... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"gopkg.in/yaml.v2"
)
var (
// VarStringAPI specifies the API filenam... | fim | zeromicro/go-zero | go |
<|fim_suffix|>Path = "/"
)
const (
propertyKeyUseDefinitions = "useDefinitions"
propertyKeyExternalDocsDescription = "externalDocsDescription"
propertyKeyExternalDocsURL = "externalDocsURL"
propertyKeyTitle = "title"
propertyKeyTermsOfService = "termsOfService"
propert... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"net/http"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
<|fim_suffix|>uctType, ok := tp.(spec.DefineStruct)
if !ok {
return []string{}
}
if typeContainsTag(ctx, structType, tagJson) {
return []string{applicationJson}
}
return []string{applicationForm... | fim | zeromicro/go-zero | go |
<|fim_suffix|>: nil,
expected: []string{},
},
{
name: "post nil",
method: http.MethodPost,
tp: nil,
expected: []string{},
},
{
name: "json tag",
method: http.MethodPost,
tp: spec.DefineStruct{
Members: []spec.Member{
{
Tag: `json:"example"`,
},
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>finitions: getBoolFromKVOrDefault(info.Properties, propertyKeyUseDefinitions, defaultValueOfPropertyUseDefinition),
WrapCodeMsg: getBoolFromKVOrDefault(info.Properties, propertyKeyWrapCodeMsg, false),
BizCodeEnumDescription: getStringFromKVOrDefault(info.Properties, propertyKeyBizCo... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"github.com/go-openapi/spec"
apiSpec "github.com/zeromicro/go-zero/tools/goctl/api/spec"
)
func definitionsFromTypes(ctx Context, types []apiSpec.Type) spec.Definitions {
if !ctx.UseDefinitions {
return nil
}
definit<|fim_suffix|>e) spec.Schema {
p, r := propertiesFromTy... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"strconv"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
func rangeValueFromOptions(options []string) (minimum *float64, maximum *float64, exclusiveMinimum bool, exclusiveMaximum bool) {
if len(options) == 0 ... | fim | zeromicro/go-zero | go |
<|fim_suffix|> string
expected any
}{
{
name: "Integer value",
options: []string{"default=42"},
key: "default=",
tp: "integer",
expected: int64(42),
},
{
name: "Boolean value",
options: []string{"default=true"},
key: "default=",
tp: "boolean",
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ype)
case swaggerTypeObject:
p, r := propertiesFromType(ctx, member.Type)
schema.Properties = p
schema.Required = r
}
properties[jsonTag.Name] = schema
}
})
if len(properties) > 0 {
if ctx.UseDefinitions {
structName, ok := isRequestBodyJson(ctx, method, tp)
if ok {
r... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"net/http"
"testing"
"github.com/stretchr/testify/assert"
apiSpec "github.com/zeromicro/go-zero/tools/goctl/api/spec"
)
func TestIsRequestBodyJson(t *testing.T) {
tests := []struct {
name string
method string
hasJson bool
expected bool
}{
{"POST with JSON... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package swagger
import (
"net/http"
"path"
"strings"
"github.com/go-openapi/spec"
apiSpec "github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func spec2Paths(ctx Context, srv apiSpec.Service) *spec.Paths {
paths := &spec.Paths{
Paths: m... | fim | zeromicro/go-zero | go |
<|fim_suffix|>WithRootRoute(t *testing.T) {
tests := []struct {
name string
prefix string
routePath string
expectedPath string
}{
{
name: "prefix with root route",
prefix: "/api/v1/shoppings",
routePath: "/",
expectedPath: "/api/v1/shoppings",
},
{
name: ... | fim | zeromicro/go-zero | go |
<|fim_suffix|> schema.Required = r
// For objects with useDefinitions, set $ref at schema level
if ctx.UseDefinitions {
structName, containsStruct := containsStruct(member.Type)
if containsStruct {
schema.SchemaProps.Ref = spec.MustCreateRef(getRefName(structName))
}
}
default:
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>s(ctx, props, atDoc),
},
},
},
},
},
}
}
}
p, _ := propertiesFromType(ctx, tp)
props.Type = typeFromGoType(ctx, tp)
props.Properties = p
return &spec.Responses{
ResponsesProps: spec.ResponsesProps{
StatusCodeResponses: map[int]spec.Response{
http.StatusOK:... | fim | zeromicro/go-zero | go |
<|fim_suffix|>v)
}
case apiSpec.NestedStruct:
for _, v := range val.Members {
if v.IsInline {
members = append(members, expandMembers(ctx, v.Type)...)
continue
}
members = append(members, v)
}
}
return members
}
func rangeMemberAndDo(ctx Context, structType apiSpec.Type, do func(tag *apiSpec... | fim | zeromicro/go-zero | go |
<|fim_suffix|>assert.Equal(t, "array", arrayField.Type[0])
// Should have items with full schema, no $ref
assert.NotNil(t, arrayField.Items)
assert.NotNil(t, arrayField.Items.Schema)
// Should NOT have $ref at schema level
assert.Empty(t, arrayField.Ref.String(), "Schema should not have $ref when useDefinitions ... | fim | zeromicro/go-zero | go |
<|fim_suffix|> "byte": swaggerTypeInteger,
"float32": swaggerTypeNumber,
"float64": swaggerTypeNumber,
"string": swaggerTypeString,
"bool": swaggerTypeBoolean,
}
commaRune = func(r rune) bool {
return r == ','
}
slashRune = func(r rune) bool {
return r == '/'
}
)
<|fim_prefix|>package swagger
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package tsgen
import (
"errors"
"fmt"
"github.com/gookit/color"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/tools/goctl/api/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
// VarStringDir describes a directory.
VarString... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tFile)
if err := pathx.RemoveIfExist(filename); err != nil {
return err
}
fp, created, err := apiutil.MaybeCreateFile(dir, ".", outputFile)
if err != nil {
return err
}
if !created {
return nil
}
defer fp.Close()
t := template.Must(template.New("componentsTemplate").Parse(componentsTempla... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package tsgen
import (
_ "embed"
"fmt"
"path"
"strings"
"text/template"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
apiutil "github.com/zeromicro/go-zero/tools/goctl/api/util"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
//go:e... | fim | zeromicro/go-zero | go |
<|fim_suffix|>
}
return os.WriteFile(filename, []byte(requestTemplate), 0644)
}
<|fim_prefix|>package tsgen
import (
_ "embed"
"os"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
//go:embed request.ts
var requestTemplate string
func genRequest(dir string) error {
abs, err := filepat... | fim | zeromicro/go-zero | go |
<|fim_suffix|> unknown): Promise<T> {
return api<T>('post', url, req, config);
},
patch<T>(url: string, req: unknown, config?: unknown): Promise<T> {
return api<T>('patch', url, req, config);
}
};
export default webapi
<|fim_prefix|>export type Method =
| 'get'
| 'GET'
| 'delete... | fim | zeromicro/go-zero | typescript |
<|fim_suffix|>nge members {
if member.IsInline {
if err := writeMembers(writer, member.Type, isParam, indent); err != nil {
return err
}
continue
}
if err := writeProperty(writer, member, indent); err != nil {
return apiutil.WrapErr(err, " type "+tp.Name())
}
}
return nil
}
func writeTagMemb... | fim | zeromicro/go-zero | go |
<|fim_suffix|>s|123"`,
Comment: "",
Docs: nil,
IsInline: false,
}
ty, err := genTsType(member, 1)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, `'foo' | 'bar' | 'options' | '123'`, ty)
member.IsInline = true
ty, err = genTsType(member, 1)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, `'foo' ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package tsgen
const (
packagePrefix = "components."
pathPrefix<|fim_suffix|>hPrefix"
)
<|fim_middle|> = "pat<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>turns a copy string by converting snake case into camel case
func ToCamelCase(s string) string {
s = ToLower(s)
out := []rune{}
for index, r := range s {
if r == '_' {
continue
}
if index == 0 {
out = append(out, ToUpperCase(r))
continue
}
if index > 0 && s[index-1] == '_' {
out ... | 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.