pulumi/pkg/encoding/decode.go

// Copyright 2016-2017, Pulumi Corporation.  All rights reserved.

// Package encoding can unmarshal LumiPack and LumiIL metadata formats.  Because of their complex structure, we cannot
// rely on the standard JSON  marshaling and unmarshaling routines.  Instead, we will need to do it mostly "by hand".
package encoding

import (
	"github.com/pulumi/pulumi-fabric/pkg/pack"
)

// Decode unmarshals the entire contents of the given byte array into a Package object.
func Decode(m Marshaler, b []byte) (*pack.Package, error) {
	var pack pack.Package
	if err := m.Unmarshal(b, &pack); err != nil {
		return nil, err
	}
	return &pack, nil
}
Clarify aspects of using the DCO 2017-06-26 23:46:34 +02:00			`// Copyright 2016-2017, Pulumi Corporation. All rights reserved.`
Add custom decoding for MuPack metadata This adds basic custom decoding for the MuPack metadata section of the incoming JSON/YAML. Because of the type discriminated union nature of the incoming payload, we cannot rely on the simple built-in JSON/YAML unmarshaling behavior. Note that for the metadata section -- what is in this checkin -- we could have, but the IL AST nodes are problematic. (To know what kind of structure to creat requires inspecting the "kind" field of the IL.) We will use a reflection-driven walk of the target structure plus a weakly typed deserialized map[string]interface{}, as is fairly customary in Go for scenarios like this (though good libaries seem to be lacking in this area...). 2017-01-14 16:40:13 +01:00
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub. 2017-05-18 20:38:28 +02:00			`// Package encoding can unmarshal LumiPack and LumiIL metadata formats. Because of their complex structure, we cannot`
Coconut! 2017-02-25 16:25:33 +01:00			`// rely on the standard JSON marshaling and unmarshaling routines. Instead, we will need to do it mostly "by hand".`
Add custom decoding for MuPack metadata This adds basic custom decoding for the MuPack metadata section of the incoming JSON/YAML. Because of the type discriminated union nature of the incoming payload, we cannot rely on the simple built-in JSON/YAML unmarshaling behavior. Note that for the metadata section -- what is in this checkin -- we could have, but the IL AST nodes are problematic. (To know what kind of structure to creat requires inspecting the "kind" field of the IL.) We will use a reflection-driven walk of the target structure plus a weakly typed deserialized map[string]interface{}, as is fairly customary in Go for scenarios like this (though good libaries seem to be lacking in this area...). 2017-01-14 16:40:13 +01:00			`package encoding`

			`import (`
Rename pulumi/lumi to pulumi/pulumi-fabric We are renaming Lumi to Pulumi Fabric. This change simply renames the pulumi/lumi repo to pulumi/pulumi-fabric, without the CLI tools and other changes that will follow soon afterwards. 2017-08-02 18:25:22 +02:00			`"github.com/pulumi/pulumi-fabric/pkg/pack"`
Add custom decoding for MuPack metadata This adds basic custom decoding for the MuPack metadata section of the incoming JSON/YAML. Because of the type discriminated union nature of the incoming payload, we cannot rely on the simple built-in JSON/YAML unmarshaling behavior. Note that for the metadata section -- what is in this checkin -- we could have, but the IL AST nodes are problematic. (To know what kind of structure to creat requires inspecting the "kind" field of the IL.) We will use a reflection-driven walk of the target structure plus a weakly typed deserialized map[string]interface{}, as is fairly customary in Go for scenarios like this (though good libaries seem to be lacking in this area...). 2017-01-14 16:40:13 +01:00			`)`

			`// Decode unmarshals the entire contents of the given byte array into a Package object.`
Merge pkg/pack/encoding into pkg/encoding 2017-01-17 23:58:45 +01:00			`func Decode(m Marshaler, b []byte) (*pack.Package, error) {`
Implement tag-directed decoding This change eliminates boilerplate decoding logic in all the different data structures, and instead uses a new tag-directed decoding scheme. This works a lot like the JSON deserializers, in that it recognizes the `json:"name"` tags, except that we permit annotation of fields that require custom deserialization, as `json:"name,custom"`. The existing `json:"name,omitempty"` tag is recognized for optional fields. 2017-01-14 18:42:05 +01:00			`var pack pack.Package`
Wire up Lumi to the new runtime strategy :fire: :fire: :fire: :boat: :fire: :fire: :fire: Getting closer on #311. 2017-08-30 03:24:12 +02:00			`if err := m.Unmarshal(b, &pack); err != nil {`
Add custom decoding for MuPack metadata This adds basic custom decoding for the MuPack metadata section of the incoming JSON/YAML. Because of the type discriminated union nature of the incoming payload, we cannot rely on the simple built-in JSON/YAML unmarshaling behavior. Note that for the metadata section -- what is in this checkin -- we could have, but the IL AST nodes are problematic. (To know what kind of structure to creat requires inspecting the "kind" field of the IL.) We will use a reflection-driven walk of the target structure plus a weakly typed deserialized map[string]interface{}, as is fairly customary in Go for scenarios like this (though good libaries seem to be lacking in this area...). 2017-01-14 16:40:13 +01:00			`return nil, err`
			`}`
Add custom decoders to eliminate boilerplate This change overhauls the approach to custom decoding. Instead of decoding the parts of the struct that are "trivial" in one pass, and then patching up the structure afterwards with custom decoding, the decoder itself understands the notion of custom decoder functions. First, the general purpose logic has moved out of pkg/pack/encoding and into a new package, pkg/util/mapper. Most functions are now members of a new top- level type, Mapper, which may be initialized with custom decoders. This is a map from target type to a function that can decode objects into it. Second, the AST-specific decoding logic is rewritten to use it. All AST nodes are now supported, including definitions, statements, and expressions. The overall approach here is to simply define a custom decoder for any interface type that will occur in a node field position. The mapper, upon encountering such a type, will consult the custom decoder map; if a decoder is found, it will be used, otherwise an error results. This decoder then needs to switch on the type discriminated kind field that is present in the metadata, creating a concrete struct of the right type, and then converting it to the desired interface type. Note that, subtly, interface types used only for "marker" purposes don't require any custom decoding, because they do not appear in field positions and therefore won't be encountered during the decoding process. 2017-01-16 18:41:26 +01:00			`return &pack, nil`
			`}`