Less complexity - Githubissues

This is what my linter shows me:

grape/serialize.go:53:1 - ReadJson has complexity: 14
  complexity = 1
  + 1 (found 'if' at line: 59, complexity = 2)
  + 1 (found 'if with (35) lines >= 10 ' at line: 59, complexity = 3)
  + 1 (found 'if with (35) lines >= 25 ' at line: 59, complexity = 4)
    + 2 (found 'switch' at line: 64, complexity = 6)
    + 2 (found 'case with (5) lines >= 3 ' at line: 77, complexity = 8)
      + 3 (found 'if' at line: 78, complexity = 11)
    + 2 (found 'case with (3) lines >= 3 ' at line: 86, complexity = 13)
  + 1 (found 'if' at line: 96, complexity = 14)

And by looking at it, I would do an early return around line 59

func (s serializer) ReadJson(w http.ResponseWriter, r *http.Request, dst any) error {
    r.Body = http.MaxBytesReader(w, r.Body, s.maxBytes)
    dec := json.NewDecoder(r.Body)
    dec.DisallowUnknownFields()

    err := dec.Decode(dst)
    if err == nil {
        err = dec.Decode(&struct{}{})
        if err != io.EOF {
            return errors.New("body must only contain a single JSON value")
        }
        return nil
    }

    var syntaxError *json.SyntaxError
    var unmarshalTypeError *json.UnmarshalTypeError
    var invalidUnmarshalError *json.InvalidUnmarshalError

    switch {
    case errors.Is(err, io.EOF):
        return errors.New("body must not be empty")

    case errors.Is(err, io.ErrUnexpectedEOF):
        return errors.New("body contains badly-formed JSON")

    case errors.As(err, &invalidUnmarshalError):
        return err

    case errors.As(err, &syntaxError):
        return fmt.Errorf("body contains badly-formed JSON (at character %d)", syntaxError.Offset)

    case errors.As(err, &unmarshalTypeError):
        if unmarshalTypeError.Field != "" {
            return fmt.Errorf("body contains incorrect JSON type for field %q", unmarshalTypeError.Field)
        }
        return fmt.Errorf("body contains incorrect JSON type (at character %d)", unmarshalTypeError.Offset)

    case err.Error() == "http: request body too large":
        return fmt.Errorf("body must not be larger than %d bytes", s.maxBytes)

    case strings.HasPrefix(err.Error(), "json: unknown field "):
        fieldName := strings.TrimPrefix(err.Error(), "json: unknown field ")
        return fmt.Errorf("body contains unknown key %s", fieldName)

    default:
        return err
    }

    return nil
}

Then this is complexity 10 ! Just my 2 cents ;-)

hossein1376 / grape

Less complexity #5