| // Copyright 2020 The Bazel Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package starlarkjson defines utilities for converting Starlark values |
| // to/from JSON strings. The most recent IETF standard for JSON is |
| // https://www.ietf.org/rfc/rfc7159.txt. |
| package starlarkjson // import "go.starlark.net/starlarkjson" |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "log" |
| "math" |
| "math/big" |
| "sort" |
| "strconv" |
| "strings" |
| "unicode/utf8" |
| |
| "go.starlark.net/starlark" |
| "go.starlark.net/starlarkstruct" |
| ) |
| |
| // Module json is a Starlark module of JSON-related functions. |
| // |
| // json = module( |
| // encode, |
| // decode, |
| // indent, |
| // ) |
| // |
| // def encode(x): |
| // |
| // The encode function accepts one required positional argument, |
| // which it converts to JSON by cases: |
| // - A Starlark value that implements Go's standard json.Marshal |
| // interface defines its own JSON encoding. |
| // - None, True, and False are converted to null, true, and false, respectively. |
| // - Starlark int values, no matter how large, are encoded as decimal integers. |
| // Some decoders may not be able to decode very large integers. |
| // - Starlark float values are encoded using decimal point notation, |
| // even if the value is an integer. |
| // It is an error to encode a non-finite floating-point value. |
| // - Starlark strings are encoded as JSON strings, using UTF-16 escapes. |
| // - a Starlark IterableMapping (e.g. dict) is encoded as a JSON object. |
| // It is an error if any key is not a string. |
| // - any other Starlark Iterable (e.g. list, tuple) is encoded as a JSON array. |
| // - a Starlark HasAttrs (e.g. struct) is encoded as a JSON object. |
| // It an application-defined type matches more than one the cases describe above, |
| // (e.g. it implements both Iterable and HasFields), the first case takes precedence. |
| // Encoding any other value yields an error. |
| // |
| // def decode(x): |
| // |
| // The decode function accepts one positional parameter, a JSON string. |
| // It returns the Starlark value that the string denotes. |
| // - Numbers are parsed as int or float, depending on whether they |
| // contain a decimal point. |
| // - JSON objects are parsed as new unfrozen Starlark dicts. |
| // - JSON arrays are parsed as new unfrozen Starlark lists. |
| // Decoding fails if x is not a valid JSON string. |
| // |
| // def indent(str, *, prefix="", indent="\t"): |
| // |
| // The indent function pretty-prints a valid JSON encoding, |
| // and returns a string containing the indented form. |
| // It accepts one required positional parameter, the JSON string, |
| // and two optional keyword-only string parameters, prefix and indent, |
| // that specify a prefix of each new line, and the unit of indentation. |
| // |
| var Module = &starlarkstruct.Module{ |
| Name: "json", |
| Members: starlark.StringDict{ |
| "encode": starlark.NewBuiltin("json.encode", encode), |
| "decode": starlark.NewBuiltin("json.decode", decode), |
| "indent": starlark.NewBuiltin("json.indent", indent), |
| }, |
| } |
| |
| func encode(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { |
| var x starlark.Value |
| if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &x); err != nil { |
| return nil, err |
| } |
| |
| buf := new(bytes.Buffer) |
| |
| var quoteSpace [128]byte |
| quote := func(s string) { |
| // Non-trivial escaping is handled by Go's encoding/json. |
| if isPrintableASCII(s) { |
| buf.Write(strconv.AppendQuote(quoteSpace[:0], s)) |
| } else { |
| // TODO(adonovan): opt: RFC 8259 mandates UTF-8 for JSON. |
| // Can we avoid this call? |
| data, _ := json.Marshal(s) |
| buf.Write(data) |
| } |
| } |
| |
| var emit func(x starlark.Value) error |
| emit = func(x starlark.Value) error { |
| switch x := x.(type) { |
| case json.Marshaler: |
| // Application-defined starlark.Value types |
| // may define their own JSON encoding. |
| data, err := x.MarshalJSON() |
| if err != nil { |
| return err |
| } |
| buf.Write(data) |
| |
| case starlark.NoneType: |
| buf.WriteString("null") |
| |
| case starlark.Bool: |
| if x { |
| buf.WriteString("true") |
| } else { |
| buf.WriteString("false") |
| } |
| |
| case starlark.Int: |
| fmt.Fprint(buf, x) |
| |
| case starlark.Float: |
| if !isFinite(float64(x)) { |
| return fmt.Errorf("cannot encode non-finite float %v", x) |
| } |
| fmt.Fprintf(buf, "%g", x) // always contains a decimal point |
| |
| case starlark.String: |
| quote(string(x)) |
| |
| case starlark.IterableMapping: |
| // e.g. dict (must have string keys) |
| buf.WriteByte('{') |
| items := x.Items() |
| for _, item := range items { |
| if _, ok := item[0].(starlark.String); !ok { |
| return fmt.Errorf("%s has %s key, want string", x.Type(), item[0].Type()) |
| } |
| } |
| sort.Slice(items, func(i, j int) bool { |
| return items[i][0].(starlark.String) < items[j][0].(starlark.String) |
| }) |
| for i, item := range items { |
| if i > 0 { |
| buf.WriteByte(',') |
| } |
| k, _ := starlark.AsString(item[0]) |
| quote(k) |
| buf.WriteByte(':') |
| if err := emit(item[1]); err != nil { |
| return fmt.Errorf("in %s key %s: %v", x.Type(), item[0], err) |
| } |
| } |
| buf.WriteByte('}') |
| |
| case starlark.Iterable: |
| // e.g. tuple, list |
| buf.WriteByte('[') |
| iter := x.Iterate() |
| defer iter.Done() |
| var elem starlark.Value |
| for i := 0; iter.Next(&elem); i++ { |
| if i > 0 { |
| buf.WriteByte(',') |
| } |
| if err := emit(elem); err != nil { |
| return fmt.Errorf("at %s index %d: %v", x.Type(), i, err) |
| } |
| } |
| buf.WriteByte(']') |
| |
| case starlark.HasAttrs: |
| // e.g. struct |
| buf.WriteByte('{') |
| var names []string |
| names = append(names, x.AttrNames()...) |
| sort.Strings(names) |
| for i, name := range names { |
| v, err := x.Attr(name) |
| if err != nil || v == nil { |
| log.Fatalf("internal error: dir(%s) includes %q but value has no .%s field", x.Type(), name, name) |
| } |
| if i > 0 { |
| buf.WriteByte(',') |
| } |
| quote(name) |
| buf.WriteByte(':') |
| if err := emit(v); err != nil { |
| return fmt.Errorf("in field .%s: %v", name, err) |
| } |
| } |
| buf.WriteByte('}') |
| |
| default: |
| return fmt.Errorf("cannot encode %s as JSON", x.Type()) |
| } |
| return nil |
| } |
| |
| if err := emit(x); err != nil { |
| return nil, fmt.Errorf("%s: %v", b.Name(), err) |
| } |
| return starlark.String(buf.String()), nil |
| } |
| |
| // isPrintableASCII reports whether s contains only printable ASCII. |
| func isPrintableASCII(s string) bool { |
| for i := 0; i < len(s); i++ { |
| b := s[i] |
| if b < 0x20 || b >= 0x80 { |
| return false |
| } |
| } |
| return true |
| } |
| |
| // isFinite reports whether f represents a finite rational value. |
| // It is equivalent to !math.IsNan(f) && !math.IsInf(f, 0). |
| func isFinite(f float64) bool { |
| return math.Abs(f) <= math.MaxFloat64 |
| } |
| |
| func indent(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { |
| prefix, indent := "", "\t" // keyword-only |
| if err := starlark.UnpackArgs(b.Name(), nil, kwargs, |
| "prefix?", &prefix, |
| "indent?", &indent, |
| ); err != nil { |
| return nil, err |
| } |
| var str string // positional-only |
| if err := starlark.UnpackPositionalArgs(b.Name(), args, nil, 1, &str); err != nil { |
| return nil, err |
| } |
| |
| buf := new(bytes.Buffer) |
| if err := json.Indent(buf, []byte(str), prefix, indent); err != nil { |
| return nil, fmt.Errorf("%s: %v", b.Name(), err) |
| } |
| return starlark.String(buf.String()), nil |
| } |
| |
| func decode(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (_ starlark.Value, err error) { |
| var s string |
| if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &s); err != nil { |
| return nil, err |
| } |
| |
| // The decoder necessarily makes certain representation choices |
| // such as list vs tuple, struct vs dict, int vs float. |
| // In principle, we could parameterize it to allow the caller to |
| // control the returned types, but there's no compelling need yet. |
| |
| // Use panic/recover with a distinguished type (failure) for error handling. |
| type failure string |
| fail := func(format string, args ...interface{}) { |
| panic(failure(fmt.Sprintf(format, args...))) |
| } |
| |
| i := 0 |
| |
| // skipSpace consumes leading spaces, and reports whether there is more input. |
| skipSpace := func() bool { |
| for ; i < len(s); i++ { |
| b := s[i] |
| if b != ' ' && b != '\t' && b != '\n' && b != '\r' { |
| return true |
| } |
| } |
| return false |
| } |
| |
| // next consumes leading spaces and returns the first non-space. |
| // It panics if at EOF. |
| next := func() byte { |
| if skipSpace() { |
| return s[i] |
| } |
| fail("unexpected end of file") |
| panic("unreachable") |
| } |
| |
| // parse returns the next JSON value from the input. |
| // It consumes leading but not trailing whitespace. |
| // It panics on error. |
| var parse func() starlark.Value |
| parse = func() starlark.Value { |
| b := next() |
| switch b { |
| case '"': |
| // string |
| |
| // Find end of quotation. |
| // Also, record whether trivial unquoting is safe. |
| // Non-trivial unquoting is handled by Go's encoding/json. |
| safe := true |
| closed := false |
| j := i + 1 |
| for ; j < len(s); j++ { |
| b := s[j] |
| if b == '\\' { |
| safe = false |
| j++ // skip x in \x |
| } else if b == '"' { |
| closed = true |
| j++ // skip '"' |
| break |
| } else if b >= utf8.RuneSelf { |
| safe = false |
| } |
| } |
| if !closed { |
| fail("unclosed string literal") |
| } |
| |
| r := s[i:j] |
| i = j |
| |
| // unquote |
| if safe { |
| r = r[1 : len(r)-1] |
| } else if err := json.Unmarshal([]byte(r), &r); err != nil { |
| fail("%s", err) |
| } |
| return starlark.String(r) |
| |
| case 'n': |
| if strings.HasPrefix(s[i:], "null") { |
| i += len("null") |
| return starlark.None |
| } |
| |
| case 't': |
| if strings.HasPrefix(s[i:], "true") { |
| i += len("true") |
| return starlark.True |
| } |
| |
| case 'f': |
| if strings.HasPrefix(s[i:], "false") { |
| i += len("false") |
| return starlark.False |
| } |
| |
| case '[': |
| // array |
| var elems []starlark.Value |
| |
| i++ // '[' |
| b = next() |
| if b != ']' { |
| for { |
| elem := parse() |
| elems = append(elems, elem) |
| b = next() |
| if b != ',' { |
| if b != ']' { |
| fail("got %q, want ',' or ']'", b) |
| } |
| break |
| } |
| i++ // ',' |
| } |
| } |
| i++ // ']' |
| return starlark.NewList(elems) |
| |
| case '{': |
| // object |
| dict := new(starlark.Dict) |
| |
| i++ // '{' |
| b = next() |
| if b != '}' { |
| for { |
| key := parse() |
| if _, ok := key.(starlark.String); !ok { |
| fail("got %s for object key, want string", key.Type()) |
| } |
| b = next() |
| if b != ':' { |
| fail("after object key, got %q, want ':' ", b) |
| } |
| i++ // ':' |
| value := parse() |
| dict.SetKey(key, value) // can't fail |
| b = next() |
| if b != ',' { |
| if b != '}' { |
| fail("in object, got %q, want ',' or '}'", b) |
| } |
| break |
| } |
| i++ // ',' |
| } |
| } |
| i++ // '}' |
| return dict |
| |
| default: |
| // number? |
| if isdigit(b) || b == '-' { |
| // scan literal. Allow [0-9+-eE.] for now. |
| float := false |
| var j int |
| for j = i + 1; j < len(s); j++ { |
| b = s[j] |
| if isdigit(b) { |
| // ok |
| } else if b == '.' || |
| b == 'e' || |
| b == 'E' || |
| b == '+' || |
| b == '-' { |
| float = true |
| } else { |
| break |
| } |
| } |
| num := s[i:j] |
| i = j |
| |
| // Unlike most C-like languages, |
| // JSON disallows a leading zero before a digit. |
| digits := num |
| if num[0] == '-' { |
| digits = num[1:] |
| } |
| if digits == "" || digits[0] == '0' && len(digits) > 1 && isdigit(digits[1]) { |
| fail("invalid number: %s", num) |
| } |
| |
| // parse literal |
| if float { |
| x, err := strconv.ParseFloat(num, 64) |
| if err != nil { |
| fail("invalid number: %s", num) |
| } |
| return starlark.Float(x) |
| } else { |
| x, ok := new(big.Int).SetString(num, 10) |
| if !ok { |
| fail("invalid number: %s", num) |
| } |
| return starlark.MakeBigInt(x) |
| } |
| } |
| } |
| fail("unexpected character %q", b) |
| panic("unreachable") |
| } |
| defer func() { |
| x := recover() |
| switch x := x.(type) { |
| case failure: |
| err = fmt.Errorf("json.decode: at offset %d, %s", i, x) |
| case nil: |
| // nop |
| default: |
| panic(x) // unexpected panic |
| } |
| }() |
| x := parse() |
| if skipSpace() { |
| fail("unexpected character %q after value", s[i]) |
| } |
| return x, nil |
| } |
| |
| func isdigit(b byte) bool { |
| return b >= '0' && b <= '9' |
| } |