go-plist

The go-plist library is a pure Go transcoder that supports encoding and decoding property lists. It handles multiple formats including:

• Apple XML
• Apple Binary
• OpenStep
• GNUStep

It allows for seamless conversion between these formats and arbitrary Go types.

Ply is a property list pretty-printer and converter. By default, it pretty-prints a plist to stdout. It can also be used to extract specific values using keypaths, convert plists to other formats, and subset plists into new files.

# Basic pretty-print
ply file.plist

# Convert to JSON with indentation
ply -c json -I file.plist

# Extract a value using a keypath
ply -k 'a/b/c' file.plist

You can use Ply to extract a subset of a property list and save it to a new file in a different format. This is achieved by combining the -k (keypath), -c (convert), and -o (out) flags.

Example: Extracting a sub-dictionary to an OpenStep file

To extract the contents of /a/b from file.plist and save it as an indented OpenStep file named file-a-b.plist:

ply -k '/a/b' -o file-a-b.plist -c openstep -I file.plist

Install the howett.net/plist package using the standard Go toolchain:

$ go get howett.net/plist

Install the ply command-line tool using go get:

go get howett.net/plist/cmd/ply

When encoding structs, you can control how fields are serialized using the plist tag. The format is plist:"<key>[,flags...]".

Supported flags:

• omitempty: Only include the field if it is not the zero value for its type.
• -: If the key is -, the field is ignored.

Anonymous struct fields are treated as if their exported fields were part of the outer struct.

type User struct {
    Name     string `plist:"name"` 
    Email    string `plist:"email,omitempty"` 
    Password string `plist:"-"` // Ignored
}

You can use the --key flag to navigate through a property list and extract specific nested data. The keypath syntax supports several operations:

• Maps: Use the key name (e.g., KeyName).
• Arrays: Use square brackets with an index (e.g., [0]) or a slice (e.g., [0:2]).
• Sub-plists: Use the ! operator to treat a data blob (byte array) as a nested property list (e.g., DataKey!).
• Dynamic Expressions: Use $(...) to evaluate a subexpression (e.g., $(some_key)).

You can also use the filename:keypath syntax as a shorthand for the --key flag.

Example usage:

# Extract the first element of an array named 'Items'
ply --key Items[0] input.plist

# Extract a nested key using the filename shorthand
ply input.plist:NestedKey/SubKey

ply --key "Key/SubKey[0]" input.plist

The ply command-line tool allows you to transcode property list files between various formats (XML, Binary, OpenStep, GNUStep) or convert them to other data formats like JSON and YAML. You can also use it to extract specific values from a plist using a keypath.

To see all supported output formats, run the command with the --convert list flag.

ply --convert <format> <filename>
# Example: Convert a binary plist to JSON
ply --convert json my_file.plist

# Example: Convert a plist to an indented XML file
ply --convert xml --indent --out output.xml input.plist

To encode arbitrary Go types (such as maps, structs, or slices) into a property list format, create a new encoder using plist.NewEncoder(io.Writer) and call the Encode method. The encoder writes the resulting property list to the provided writer.

package main
import (
	"howett.net/plist"
	"os"
)
func main() {
	encoder := plist.NewEncoder(os.Stdout)
	encoder.Encode(map[string]string{"hello": "world"})
}

The following options are available for the ply command: