1set/starlet

Function listDirContents has 12 return statements (exceeds 4 allowed).

Open

func listDirContents(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var (
        path       string
        recursive  bool
        filterFunc = tps.NullableCallable{}

Method Module.genLoggerBuiltin has 54 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (m *Module) genLoggerBuiltin(name string, level zapcore.Level) starlark.Callable {
    return starlark.NewBuiltin(ModuleName+"."+name, func(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
        var msg string
        if len(args) <= 0 {
            return nil, fmt.Errorf("%s: expected at least 1 argument, got 0", fn.Name())

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func newString(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var value string
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value?", &value); err != nil {
        return nil, err
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func newInt(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var value int64
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value?", &value); err != nil {
        return nil, err
    }

• Read up
  Read up

Function setBody has 11 return statements (exceeds 4 allowed).

Open

func setBody(req *http.Request, body *types.NullableStringOrBytes, formData *starlark.Dict, formEncoding starlark.String, jsonData starlark.Value) error {
    if !body.IsNullOrEmpty() {
        uq := body.GoString()
        req.Body = ioutil.NopCloser(strings.NewReader(uq))
        // Specifying the Content-Length ensures that https://go.dev/src/net/http/transfer.go doesnt specify Transfer-Encoding: chunked which is not supported by some endpoints.

Function copyFileGo has 11 return statements (exceeds 4 allowed).

Open

func copyFileGo(src, dst string, overwrite bool) (string, error) {
    // No empty input
    if src == emptyStr {
        return emptyStr, errors.New("source path is empty")
    }

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func hex(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var x starlark.Int
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "x", &x); err != nil {
        return none, err
    }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func oct(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var x starlark.Int
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "x", &x); err != nil {
        return none, err
    }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func bin(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var x starlark.Int
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "x", &x); err != nil {
        return none, err
    }

• Read up
  Read up

Method Machine.prepareThread has 10 return statements (exceeds 4 allowed).

Open

func (m *Machine) prepareThread(extras StringAnyMap) (err error) {
    mergeExtra := func() error {
        // no extras
        if extras == nil {
            return nil

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if len(d) == 1 {
                m, found := d[moduleName]
                if found {
                    if mm, ok := m.(*starlarkstruct.Module); ok && mm != nil {
                        return mm.Members, nil

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        if len(d) == 1 {
            m, found := d[s]
            if found {
                if mm, ok := m.(*starlarkstruct.Module); ok && mm != nil {
                    return mm.Members, nil

• Read up
  Read up

Function writeDict has 9 return statements (exceeds 4 allowed).

Open

func writeDict(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var (
        buf    = &bytes.Buffer{}
        data   starlark.Value
        header starlark.Iterable

Function Marshal has 8 return statements (exceeds 4 allowed).

Open

func Marshal(data interface{}) (v starlark.Value, err error) {
    switch x := data.(type) {
    case nil:
        v = starlark.None
    case bool:

Function shuffle has 8 return statements (exceeds 4 allowed).

Open

func shuffle(thread *starlark.Thread, bn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    // precondition checks
    var seq starlark.HasSetIndex
    if err := starlark.UnpackArgs(bn.Name(), args, kwargs, "seq", &seq); err != nil {
        return nil, err

Function ExecModuleWithErrorTest has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func ExecModuleWithErrorTest(t *testing.T, name string, loader ModuleLoadFunc, script string, wantErr string, predecl starlark.StringDict) (starlark.StringDict, error) {

Function setQueryParams has 7 return statements (exceeds 4 allowed).

Open

func setQueryParams(rawurl *string, params *starlark.Dict) error {
    keys := params.Keys()
    if len(keys) == 0 {
        return nil
    }

Avoid deeply nested control flow statements.

Open

                    } else if sm, ok := m.(*starlarkstruct.Struct); ok && sm != nil {
                        sd := make(starlark.StringDict)
                        sm.ToStringDict(sd)
                        return sd, nil
                    }

Function processArgs has 7 return statements (exceeds 4 allowed).

Open

func processArgs() int {
    // get starlet machine
    mac := starlet.NewWithNames(nil, preloadModules, lazyLoadModules)
    if allowRecursion {
        mac.EnableRecursionSupport()

Function writeAll has 7 return statements (exceeds 4 allowed).

Open

func writeAll(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var (
        buf   = &bytes.Buffer{}
        data  starlark.Value
        comma string