Added as a separate Go module with its own go.mod file to avoid polluting the root module's dependency tree.

The CLI interface and flags are very similar to gofmt:

$ hujsonfmt -h
usage: hujsonfmt [flags] [path ...]
  -d	display diffs instead of rewriting files
  -l	list files whose formatting differs from hujsonfmt's
  -m	minify results
  -s	standardize results to plain JSON
  -w	write result to (source) file instead of stdout

Given paths can either point directly to a file, or to a directory. In the case of a directory, it will be recursively walked finding all *.hujson files.

Input can also be provided via stdin if no paths are provided, or a single path of "-" is provided:

$ echo '{\n// hai\n"foo":"bar"}' | ./hujsonfmt
{
	// hai
	"foo": "bar",
}

I'm not sure why ObjectMember is defined as a type alias instead of a named type. In practice, it's probably not a big deal, but it makes autocomplete weird.

This package provides a HuJSON parser into an AST represented by the following Go types:

• Value: A JSON literal, object, or array with surrounding whitespace/comments.
• ValueTrimmed: A JSON value without surrounding whitespace/comments.
• Extra: Raw bytes of whitespace and comments.
• Literal: Raw bytes of a JSON literal (i.e., null, boolean, string, or number).
• Object: A JSON object.
• Array: A JSON array.

The Parse function parses raw HuJSON input as a Value. The Value.Pack method serializes the AST as raw HuJSON output.

The intention is to delete the fork of "encoding/json" currently here once we migrate all usages to the new code.

The base of hujson is go1.13, the specific commit number is in https://github.com/tailscale/hujson/commit/e2a9696a57f84acb1a0b2d50b986b180be9ed8c4. We should git diff go/src/pkg/encoding/json between that commit and go1.14 and apply the diff to hujson.

Some tests that expect a parse error pass even when no such error occurs. For example, the test suite passes after the following change:

diff --git a/decode_test.go b/decode_test.go
index 43e9b4a..2d24fcb 100644
--- a/decode_test.go
+++ b/decode_test.go
@@ -457,8 +457,8 @@ var unmarshalTests = []unmarshalTest{
        // syntax errors
        {in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}},
        {in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}},
-       {in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
-       {in: `[2, 3`, err: &SyntaxError{msg: "unexpected end of JSON input", Offset: 5}},
+       {in: `{"X":"12x"}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
+       {in: `[2, 3]`, err: &SyntaxError{msg: "unexpected end of JSON input", Offset: 5}},

        // raw value errors
        {in: "\x01 42", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},

We pretty much don't ever want tokens to have leading or trailing whitespaces, so this trims it as part of the string normalization process.

Updates tailscale/tailscale#6040

This reduces the boilerplate of using hujson with json. We avoid a helper that directly wraps json.Unmarshal since there could be a new json library in the future. Let's avoid a dependency on the json Marshal/Unmarshal semantics and keep this package purely about the HuJSON syntax.

These are not referenced anywhere whether in our own source code or in any publicly available source code.

The other deprecated declarations will also be deleted once known usages have been cleaned up.

The hujson package has no compatibility guarantees, so deletion is permissible.

The old HuJSON parser had a bug where it couldn't handle trailing comments after the last value. The new parser has no such problem.

As a quick fix to the deprecated Unmarshal function, use the new parser to strip HuJSON-specific artifacts and then pass the standardized output to Unmarshal.

To use the megalinter and linter in many IDEs is a release the json schema on https://schemastore.org required.

https://github.com/SchemaStore/schemastore

I've been testing hujson and trying to read, edit, then write the edited data back to my json file. But I can't find an example in the docs or the source code on how to write back an edited object while preserving the commas and comments. Note the jwcc.Value = ??? in my example code:

test.json

{
  "foo": "bar" // some comment
}

main.go

package main

import (
	"encoding/json"
	"fmt"
	"os"

	"github.com/tailscale/hujson"
)

func main() {
	fileBytes, err := os.ReadFile("test.json")
	if err != nil {
		fmt.Printf("error reading file: %s", err)
	}
	// read json with commas and comments
	jwccData, err := hujson.Parse(fileBytes)

	// get standard json data into tst
	tst := &test{}
	standardData, err := hujson.Standardize(fileData)
	json.Unmarshal(standardData, tst)

	// update standard data
	tst.Foo = "bar-moodified"

	// TODO: HOW to put the updated tst as jwccData.Value 
	jwcc.Value = ???

	// write the updated tst data back to test.json
	os.WriteFile("test-updated.json", preservedJSON.Pack(), 0644)

	fmt.Println("Preserved JSON Data updated")
	fmt.Println(preservedJSON)
}

type test struct {
	Foo string `json:"foo"`
}

The NewNames function produces a map of canonical names from a Go struct. It can be passed to Value.NormalizeNames to normalizes case-insensitive matches to a JSON object name to the canonical name.