v1.5.0

Mostly some small bugfixes, with a few small new features:

• Add Position.Col, to mark the column an error occurred (#410)

• Print more detailed errors in the tomlv CLI.

• Ensure ParseError.Message is always set (#411)

• Allow custom string types as map keys (#414)

• Mark meta keys as decoded when using Unmarshaler interface (#426)

• Fix encoding when nested inline table ends with map (#438)

• Fix encoding of several layers of embedded structs (#430)

• Fix ErrorWithPosition panic when there is no newline in the TOML document (#433)

v1.4.0

This version requires Go 1.18

• Add toml.Marshal() (#405)

• Require 2-digit hour (#320)

• Wrap UnmarshalTOML() and UnmarshalText() return values in ParseError for position information (#398)

• Fix inline tables with dotted keys inside inline arrays (e.g. k=[{a.b=1}]) (#400)

v1.3.2

Fix reading BURNTSUSHI_TOML_110 again 😅 The fix for 1.3.1 caused a race issue with multiple decodes being run in parallel.

v1.3.1

This fixes two small bugs:

• The BURNTSUSHI_TOML_110 environment variable would be checked on package import, rather than Decode().

  This meant that setting os.Setenv("BURNTSUSHI_TOML_110", "") had no effect, as it happens after the import.

• Fix order of Meta.Keys() for inline tables (this has been an issue since support for inline tables was added).

v1.3.0

New features:

• Support upcoming TOML 1.1

  While it looks like TOML 1.1 is mostly stable and I don't expect any further major changes, there are NO compatibility guarantees as it is NOT yet released and anything can still change.

  To use it, set the BURNTSUSHI_TOML_110 environment variable to any value, which can be done either with os.SetEnv() or by the user running a program.

  A full list is changes is available in the TOML ChangeLog; the two most notable ones are that newlines and trailing commas are now allowed in inline tables, and Unicode in bare keys can now be used – this is now a valid document:

  lëttërs = {
    ä = "a with diaeresis",
    è = "e with accent grave",
  }
  

• Allow MarshalTOML and MarshalText to be used on the document type itself, instead of only fields (#383).

Bufixes:

• \ escapes at the end of line weren't processed correctly in multiline strings (#372).

• Read over UTF-8 BOM (#381).

• omitempty struct tag did not work for pointer values (#371).

• Fix encoding anonymous structs on 32bit systems (#374).

v1.2.1

This release fixes the omitempty struct tag on an uncomparable type panicking.

v1.2.0

This release adds a few additional features:

• Support encoding and decoding json.Number, making interoperability with JSON when using json.Encoder.UseNumber() easier.

• Support time.Duration string format; an integer will be interpreted as nanoseconds (like before), but a string like "5h" will be parsed. On encoding the string format is used.

• The omitempty struct tag now also works for structs with all zero values, for example an empty time.Time. A struct is considered "empty" when all fields (exported and private) are the zero value.

• Allow using interface{} (or any) as the map key when decoding.

And some fixes:

• Fix encoding.TextUnmarshaler not working for map values.

• Make encoding.TextUnmarshaler and toml.Unmarshaler work if MarshalText() or MarshalTOML() have a pointer receiver.

• Error out on nil returns from MarshalTOML/MarshalText; before they would get encoded as invalid TOML (keyname =).

• Fix a panic where it would try to encode array = [{}, 0] as:

  [[array]]
  [[array]]
  

  Which isn't valid as 0 isn't a table.

• Some better error reporting for some errors.

v1.1.0

Just a few bugfixes:

• Skip fields with toml:"-" even when they're unsupported types. Previously something like this would fail to encode due to func being an unsupported type:

  struct {
      Str  string `toml:"str"
      Func func() `toml:"-"`
  }
  

• Multiline strings can't end with \. This is valid:

  # Valid
  key = """ foo \
  """
  
  # Invalid
  key = """ foo \ """
  

• Don't quote values in TOMLMarshaler. Previously they would always include quoting (e.g. "value"), while the entire point of this interface is to bypass that.

v1.0.0

This release adds much more detailed errors, support for the toml.Marshaler interface, and several fixes.

There is no special meaning in the jump to v1.0; the 0.x releases were always treated as if they're 1.x with regards to compatibility; the versioning scheme for this library predates the release of modules.

New features

• Error reporting is much improved; the reported position of errors should now always be correct and the library can print more detailed errors (#299, #332)

  Decode always return a toml.ParseError, which has three methods:

  • Error() behaves as before and shows a single concise line with the error.

  • ErrorWithPosition() shows the same error, but also shows the line the error occurred at, similar to e.g. clang or the Rust compiler.

  • ErrorWithUsage() is the same as ErrorWithPosition(), but may also show a longer usage guidance message. This isn't always present (in which case it behaves identical to ErrorWithPosition()), but it should be present for most common mistakes and sources of confusion.

  Which error the correct one to use is depends on your application and preferences; in general I would recommend using at least ErrorWithPosition() for user-facing errors, as it's much more helpful for users of any skill level. If your users are likely to be non-technical then ErrorWithUsage() is probably a good idea; I did my best to avoid technical jargon such as "newline" and phrase things in a way that's understandable by most people not intimately familiar with these sort of things.

  Additionally, the TOML key that fialed should now always be reported in all errors.

• Add toml.Marshaler interface. This can be used if you want full control over how something is marshalled as TOML, similar to json.Marshaler etc. This takes precedence over encoding.TextMarshaler. (#327)

• Allow TOML integers to be decoded to a Go float (#325)

  Previously int = 42 could only be decoded to an int* type; now this can also be decoded in a float type as long as it can be represented without loss of data.

Fixes

• Key.String() is now quoted when needed (#333)

• Fix decoding of nested structs on 32bit platforms (#314)

• Empty slices are now always []T{} rather than nil, which was the behaviour in v0.3.1 and before. While they are identical for most purposes, encoding/json encodes them different ([] vs. null), making it an (accidentally) incompatible change (#339)

Release v0.4.1

This fixes a cyclic module dependency issue with github.com/BurntSushi/toml-test that prevented some people from updating. See #313 for some details.