mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-05-07 19:30:22 -05:00
Code Issues Packages Projects Releases 161 Wiki Activity

NomDL serializing

Browse Source 
This now handles serializing TypeRef values
This commit is contained in:
Erik Arvidsson
2015-10-08 16:31:13 -07:00
parent ca3934a718
commit 37336f41be
23 changed files with 825 additions and 509 deletions
Download Patch File Download Diff File Expand all files Collapse all files
clients/pitchmap/index/types.go
+10 -5
View File
@@ -81,13 +81,14 @@ func (l ListOfMapOfStringToValue) Chunks() []types.Future {
}
// A Noms Value that describes ListOfMapOfStringToValue.
var __typeRefForListOfMapOfStringToValue = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind)))
var __typeRefForListOfMapOfStringToValue types.TypeRef
func (m ListOfMapOfStringToValue) TypeRef() types.TypeRef {
return __typeRefForListOfMapOfStringToValue
}
func init() {
__typeRefForListOfMapOfStringToValue = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind)))
types.RegisterFromValFunction(__typeRefForListOfMapOfStringToValue, func(v types.Value) types.NomsValue {
return ListOfMapOfStringToValueFromVal(v)
})
@@ -219,13 +220,14 @@ func (m MapOfStringToValue) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToValue.
var __typeRefForMapOfStringToValue = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind))
var __typeRefForMapOfStringToValue types.TypeRef
func (m MapOfStringToValue) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToValue
}
func init() {
__typeRefForMapOfStringToValue = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind))
types.RegisterFromValFunction(__typeRefForMapOfStringToValue, func(v types.Value) types.NomsValue {
return MapOfStringToValueFromVal(v)
})
@@ -347,13 +349,14 @@ func (m MapOfStringToListOfPitch) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToListOfPitch.
var __typeRefForMapOfStringToListOfPitch = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Pitch", __mainPackageInFile_types_CachedRef)))
var __typeRefForMapOfStringToListOfPitch types.TypeRef
func (m MapOfStringToListOfPitch) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToListOfPitch
}
func init() {
__typeRefForMapOfStringToListOfPitch = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Pitch", __mainPackageInFile_types_CachedRef)))
types.RegisterFromValFunction(__typeRefForMapOfStringToListOfPitch, func(v types.Value) types.NomsValue {
return MapOfStringToListOfPitchFromVal(v)
})
@@ -474,13 +477,14 @@ func (l ListOfPitch) Chunks() []types.Future {
}
// A Noms Value that describes ListOfPitch.
var __typeRefForListOfPitch = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Pitch", __mainPackageInFile_types_CachedRef))
var __typeRefForListOfPitch types.TypeRef
func (m ListOfPitch) TypeRef() types.TypeRef {
return __typeRefForListOfPitch
}
func init() {
__typeRefForListOfPitch = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Pitch", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfPitch, func(v types.Value) types.NomsValue {
return ListOfPitchFromVal(v)
})
@@ -700,13 +704,14 @@ func (m MapOfStringToString) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToString.
var __typeRefForMapOfStringToString = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.StringKind))
var __typeRefForMapOfStringToString types.TypeRef
func (m MapOfStringToString) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToString
}
func init() {
__typeRefForMapOfStringToString = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.StringKind))
types.RegisterFromValFunction(__typeRefForMapOfStringToString, func(v types.Value) types.NomsValue {
return MapOfStringToStringFromVal(v)
})
clients/quad_tree/types.go
+12 -6
View File
@@ -363,13 +363,14 @@ func RefOfValueFromVal(p types.Value) RefOfValue {
}
// A Noms Value that describes RefOfValue.
var __typeRefForRefOfValue = types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.ValueKind))
var __typeRefForRefOfValue types.TypeRef
func (m RefOfValue) TypeRef() types.TypeRef {
return __typeRefForRefOfValue
}
func init() {
__typeRefForRefOfValue = types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.ValueKind))
types.RegisterFromValFunction(__typeRefForRefOfValue, func(v types.Value) types.NomsValue {
return RefOfValueFromVal(v)
})
@@ -573,13 +574,14 @@ func (l ListOfNode) Chunks() []types.Future {
}
// A Noms Value that describes ListOfNode.
var __typeRefForListOfNode = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Node", __mainPackageInFile_types_CachedRef))
var __typeRefForListOfNode types.TypeRef
func (m ListOfNode) TypeRef() types.TypeRef {
return __typeRefForListOfNode
}
func init() {
__typeRefForListOfNode = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Node", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfNode, func(v types.Value) types.NomsValue {
return ListOfNodeFromVal(v)
})
@@ -711,13 +713,14 @@ func (m MapOfStringToQuadTree) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToQuadTree.
var __typeRefForMapOfStringToQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeTypeRef("QuadTree", __mainPackageInFile_types_CachedRef))
var __typeRefForMapOfStringToQuadTree types.TypeRef
func (m MapOfStringToQuadTree) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToQuadTree
}
func init() {
__typeRefForMapOfStringToQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeTypeRef("QuadTree", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForMapOfStringToQuadTree, func(v types.Value) types.NomsValue {
return MapOfStringToQuadTreeFromVal(v)
})
@@ -974,13 +977,14 @@ func (l ListOfRefOfValue) Chunks() []types.Future {
}
// A Noms Value that describes ListOfRefOfValue.
var __typeRefForListOfRefOfValue = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.ValueKind)))
var __typeRefForListOfRefOfValue types.TypeRef
func (m ListOfRefOfValue) TypeRef() types.TypeRef {
return __typeRefForListOfRefOfValue
}
func init() {
__typeRefForListOfRefOfValue = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.ValueKind)))
types.RegisterFromValFunction(__typeRefForListOfRefOfValue, func(v types.Value) types.NomsValue {
return ListOfRefOfValueFromVal(v)
})
@@ -1112,13 +1116,14 @@ func (m MapOfStringToRefOfSQuadTree) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToRefOfSQuadTree.
var __typeRefForMapOfStringToRefOfSQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeCompoundTypeRef("", types.RefKind, types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef)))
var __typeRefForMapOfStringToRefOfSQuadTree types.TypeRef
func (m MapOfStringToRefOfSQuadTree) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToRefOfSQuadTree
}
func init() {
__typeRefForMapOfStringToRefOfSQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeCompoundTypeRef("", types.RefKind, types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef)))
types.RegisterFromValFunction(__typeRefForMapOfStringToRefOfSQuadTree, func(v types.Value) types.NomsValue {
return MapOfStringToRefOfSQuadTreeFromVal(v)
})
@@ -1220,13 +1225,14 @@ func RefOfSQuadTreeFromVal(p types.Value) RefOfSQuadTree {
}
// A Noms Value that describes RefOfSQuadTree.
var __typeRefForRefOfSQuadTree = types.MakeCompoundTypeRef("", types.RefKind, types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef))
var __typeRefForRefOfSQuadTree types.TypeRef
func (m RefOfSQuadTree) TypeRef() types.TypeRef {
return __typeRefForRefOfSQuadTree
}
func init() {
__typeRefForRefOfSQuadTree = types.MakeCompoundTypeRef("", types.RefKind, types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForRefOfSQuadTree, func(v types.Value) types.NomsValue {
return RefOfSQuadTreeFromVal(v)
})
clients/sfcrime_importer/types.go
+2 -1
View File
@@ -97,13 +97,14 @@ func (l ListOfIncident) Chunks() []types.Future {
}
// A Noms Value that describes ListOfIncident.
var __typeRefForListOfIncident = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Incident", __mainPackageInFile_types_CachedRef))
var __typeRefForListOfIncident types.TypeRef
func (m ListOfIncident) TypeRef() types.TypeRef {
return __typeRefForListOfIncident
}
func init() {
__typeRefForListOfIncident = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Incident", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfIncident, func(v types.Value) types.NomsValue {
return ListOfIncidentFromVal(v)
})
clients/sfcrime_search/types.go
+4 -2
View File
@@ -109,13 +109,14 @@ func (l ListOfIncident) Chunks() []types.Future {
}
// A Noms Value that describes ListOfIncident.
var __typeRefForListOfIncident = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Incident", __mainPackageInFile_types_CachedRef))
var __typeRefForListOfIncident types.TypeRef
func (m ListOfIncident) TypeRef() types.TypeRef {
return __typeRefForListOfIncident
}
func init() {
__typeRefForListOfIncident = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Incident", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfIncident, func(v types.Value) types.NomsValue {
return ListOfIncidentFromVal(v)
})
@@ -683,13 +684,14 @@ func (m MapOfStringToSQuadTree) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToSQuadTree.
var __typeRefForMapOfStringToSQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef))
var __typeRefForMapOfStringToSQuadTree types.TypeRef
func (m MapOfStringToSQuadTree) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToSQuadTree
}
func init() {
__typeRefForMapOfStringToSQuadTree = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakeTypeRef("SQuadTree", __mainPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForMapOfStringToSQuadTree, func(v types.Value) types.NomsValue {
return MapOfStringToSQuadTreeFromVal(v)
})
datas/types.go
+2 -1
View File
@@ -129,13 +129,14 @@ func (s SetOfCommit) Chunks() []types.Future {
}
// A Noms Value that describes SetOfCommit.
var __typeRefForSetOfCommit = types.MakeCompoundTypeRef("", types.SetKind, types.MakeTypeRef("Commit", __datasPackageInFile_types_CachedRef))
var __typeRefForSetOfCommit types.TypeRef
func (m SetOfCommit) TypeRef() types.TypeRef {
return __typeRefForSetOfCommit
}
func init() {
__typeRefForSetOfCommit = types.MakeCompoundTypeRef("", types.SetKind, types.MakeTypeRef("Commit", __datasPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForSetOfCommit, func(v types.Value) types.NomsValue {
return SetOfCommitFromVal(v)
})
dataset/dataset_test.go
+1 -1
View File
@@ -30,7 +30,7 @@ func TestDatasetCommitTracker(t *testing.T) {
assert.False(ds2.Head().Value().Equals(ds1Commit))
assert.False(ds1.Head().Value().Equals(ds2Commit))
assert.Equal("sha1-1176427698c2848df16fe97c0bd900f4daf150f5", ms.Root().String())
assert.Equal("sha1-018203db5f23522729c1b3a2e9afc785553000dc", ms.Root().String())
}
func TestExplicitBranchUsingDatasets(t *testing.T) {
dataset/mgmt/types.go
+2 -1
View File
@@ -83,13 +83,14 @@ func (s SetOfDataset) Chunks() []types.Future {
}
// A Noms Value that describes SetOfDataset.
var __typeRefForSetOfDataset = types.MakeCompoundTypeRef("", types.SetKind, types.MakeTypeRef("Dataset", __mgmtPackageInFile_types_CachedRef))
var __typeRefForSetOfDataset types.TypeRef
func (m SetOfDataset) TypeRef() types.TypeRef {
return __typeRefForSetOfDataset
}
func init() {
__typeRefForSetOfDataset = types.MakeCompoundTypeRef("", types.SetKind, types.MakeTypeRef("Dataset", __mgmtPackageInFile_types_CachedRef))
types.RegisterFromValFunction(__typeRefForSetOfDataset, func(v types.Value) types.NomsValue {
return SetOfDatasetFromVal(v)
})
nomdl/codegen/test/list_int64.go
+2 -1
View File
@@ -60,13 +60,14 @@ func (l ListOfInt64) Chunks() []types.Future {
}
// A Noms Value that describes ListOfInt64.
var __typeRefForListOfInt64 = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.Int64Kind))
var __typeRefForListOfInt64 types.TypeRef
func (m ListOfInt64) TypeRef() types.TypeRef {
return __typeRefForListOfInt64
}
func init() {
__typeRefForListOfInt64 = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.Int64Kind))
types.RegisterFromValFunction(__typeRefForListOfInt64, func(v types.Value) types.NomsValue {
return ListOfInt64FromVal(v)
})
nomdl/codegen/test/map.go
+4 -2
View File
@@ -61,13 +61,14 @@ func (m MapOfBoolToString) Chunks() []types.Future {
}
// A Noms Value that describes MapOfBoolToString.
var __typeRefForMapOfBoolToString = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.BoolKind), types.MakePrimitiveTypeRef(types.StringKind))
var __typeRefForMapOfBoolToString types.TypeRef
func (m MapOfBoolToString) TypeRef() types.TypeRef {
return __typeRefForMapOfBoolToString
}
func init() {
__typeRefForMapOfBoolToString = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.BoolKind), types.MakePrimitiveTypeRef(types.StringKind))
types.RegisterFromValFunction(__typeRefForMapOfBoolToString, func(v types.Value) types.NomsValue {
return MapOfBoolToStringFromVal(v)
})
@@ -189,13 +190,14 @@ func (m MapOfStringToValue) Chunks() []types.Future {
}
// A Noms Value that describes MapOfStringToValue.
var __typeRefForMapOfStringToValue = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind))
var __typeRefForMapOfStringToValue types.TypeRef
func (m MapOfStringToValue) TypeRef() types.TypeRef {
return __typeRefForMapOfStringToValue
}
func init() {
__typeRefForMapOfStringToValue = types.MakeCompoundTypeRef("", types.MapKind, types.MakePrimitiveTypeRef(types.StringKind), types.MakePrimitiveTypeRef(types.ValueKind))
types.RegisterFromValFunction(__typeRefForMapOfStringToValue, func(v types.Value) types.NomsValue {
return MapOfStringToValueFromVal(v)
})
nomdl/codegen/test/ref.go
+12 -6
View File
@@ -62,13 +62,14 @@ func RefOfListOfStringFromVal(p types.Value) RefOfListOfString {
}
// A Noms Value that describes RefOfListOfString.
var __typeRefForRefOfListOfString = types.MakeCompoundTypeRef("", types.RefKind, types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.StringKind)))
var __typeRefForRefOfListOfString types.TypeRef
func (m RefOfListOfString) TypeRef() types.TypeRef {
return __typeRefForRefOfListOfString
}
func init() {
__typeRefForRefOfListOfString = types.MakeCompoundTypeRef("", types.RefKind, types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.StringKind)))
types.RegisterFromValFunction(__typeRefForRefOfListOfString, func(v types.Value) types.NomsValue {
return RefOfListOfStringFromVal(v)
})
@@ -136,13 +137,14 @@ func (l ListOfString) Chunks() []types.Future {
}
// A Noms Value that describes ListOfString.
var __typeRefForListOfString = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.StringKind))
var __typeRefForListOfString types.TypeRef
func (m ListOfString) TypeRef() types.TypeRef {
return __typeRefForListOfString
}
func init() {
__typeRefForListOfString = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.StringKind))
types.RegisterFromValFunction(__typeRefForListOfString, func(v types.Value) types.NomsValue {
return ListOfStringFromVal(v)
})
@@ -273,13 +275,14 @@ func (l ListOfRefOfFloat32) Chunks() []types.Future {
}
// A Noms Value that describes ListOfRefOfFloat32.
var __typeRefForListOfRefOfFloat32 = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.Float32Kind)))
var __typeRefForListOfRefOfFloat32 types.TypeRef
func (m ListOfRefOfFloat32) TypeRef() types.TypeRef {
return __typeRefForListOfRefOfFloat32
}
func init() {
__typeRefForListOfRefOfFloat32 = types.MakeCompoundTypeRef("", types.ListKind, types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.Float32Kind)))
types.RegisterFromValFunction(__typeRefForListOfRefOfFloat32, func(v types.Value) types.NomsValue {
return ListOfRefOfFloat32FromVal(v)
})
@@ -391,13 +394,14 @@ func RefOfFloat32FromVal(p types.Value) RefOfFloat32 {
}
// A Noms Value that describes RefOfFloat32.
var __typeRefForRefOfFloat32 = types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.Float32Kind))
var __typeRefForRefOfFloat32 types.TypeRef
func (m RefOfFloat32) TypeRef() types.TypeRef {
return __typeRefForRefOfFloat32
}
func init() {
__typeRefForRefOfFloat32 = types.MakeCompoundTypeRef("", types.RefKind, types.MakePrimitiveTypeRef(types.Float32Kind))
types.RegisterFromValFunction(__typeRefForRefOfFloat32, func(v types.Value) types.NomsValue {
return RefOfFloat32FromVal(v)
})
@@ -522,13 +526,14 @@ func RefOfSetOfFloat32FromVal(p types.Value) RefOfSetOfFloat32 {
}
// A Noms Value that describes RefOfSetOfFloat32.
var __typeRefForRefOfSetOfFloat32 = types.MakeCompoundTypeRef("", types.RefKind, types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.Float32Kind)))
var __typeRefForRefOfSetOfFloat32 types.TypeRef
func (m RefOfSetOfFloat32) TypeRef() types.TypeRef {
return __typeRefForRefOfSetOfFloat32
}
func init() {
__typeRefForRefOfSetOfFloat32 = types.MakeCompoundTypeRef("", types.RefKind, types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.Float32Kind)))
types.RegisterFromValFunction(__typeRefForRefOfSetOfFloat32, func(v types.Value) types.NomsValue {
return RefOfSetOfFloat32FromVal(v)
})
@@ -598,13 +603,14 @@ func (s SetOfFloat32) Chunks() []types.Future {
}
// A Noms Value that describes SetOfFloat32.
var __typeRefForSetOfFloat32 = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.Float32Kind))
var __typeRefForSetOfFloat32 types.TypeRef
func (m SetOfFloat32) TypeRef() types.TypeRef {
return __typeRefForSetOfFloat32
}
func init() {
__typeRefForSetOfFloat32 = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.Float32Kind))
types.RegisterFromValFunction(__typeRefForSetOfFloat32, func(v types.Value) types.NomsValue {
return SetOfFloat32FromVal(v)
})
nomdl/codegen/test/set.go
+2 -1
View File
@@ -62,13 +62,14 @@ func (s SetOfBool) Chunks() []types.Future {
}
// A Noms Value that describes SetOfBool.
var __typeRefForSetOfBool = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.BoolKind))
var __typeRefForSetOfBool types.TypeRef
func (m SetOfBool) TypeRef() types.TypeRef {
return __typeRefForSetOfBool
}
func init() {
__typeRefForSetOfBool = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.BoolKind))
types.RegisterFromValFunction(__typeRefForSetOfBool, func(v types.Value) types.NomsValue {
return SetOfBoolFromVal(v)
})
nomdl/codegen/test/struct.go
+2 -1
View File
@@ -81,13 +81,14 @@ func (l ListOfStruct) Chunks() []types.Future {
}
// A Noms Value that describes ListOfStruct.
var __typeRefForListOfStruct = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Struct", __testPackageInFile_struct_CachedRef))
var __typeRefForListOfStruct types.TypeRef
func (m ListOfStruct) TypeRef() types.TypeRef {
return __typeRefForListOfStruct
}
func init() {
__typeRefForListOfStruct = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Struct", __testPackageInFile_struct_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfStruct, func(v types.Value) types.NomsValue {
return ListOfStructFromVal(v)
})
nomdl/codegen/test/struct_recursive.go
+2 -1
View File
@@ -156,13 +156,14 @@ func (l ListOfTree) Chunks() []types.Future {
}
// A Noms Value that describes ListOfTree.
var __typeRefForListOfTree = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Tree", __testPackageInFile_struct_recursive_CachedRef))
var __typeRefForListOfTree types.TypeRef
func (m ListOfTree) TypeRef() types.TypeRef {
return __typeRefForListOfTree
}
func init() {
__typeRefForListOfTree = types.MakeCompoundTypeRef("", types.ListKind, types.MakeTypeRef("Tree", __testPackageInFile_struct_recursive_CachedRef))
types.RegisterFromValFunction(__typeRefForListOfTree, func(v types.Value) types.NomsValue {
return ListOfTreeFromVal(v)
})
nomdl/codegen/test/struct_with_list.go
+2 -1
View File
@@ -195,13 +195,14 @@ func (l ListOfUInt8) Chunks() []types.Future {
}
// A Noms Value that describes ListOfUInt8.
var __typeRefForListOfUInt8 = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.UInt8Kind))
var __typeRefForListOfUInt8 types.TypeRef
func (m ListOfUInt8) TypeRef() types.TypeRef {
return __typeRefForListOfUInt8
}
func init() {
__typeRefForListOfUInt8 = types.MakeCompoundTypeRef("", types.ListKind, types.MakePrimitiveTypeRef(types.UInt8Kind))
types.RegisterFromValFunction(__typeRefForListOfUInt8, func(v types.Value) types.NomsValue {
return ListOfUInt8FromVal(v)
})
nomdl/codegen/test/struct_with_union_field.go
+2 -1
View File
@@ -324,13 +324,14 @@ func (s SetOfUInt8) Chunks() []types.Future {
}
// A Noms Value that describes SetOfUInt8.
var __typeRefForSetOfUInt8 = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.UInt8Kind))
var __typeRefForSetOfUInt8 types.TypeRef
func (m SetOfUInt8) TypeRef() types.TypeRef {
return __typeRefForSetOfUInt8
}
func init() {
__typeRefForSetOfUInt8 = types.MakeCompoundTypeRef("", types.SetKind, types.MakePrimitiveTypeRef(types.UInt8Kind))
types.RegisterFromValFunction(__typeRefForSetOfUInt8, func(v types.Value) types.NomsValue {
return SetOfUInt8FromVal(v)
})
nomdl/codegen/type_ref.tmpl
+2 -1
View File
@@ -1,11 +1,12 @@
// A Noms Value that describes {{.Name}}.
var __typeRefFor{{.Name}} = {{toTypesTypeRef .Type .FileID .PackageName}}
var __typeRefFor{{.Name}} types.TypeRef
func (m {{.Name}}) TypeRef() types.TypeRef {
return __typeRefFor{{.Name}}
}
func init() {
__typeRefFor{{.Name}} = {{toTypesTypeRef .Type .FileID .PackageName}}
types.RegisterFromValFunction(__typeRefFor{{.Name}}, func(v types.Value) types.NomsValue {
return {{.Name}}FromVal(v)
})
types/decode_noms_value.go
+190 -121
View File
@@ -7,34 +7,22 @@ import (
)
type valueAsNomsValue struct {
v Value
Value
t TypeRef
}
func (v valueAsNomsValue) NomsValue() Value {
return v.v
return v.Value
}
func (v valueAsNomsValue) TypeRef() TypeRef {
return v.TypeRef()
}
func (v valueAsNomsValue) Ref() ref.Ref {
return v.Ref()
}
func (v valueAsNomsValue) Chunks() []Future {
return v.Chunks()
}
func (v valueAsNomsValue) Equals(other Value) bool {
return v.Equals(other)
return v.t
}
func fromTypedEncodeable(w typedValueWrapper, cs chunks.ChunkSource) NomsValue {
i := w.TypedValue()
r := newJsonArrayReader(i, cs)
t := r.readTypeRef()
return r.readTopLevelValue(t, nil)
return r.readTopLevelValue()
}
type jsonArrayReader struct {
@@ -53,6 +41,10 @@ func (r *jsonArrayReader) read() interface{} {
return v
}
func (r *jsonArrayReader) peek() interface{} {
return r.a[r.i]
}
func (r *jsonArrayReader) atEnd() bool {
return r.i >= len(r.a)
}
@@ -78,24 +70,23 @@ func (r *jsonArrayReader) readRef() ref.Ref {
return ref.Parse(s)
}
func (r *jsonArrayReader) readPackage() *Package {
ref := r.readRef()
// TODO: Should load the package if not registered?
return LookupPackage(ref)
}
func (r *jsonArrayReader) readTypeRef() TypeRef {
func (r *jsonArrayReader) readTypeRefAsTag() TypeRef {
kind := r.readKind()
switch kind {
case ListKind, SetKind, RefKind:
elemType := r.readTypeRef()
elemType := r.readTypeRefAsTag()
return MakeCompoundTypeRef("", kind, elemType)
case MapKind:
keyType := r.readTypeRef()
valueType := r.readTypeRef()
keyType := r.readTypeRefAsTag()
valueType := r.readTypeRefAsTag()
return MakeCompoundTypeRef("", kind, keyType, valueType)
case TypeRefKind:
// TypeRefKind can mean that we have a TypeRef primitive or a TypeRef pointing to a TypeRef in a Package. Do a lookahead.
i := r.peek()
if _, ok := i.(float64); ok {
return MakePrimitiveTypeRef(TypeRefKind)
}
pkgRef := r.readRef()
// TODO: Should be the ordinal
name := r.readString()
@@ -114,7 +105,7 @@ func (r *jsonArrayReader) readList(t TypeRef, pkg *Package) NomsValue {
ll := []Value{}
elemType := desc.ElemTypes[0]
for !r.atEnd() {
v := r.readValue(elemType, pkg)
v := r.readTopLevelValueWithoutTag(elemType, pkg)
ll = append(ll, v.NomsValue())
}
@@ -126,7 +117,7 @@ func (r *jsonArrayReader) readSet(t TypeRef, pkg *Package) NomsValue {
ll := []Value{}
elemType := desc.ElemTypes[0]
for !r.atEnd() {
v := r.readValue(elemType, pkg)
v := r.readTopLevelValueWithoutTag(elemType, pkg)
ll = append(ll, v.NomsValue())
}
return ToNomsValueFromTypeRef(t, NewSet(ll...))
@@ -138,64 +129,15 @@ func (r *jsonArrayReader) readMap(t TypeRef, pkg *Package) NomsValue {
keyType := desc.ElemTypes[0]
valueType := desc.ElemTypes[1]
for !r.atEnd() {
k := r.readValue(keyType, pkg)
v := r.readValue(valueType, pkg)
k := r.readTopLevelValueWithoutTag(keyType, pkg)
v := r.readTopLevelValueWithoutTag(valueType, pkg)
ll = append(ll, k.NomsValue(), v.NomsValue())
}
return ToNomsValueFromTypeRef(t, NewMap(ll...))
}
func (r *jsonArrayReader) readStruct(external, t TypeRef, pkg *Package) NomsValue {
desc := t.Desc.(StructDesc)
m := NewMap(
NewString("$name"), NewString(t.Name()),
NewString("$type"), external)
for _, f := range desc.Fields {
if f.Optional {
b := r.read().(bool)
if b {
v := r.readValue(f.T, pkg)
m = m.Set(NewString(f.Name), v.NomsValue())
}
} else {
v := r.readValue(f.T, pkg)
m = m.Set(NewString(f.Name), v.NomsValue())
}
}
if len(desc.Union) > 0 {
i := uint32(r.read().(float64))
m = m.Set(NewString("$unionIndex"), UInt32(i))
v := r.readValue(desc.Union[i].T, pkg)
m = m.Set(NewString("$unionValue"), v.NomsValue())
}
return ToNomsValueFromTypeRef(external, m)
}
func (r *jsonArrayReader) readEnum(TypeRef) NomsValue {
return valueAsNomsValue{UInt32(r.read().(float64))}
}
func (r *jsonArrayReader) readExternal(external TypeRef) NomsValue {
pkg := LookupPackage(external.PackageRef())
name := external.Name()
typeRef := pkg.NamedTypes().Get(name)
d.Chk.True(typeRef.Kind() == EnumKind || typeRef.Kind() == StructKind)
return r.readTypeRefValue(typeRef, external, pkg)
}
func (r *jsonArrayReader) readTypeRefValue(typeRef, external TypeRef, pkg *Package) NomsValue {
switch typeRef.Kind() {
case StructKind:
return r.readStruct(external, typeRef, pkg)
case EnumKind:
return r.readEnum(typeRef)
default:
panic("unreachable")
}
return nil
func (r *jsonArrayReader) readEnum(t TypeRef) NomsValue {
return valueAsNomsValue{UInt32(r.read().(float64)), t}
}
func (r *jsonArrayReader) readRefValue(t TypeRef) NomsValue {
@@ -204,62 +146,43 @@ func (r *jsonArrayReader) readRefValue(t TypeRef) NomsValue {
return ToNomsValueFromTypeRef(t, v)
}
func (r *jsonArrayReader) readValue(t TypeRef, pkg *Package) NomsValue {
switch t.Kind() {
case ListKind, MapKind, SetKind:
a := r.readArray()
r2 := newJsonArrayReader(a, r.cs)
return r2.readTopLevelValue(t, pkg)
case TypeRefKind:
// The inner value is not tagged
d.Chk.NotNil(t.PackageRef())
pkgFromTypeRef := LookupPackage(t.PackageRef())
if t.PackageRef() != (ref.Ref{}) {
pkg = pkgFromTypeRef
}
d.Chk.NotNil(pkg)
external := t
typeRef := pkg.NamedTypes().Get(t.Name())
return r.readTypeRefValue(typeRef, external, pkg)
default:
return r.readTopLevelValue(t, pkg)
}
func (r *jsonArrayReader) readTopLevelValue() NomsValue {
t := r.readTypeRefAsTag()
return r.readTopLevelValueWithoutTag(t, nil)
}
func (r *jsonArrayReader) readTopLevelValue(t TypeRef, pkg *Package) NomsValue {
func (r *jsonArrayReader) readTopLevelValueWithoutTag(t TypeRef, pkg *Package) NomsValue {
switch t.Kind() {
case BoolKind:
return valueAsNomsValue{Bool(r.read().(bool))}
return valueAsNomsValue{Bool(r.read().(bool)), t}
case UInt8Kind:
return valueAsNomsValue{UInt8(r.read().(float64))}
return valueAsNomsValue{UInt8(r.read().(float64)), t}
case UInt16Kind:
return valueAsNomsValue{UInt16(r.read().(float64))}
return valueAsNomsValue{UInt16(r.read().(float64)), t}
case UInt32Kind:
return valueAsNomsValue{UInt32(r.read().(float64))}
return valueAsNomsValue{UInt32(r.read().(float64)), t}
case UInt64Kind:
return valueAsNomsValue{UInt64(r.read().(float64))}
return valueAsNomsValue{UInt64(r.read().(float64)), t}
case Int8Kind:
return valueAsNomsValue{Int8(r.read().(float64))}
return valueAsNomsValue{Int8(r.read().(float64)), t}
case Int16Kind:
return valueAsNomsValue{Int16(r.read().(float64))}
return valueAsNomsValue{Int16(r.read().(float64)), t}
case Int32Kind:
return valueAsNomsValue{Int32(r.read().(float64))}
return valueAsNomsValue{Int32(r.read().(float64)), t}
case Int64Kind:
return valueAsNomsValue{Int64(r.read().(float64))}
return valueAsNomsValue{Int64(r.read().(float64)), t}
case Float32Kind:
return valueAsNomsValue{Float32(r.read().(float64))}
return valueAsNomsValue{Float32(r.read().(float64)), t}
case Float64Kind:
return valueAsNomsValue{Float64(r.read().(float64))}
return valueAsNomsValue{Float64(r.read().(float64)), t}
case StringKind:
return valueAsNomsValue{NewString(r.readString())}
return valueAsNomsValue{NewString(r.readString()), t}
case BlobKind:
panic("not implemented")
case ValueKind:
// The value is always tagged
t := r.readTypeRef()
return r.readValue(t, pkg)
t := r.readTypeRefAsTag()
return r.readValueWithoutTag(t, pkg)
case ListKind:
return r.readList(t, pkg)
case MapKind:
@@ -271,7 +194,153 @@ func (r *jsonArrayReader) readTopLevelValue(t TypeRef, pkg *Package) NomsValue {
case EnumKind, StructKind:
panic("not allowed")
case TypeRefKind:
return r.readExternal(t)
return r.readTypeRefKindToValue(t, pkg)
}
panic("not reachable")
}
func (r *jsonArrayReader) readValueWithoutTag(t TypeRef, pkg *Package) NomsValue {
switch t.Kind() {
case ListKind, MapKind, SetKind:
r2 := newJsonArrayReader(r.readArray(), r.cs)
return r2.readTopLevelValueWithoutTag(t, pkg)
}
return r.readTopLevelValueWithoutTag(t, pkg)
}
func (r *jsonArrayReader) readTypeRefKindToValue(t TypeRef, pkg *Package) NomsValue {
if _, ok := t.Desc.(PrimitiveDesc); ok {
return valueAsNomsValue{r.readTypeRefAsValue(pkg), t}
}
pkgRef := t.PackageRef()
name := t.Name()
pkg2 := LookupPackage(pkgRef)
if pkg2 != nil {
pkg = pkg2
}
typeDef := pkg.NamedTypes().Get(name)
if typeDef.Kind() == EnumKind {
return r.readEnum(t)
}
d.Chk.Equal(StructKind, typeDef.Kind())
return r.readStruct(typeDef, t, pkg)
}
func (r *jsonArrayReader) readTypeRefAsValue(pkg *Package) TypeRef {
k := r.readKind()
switch k {
case EnumKind:
name := r.readString()
r2 := newJsonArrayReader(r.readArray(), r.cs)
ids := []string{}
for !r2.atEnd() {
ids = append(ids, r2.readString())
}
return MakeEnumTypeRef(name, ids...)
case ListKind, MapKind, RefKind, SetKind:
r2 := newJsonArrayReader(r.readArray(), r.cs)
elemTypes := []TypeRef{}
for !r2.atEnd() {
t := r2.readTypeRefAsValue(pkg)
elemTypes = append(elemTypes, t)
}
return MakeCompoundTypeRef("", k, elemTypes...)
case StructKind:
name := r.readString()
fields := []Field{}
choices := Choices{}
fieldReader := newJsonArrayReader(r.readArray(), r.cs)
for !fieldReader.atEnd() {
fieldName := fieldReader.readString()
fieldType := fieldReader.readTypeRefAsValue(pkg)
optional := fieldReader.readBool()
fields = append(fields, Field{Name: fieldName, T: fieldType, Optional: optional})
}
choiceReader := newJsonArrayReader(r.readArray(), r.cs)
for !choiceReader.atEnd() {
fieldName := choiceReader.readString()
fieldType := choiceReader.readTypeRefAsValue(pkg)
optional := choiceReader.readBool()
choices = append(choices, Field{Name: fieldName, T: fieldType, Optional: optional})
}
return MakeStructTypeRef(name, fields, choices)
case TypeRefKind:
pkgRef := r.readRef()
name := r.readString()
return MakeTypeRef(name, pkgRef)
}
d.Chk.True(IsPrimitiveKind(k))
return MakePrimitiveTypeRef(k)
}
// fixupTypeRef goes trough the object graph of tr and updates the PackageRef to pkg if the the old PackageRef was an empty ref.
func fixupTypeRef(tr TypeRef, pkg *Package) TypeRef {
switch desc := tr.Desc.(type) {
case EnumDesc, PrimitiveDesc:
return tr
case CompoundDesc:
elemTypes := make([]TypeRef, len(desc.ElemTypes))
for i, elemType := range desc.ElemTypes {
elemTypes[i] = fixupTypeRef(elemType, pkg)
}
return MakeCompoundTypeRef(tr.Name(), tr.Kind(), elemTypes...)
case StructDesc:
fields := make([]Field, len(desc.Fields))
for i, f := range desc.Fields {
fields[i] = Field{f.Name, fixupTypeRef(f.T, pkg), f.Optional}
}
choices := make(Choices, len(desc.Union))
for i, c := range desc.Union {
choices[i] = Field{c.Name, fixupTypeRef(c.T, pkg), c.Optional}
}
return MakeStructTypeRef(tr.Name(), fields, choices)
case UnresolvedDesc:
if tr.PackageRef() != (ref.Ref{}) {
return tr
}
return MakeTypeRef(tr.Name(), pkg.Ref())
}
if tr.Kind() == TypeRefKind {
}
panic("unreachable")
}
func (r *jsonArrayReader) readStruct(typeDef, typeRef TypeRef, pkg *Package) NomsValue {
typeRef = fixupTypeRef(typeRef, pkg)
typeDef = fixupTypeRef(typeDef, pkg)
// We've read `[StructKind, sha1, name` at this point
desc := typeDef.Desc.(StructDesc)
m := NewMap(
NewString("$name"), NewString(typeRef.Name()),
NewString("$type"), typeRef)
for _, f := range desc.Fields {
if f.Optional {
b := r.read().(bool)
if b {
v := r.readValueWithoutTag(f.T, pkg)
m = m.Set(NewString(f.Name), v.NomsValue())
}
} else {
v := r.readValueWithoutTag(f.T, pkg)
m = m.Set(NewString(f.Name), v.NomsValue())
}
}
if len(desc.Union) > 0 {
i := uint32(r.read().(float64))
m = m.Set(NewString("$unionIndex"), UInt32(i))
v := r.readValueWithoutTag(desc.Union[i].T, pkg)
m = m.Set(NewString("$unionValue"), v.NomsValue())
}
return ToNomsValueFromTypeRef(typeRef, m)
}
types/decode_noms_value_test.go
+190 -165
View File
@@ -28,43 +28,45 @@ func TestRead(t *testing.T) {
assert.True(r.atEnd())
}
func parseJson(s string) (v []interface{}) {
dec := json.NewDecoder(strings.NewReader(s))
func parseJson(s string, vs ...interface{}) (v []interface{}) {
dec := json.NewDecoder(strings.NewReader(fmt.Sprintf(s, vs...)))
dec.Decode(&v)
return
}
func TestReadTypeRef(t *testing.T) {
assert := assert.New(t)
func TestReadTypeRefAsTag(t *testing.T) {
cs := chunks.NewMemoryStore()
a := parseJson(`[0, true]`)
r := newJsonArrayReader(a, cs)
k := r.readKind()
assert.Equal(BoolKind, k)
test := func(expected TypeRef, s string, vs ...interface{}) {
a := parseJson(s, vs...)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRefAsTag()
assert.True(t, expected.Equals(tr))
}
r = newJsonArrayReader(a, cs)
tr := r.readTypeRef()
assert.Equal(BoolKind, tr.Kind())
b := r.readTopLevelValue(tr, nil).NomsValue()
assert.EqualValues(Bool(true), b)
test(MakePrimitiveTypeRef(BoolKind), "[%d, true]", BoolKind)
test(MakePrimitiveTypeRef(TypeRefKind), "[%d, %d]", TypeRefKind, BoolKind)
test(MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(BoolKind)), "[%d, %d, true, false]", ListKind, BoolKind)
r := ref.Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
test(MakeTypeRef("S", r), `[%d, "%s", "S"]`, TypeRefKind, r.String())
test(MakePrimitiveTypeRef(TypeRefKind), `[%d, %d, "%s", "S"]`, TypeRefKind, TypeRefKind, r.String())
}
func TestReadListOfInt32(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf("[%d, %d, 0, 1, 2, 3]", ListKind, Int32Kind))
a := parseJson("[%d, %d, 0, 1, 2, 3]", ListKind, Int32Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
tr := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(Int32Kind))
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, tr}
})
assert.Equal(ListKind, tr.Kind())
assert.Equal(Int32Kind, tr.Desc.(CompoundDesc).ElemTypes[0].Kind())
l := r.readList(tr, nil).NomsValue()
l := r.readTopLevelValue().NomsValue()
assert.EqualValues(NewList(Int32(0), Int32(1), Int32(2), Int32(3)), l)
}
@@ -72,19 +74,15 @@ func TestReadListOfValue(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf(`[%d, %d, %d, 1, %d, "hi", %d, true]`, ListKind, ValueKind, Int32Kind, StringKind, BoolKind))
a := parseJson(`[%d, %d, %d, 1, %d, "hi", %d, true]`, ListKind, ValueKind, Int32Kind, StringKind, BoolKind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
listTr := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(ValueKind))
RegisterFromValFunction(listTr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, listTr}
})
assert.Equal(ListKind, tr.Kind())
assert.Equal(ValueKind, tr.Desc.(CompoundDesc).ElemTypes[0].Kind())
l := r.readList(tr, nil).NomsValue()
l := r.readTopLevelValue().NomsValue()
assert.EqualValues(NewList(Int32(1), NewString("hi"), Bool(true)), l)
}
@@ -92,17 +90,15 @@ func TestReadValueListOfInt8(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf(`[%d, %d, %d, [0, 1, 2]]`, ValueKind, ListKind, Int8Kind))
a := parseJson(`[%d, %d, %d, [0, 1, 2]]`, ValueKind, ListKind, Int8Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
listTr := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(Int8Kind))
listTr := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(Int8Kind))
RegisterFromValFunction(listTr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, listTr}
})
assert.Equal(ValueKind, tr.Kind())
l := r.readTopLevelValue(tr, nil).NomsValue()
l := r.readTopLevelValue().NomsValue()
assert.EqualValues(NewList(Int8(0), Int8(1), Int8(2)), l)
}
@@ -110,18 +106,15 @@ func TestReadMapOfInt64ToFloat64(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf("[%d, %d, %d, 0, 1, 2, 3]", MapKind, Int64Kind, Float64Kind))
a := parseJson("[%d, %d, %d, 0, 1, 2, 3]", MapKind, Int64Kind, Float64Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
tr := MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(Int64Kind), MakePrimitiveTypeRef(Float64Kind))
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, tr}
})
assert.Equal(MapKind, tr.Kind())
assert.Equal(Int64Kind, tr.Desc.(CompoundDesc).ElemTypes[0].Kind())
assert.Equal(Float64Kind, tr.Desc.(CompoundDesc).ElemTypes[1].Kind())
m := r.readMap(tr, nil).NomsValue()
m := r.readTopLevelValue().NomsValue()
assert.EqualValues(NewMap(Int64(0), Float64(1), Int64(2), Float64(3)), m)
}
@@ -129,17 +122,15 @@ func TestReadValueMapOfUInt64ToUInt32(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf("[%d, %d, %d, %d, [0, 1, 2, 3]]", ValueKind, MapKind, UInt64Kind, UInt32Kind))
a := parseJson("[%d, %d, %d, %d, [0, 1, 2, 3]]", ValueKind, MapKind, UInt64Kind, UInt32Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
mapTr := MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(UInt64Kind), MakePrimitiveTypeRef(UInt32Kind))
mapTr := MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(UInt64Kind), MakePrimitiveTypeRef(UInt32Kind))
RegisterFromValFunction(mapTr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, mapTr}
})
assert.Equal(ValueKind, tr.Kind())
m := r.readTopLevelValue(tr, nil).NomsValue()
m := r.readTopLevelValue().NomsValue()
assert.True(NewMap(UInt64(0), UInt32(1), UInt64(2), UInt32(3)).Equals(m))
}
@@ -147,17 +138,15 @@ func TestReadSetOfUInt8(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf("[%d, %d, 0, 1, 2, 3]", SetKind, UInt8Kind))
a := parseJson("[%d, %d, 0, 1, 2, 3]", SetKind, UInt8Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
tr := MakeCompoundTypeRef("", SetKind, MakePrimitiveTypeRef(UInt8Kind))
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, tr}
})
assert.Equal(SetKind, tr.Kind())
assert.Equal(UInt8Kind, tr.Desc.(CompoundDesc).ElemTypes[0].Kind())
s := r.readSet(tr, nil).NomsValue()
s := r.readTopLevelValue().NomsValue()
assert.EqualValues(NewSet(UInt8(0), UInt8(1), UInt8(2), UInt8(3)), s)
}
@@ -165,54 +154,43 @@ func TestReadValueSetOfUInt16(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
a := parseJson(fmt.Sprintf("[%d, %d, %d, [0, 1, 2, 3]]", ValueKind, SetKind, UInt16Kind))
a := parseJson("[%d, %d, %d, [0, 1, 2, 3]]", ValueKind, SetKind, UInt16Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
setTr := MakeCompoundTypeRef("", SetKind, MakePrimitiveTypeRef(UInt16Kind))
RegisterFromValFunction(setTr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, setTr}
})
assert.Equal(ValueKind, tr.Kind())
m := r.readTopLevelValue(tr, nil).NomsValue()
assert.True(NewSet(UInt16(0), UInt16(1), UInt16(2), UInt16(3)).Equals(m))
s := r.readTopLevelValue().NomsValue()
assert.True(NewSet(UInt16(0), UInt16(1), UInt16(2), UInt16(3)).Equals(s))
}
func TestReadStruct(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A1 {
// x: Float32
// b: Bool
// s: String
// }
tref := MakeStructTypeRef("A1", []Field{
Field{"x", MakePrimitiveTypeRef(Int16Kind), false},
Field{"s", MakePrimitiveTypeRef(StringKind), false},
Field{"b", MakePrimitiveTypeRef(BoolKind), false},
}, Choices{})
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("A1", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "A1", 42, "hi", true]`, TypeRefKind, ref.String()))
a := parseJson(`[%d, "%s", "A1", 42, "hi", true]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
structTr := MakeTypeRef("A1", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A1")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("x")).Equals(Int16(42)))
assert.True(v.Get(NewString("s")).Equals(NewString("hi")))
assert.True(v.Get(NewString("b")).Equals(Bool(true)))
@@ -222,15 +200,6 @@ func TestReadStructUnion(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A2 {
// x: Float32
// union {
// b: Bool
// s: String
// }
// }
tref := MakeStructTypeRef("A2", []Field{
Field{"x", MakePrimitiveTypeRef(Float32Kind), false},
}, Choices{
@@ -238,21 +207,20 @@ func TestReadStructUnion(t *testing.T) {
Field{"s", MakePrimitiveTypeRef(StringKind), false},
})
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("A2", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
a := parseJson(fmt.Sprintf(`[%d, "%s", "A2", 42, 1, "hi"]`, TypeRefKind, ref.String()))
a := parseJson(`[%d, "%s", "A2", 42, 1, "hi"]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
structTr := MakeTypeRef("A2", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A2")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("x")).Equals(Float32(42)))
assert.False(v.Has(NewString("b")))
assert.False(v.Has(NewString("s")))
@@ -264,35 +232,27 @@ func TestReadStructOptional(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A3 {
// x: Float32
// s: optional String
// b: optional Bool
// }
tref := MakeStructTypeRef("A3", []Field{
Field{"x", MakePrimitiveTypeRef(Float32Kind), false},
Field{"s", MakePrimitiveTypeRef(StringKind), true},
Field{"b", MakePrimitiveTypeRef(BoolKind), true},
}, Choices{})
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("A3", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "A3", 42, false, true, false]`, TypeRefKind, ref.String()))
a := parseJson(`[%d, "%s", "A3", 42, false, true, false]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
structTr := MakeTypeRef("A3", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A3")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("x")).Equals(Float32(42)))
assert.False(v.Has(NewString("s")))
assert.True(v.Get(NewString("b")).Equals(Bool(false)))
@@ -302,7 +262,6 @@ func TestReadStructWithList(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A4 {
// b: Bool
// l: List(Int32)
@@ -315,26 +274,26 @@ func TestReadStructWithList(t *testing.T) {
Field{"s", MakePrimitiveTypeRef(StringKind), false},
}, Choices{})
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("A4", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "A4", true, [0, 1, 2], "hi"]`, TypeRefKind, ref.String()))
a := parseJson(`[%d, "%s", "A4", true, [0, 1, 2], "hi"]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
structTr := MakeTypeRef("A4", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
l32Tr := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(Int32Kind))
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
})
RegisterFromValFunction(l32Tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, l32Tr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A4")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("b")).Equals(Bool(true)))
assert.True(v.Get(NewString("l")).Equals(NewList(Int32(0), Int32(1), Int32(2))))
assert.True(v.Get(NewString("s")).Equals(NewString("hi")))
@@ -344,7 +303,6 @@ func TestReadStructWithValue(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A5 {
// b: Bool
// v: Value
@@ -357,22 +315,21 @@ func TestReadStructWithValue(t *testing.T) {
Field{"s", MakePrimitiveTypeRef(StringKind), false},
}, Choices{})
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("A5", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "A5", true, %d, 42, "hi"]`, TypeRefKind, ref.String(), UInt8Kind))
a := parseJson(`[%d, "%s", "A5", true, %d, 42, "hi"]`, TypeRefKind, pkgRef.String(), UInt8Kind)
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
structTr := MakeTypeRef("A5", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A5")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("b")).Equals(Bool(true)))
assert.True(v.Get(NewString("v")).Equals(UInt8(42)))
assert.True(v.Get(NewString("s")).Equals(NewString("hi")))
@@ -382,7 +339,6 @@ func TestReadValueStruct(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// struct A1 {
// x: Float32
// b: Bool
@@ -398,17 +354,15 @@ func TestReadValueStruct(t *testing.T) {
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, %d, "%s", "A1", 42, "hi", true]`, ValueKind, TypeRefKind, pkgRef.String()))
a := parseJson(`[%d, %d, "%s", "A1", 42, "hi", true]`, ValueKind, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
structTr := MakeTypeRef("A1", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, structTr}
})
assert.Equal(ValueKind, tr.Kind())
v := r.readTopLevelValue(tr, &pkg).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A1")))
assert.True(v.Get(NewString("$type")).Equals(structTr))
@@ -423,14 +377,13 @@ func TestReadEnum(t *testing.T) {
tref := MakeEnumTypeRef("E", "a", "b", "c")
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("E", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "E", 1]`, TypeRefKind, ref.String()))
a := parseJson(`[%d, "%s", "E", 1]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
assert.Equal(TypeRefKind, tr.Kind())
v := r.readExternal(tr).NomsValue()
v := r.readTopLevelValue().NomsValue()
assert.Equal(uint32(1), uint32(v.(UInt32)))
}
@@ -440,14 +393,13 @@ func TestReadValueEnum(t *testing.T) {
tref := MakeEnumTypeRef("E", "a", "b", "c")
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("E", tref))
ref := RegisterPackage(&pkg)
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, %d, "%s", "E", 1]`, ValueKind, TypeRefKind, ref.String()))
a := parseJson(`[%d, %d, "%s", "E", 1]`, ValueKind, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
assert.Equal(ValueKind, tr.Kind())
v := r.readTopLevelValue(tr, &pkg).NomsValue()
v := r.readTopLevelValue().NomsValue()
assert.Equal(uint32(1), uint32(v.(UInt32)))
}
@@ -457,16 +409,16 @@ func TestReadRef(t *testing.T) {
r := ref.Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
a := parseJson(fmt.Sprintf(`[%d, %d, "%s"]`, RefKind, UInt32Kind, r.String()))
a := parseJson(`[%d, %d, "%s"]`, RefKind, UInt32Kind, r.String())
reader := newJsonArrayReader(a, cs)
tr := reader.readTypeRef()
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
refTr := MakeCompoundTypeRef("", RefKind, MakePrimitiveTypeRef(UInt32Kind))
RegisterFromValFunction(refTr, func(v Value) NomsValue {
return valueAsNomsValue{v, refTr}
})
assert.Equal(RefKind, tr.Kind())
assert.Equal(UInt32Kind, tr.Desc.(CompoundDesc).ElemTypes[0].Kind())
rOut := reader.readRefValue(tr).NomsValue()
assert.True(Ref{r}.Equals(rOut))
v := reader.readTopLevelValue().NomsValue()
assert.True(Ref{r}.Equals(v))
}
func TestReadValueRef(t *testing.T) {
@@ -475,24 +427,22 @@ func TestReadValueRef(t *testing.T) {
r := ref.Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
a := parseJson(fmt.Sprintf(`[%d, %d, %d, "%s"]`, ValueKind, RefKind, UInt32Kind, r.String()))
a := parseJson(`[%d, %d, %d, "%s"]`, ValueKind, RefKind, UInt32Kind, r.String())
reader := newJsonArrayReader(a, cs)
tr := reader.readTypeRef()
refTypeRef := MakeCompoundTypeRef("", RefKind, MakePrimitiveTypeRef(UInt32Kind))
RegisterFromValFunction(refTypeRef, func(v Value) NomsValue {
return valueAsNomsValue{v}
return valueAsNomsValue{v, refTypeRef}
})
assert.Equal(ValueKind, tr.Kind())
rOut := reader.readTopLevelValue(tr, nil).NomsValue()
assert.True(Ref{r}.Equals(rOut))
v := reader.readTopLevelValue().NomsValue()
assert.True(Ref{r}.Equals(v))
}
func TestReadStructWithEnum(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
// Cannot use parse since it is in a different package that depends on types!
// enum E {
// a
// b
@@ -513,21 +463,96 @@ func TestReadStructWithEnum(t *testing.T) {
pkgRef := RegisterPackage(&pkg)
// TODO: Should use ordinal of type and not name
a := parseJson(fmt.Sprintf(`[%d, "%s", "A1", 42, 1, true]`, TypeRefKind, pkgRef.String()))
a := parseJson(`[%d, "%s", "A1", 42, 1, true]`, TypeRefKind, pkgRef.String())
r := newJsonArrayReader(a, cs)
tr := r.readTypeRef()
// structTr := MakeTypeRef("A1", ref)
RegisterFromValFunction(tr, func(v Value) NomsValue {
return valueAsNomsValue{v}
structTr := MakeTypeRef("A1", pkgRef)
RegisterFromValFunction(structTr, func(v Value) NomsValue {
return valueAsNomsValue{v, structTr}
})
assert.Equal(TypeRefKind, tr.Kind())
v := r.readTopLevelValue(tr, &pkg).NomsValue().(Map)
v := r.readTopLevelValue().NomsValue().(Map)
assert.True(v.Get(NewString("$name")).Equals(NewString("A1")))
assert.True(v.Get(NewString("$type")).Equals(tr))
assert.True(v.Get(NewString("$type")).Equals(structTr))
assert.True(v.Get(NewString("x")).Equals(Int16(42)))
assert.True(v.Get(NewString("e")).Equals(UInt32(1)))
assert.True(v.Get(NewString("b")).Equals(Bool(true)))
}
func TestReadTypeRefValue(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewMemoryStore()
test := func(expected TypeRef, json string, vs ...interface{}) {
a := parseJson(json, vs...)
r := newJsonArrayReader(a, cs)
tr := r.readTopLevelValue().NomsValue()
assert.True(expected.Equals(tr))
}
test(MakePrimitiveTypeRef(Int32Kind),
`[%d, %d]`, TypeRefKind, Int32Kind)
test(MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(BoolKind)),
`[%d, %d, [%d]]`, TypeRefKind, ListKind, BoolKind)
test(MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(BoolKind), MakePrimitiveTypeRef(StringKind)),
`[%d, %d, [%d, %d]]`, TypeRefKind, MapKind, BoolKind, StringKind)
test(MakeEnumTypeRef("E", "a", "b", "c"),
`[%d, %d, "E", ["a", "b", "c"]]`, TypeRefKind, EnumKind)
test(MakeStructTypeRef("S", []Field{
Field{"x", MakePrimitiveTypeRef(Int16Kind), false},
Field{"v", MakePrimitiveTypeRef(ValueKind), true},
}, Choices{}),
`[%d, %d, "S", ["x", %d, false, "v", %d, true], []]`, TypeRefKind, StructKind, Int16Kind, ValueKind)
test(MakeStructTypeRef("S", []Field{}, Choices{
Field{"x", MakePrimitiveTypeRef(Int16Kind), false},
Field{"v", MakePrimitiveTypeRef(ValueKind), false},
}),
`[%d, %d, "S", [], ["x", %d, false, "v", %d, false]]`, TypeRefKind, StructKind, Int16Kind, ValueKind)
pkgRef := ref.Parse("sha1-0123456789abcdef0123456789abcdef01234567")
test(MakeTypeRef("E", pkgRef), `[%d, %d, "%s", "E"]`, TypeRefKind, TypeRefKind, pkgRef.String())
test(MakeStructTypeRef("S", []Field{
Field{"e", MakeTypeRef("E", pkgRef), false},
Field{"x", MakePrimitiveTypeRef(Int64Kind), false},
}, Choices{}),
`[%d, %d, "S", ["e", %d, "%s", "E", false, "x", %d, false], []]`, TypeRefKind, StructKind, TypeRefKind, pkgRef.String(), Int64Kind)
}
func TestReadPackage(t *testing.T) {
cs := chunks.NewMemoryStore()
pkg := PackageDef{
NamedTypes: MapOfStringToTypeRefDef{
"EnumStruct": MakeStructTypeRef("EnumStruct",
[]Field{
Field{"hand", MakeTypeRef("Handedness", ref.Ref{}), false},
},
Choices{},
),
"Handedness": MakeEnumTypeRef("Handedness", "right", "left", "switch"),
},
}.New()
// struct Package {
// Dependencies: Set(Ref(Package))
// NamedTypes: Map(String, TypeRef)
// }
a := []interface{}{
float64(TypeRefKind), __typesPackageInFile_package_CachedRef.String(), "Package",
[]interface{}{}, // Dependencies
[]interface{}{
"Handedness", float64(EnumKind), "Handedness", []interface{}{"right", "left", "switch"},
"EnumStruct", float64(StructKind), "EnumStruct", []interface{}{
"hand", float64(TypeRefKind), "sha1-0000000000000000000000000000000000000000", "Handedness", false,
},
[]interface{}{},
},
}
r := newJsonArrayReader(a, cs)
pkg2 := r.readTopLevelValue().(Package)
assert.True(t, pkg.Equals(pkg2))
}
types/encode_noms_value.go
+128 -91
View File
@@ -21,9 +21,7 @@ func (tv typedValue) TypedValue() []interface{} {
func encNomsValue(v NomsValue, cs chunks.ChunkSink) typedValue {
w := newJsonArrayWriter()
t := v.TypeRef()
w.writeTypeRef(t)
w.writeTopLevelValue(t, v.NomsValue(), nil)
w.writeTopLevelValue(v)
return typedValue{w.toArray()}
}
@@ -45,133 +43,172 @@ func (w *jsonArrayWriter) writeRef(r ref.Ref) {
w.write(r.String())
}
func (w *jsonArrayWriter) writeTypeRef(t TypeRef) {
func (w *jsonArrayWriter) writeTypeRefAsTag(t TypeRef) {
k := t.Kind()
w.write(k)
switch k {
case EnumKind, StructKind, TypeRefKind:
r := t.PackageRef()
d.Chk.NotEqual(ref.Ref{}, r)
w.writeRef(r)
// TODO: Should be ordinal instead of name.
w.write(t.Name())
case EnumKind, StructKind:
panic("unreachable")
case ListKind, MapKind, RefKind, SetKind:
for _, elemType := range t.Desc.(CompoundDesc).ElemTypes {
w.writeTypeRef(elemType)
w.writeTypeRefAsTag(elemType)
}
case TypeRefKind:
if _, ok := t.Desc.(PrimitiveDesc); !ok {
r := t.PackageRef()
d.Chk.NotEqual(ref.Ref{}, r)
w.writeRef(r)
// TODO: Should be ordinal instead of name.
w.write(t.Name())
}
}
}
func (w *jsonArrayWriter) writeValue(t TypeRef, v Value, pkg *Package) {
switch t.Kind() {
case ListKind, MapKind, SetKind:
w2 := newJsonArrayWriter()
w2.writeTopLevelValue(t, v, pkg)
w.write(w2.toArray())
default:
w.writeTopLevelValue(t, v, pkg)
}
func (w *jsonArrayWriter) writeTopLevelValue(v NomsValue) {
tr := v.TypeRef()
w.writeTypeRefAsTag(tr)
w.writeValueWithoutTag(v.NomsValue(), tr, nil)
}
func (w *jsonArrayWriter) writeTopLevelValue(t TypeRef, v Value, pkg *Package) {
switch t.Kind() {
case BoolKind, Float32Kind, Float64Kind, Int16Kind, Int32Kind, Int64Kind, Int8Kind, UInt16Kind, UInt32Kind, UInt64Kind, UInt8Kind:
w.write(v.(primitive).ToPrimitive())
case StringKind:
w.write(v.(String).String())
func (w *jsonArrayWriter) writeValueWithoutTag(v Value, tr TypeRef, pkg *Package) {
switch tr.Kind() {
case BlobKind:
panic("not yet implemented")
case ValueKind:
// The value is always tagged
runtimeType := v.TypeRef()
w.writeTypeRef(runtimeType)
w.writeValue(runtimeType, v, pkg)
case BoolKind, Float32Kind, Float64Kind, Int16Kind, Int32Kind, Int64Kind, Int8Kind, UInt16Kind, UInt32Kind, UInt64Kind, UInt8Kind:
w.write(v.(primitive).ToPrimitive())
case ListKind:
w.writeList(t, v.(List), pkg)
elemType := tr.Desc.(CompoundDesc).ElemTypes[0]
v.(List).IterAll(func(v Value, i uint64) {
w.writeValue(v, elemType, pkg)
})
case MapKind:
w.writeMap(t, v.(Map), pkg)
elemTypes := tr.Desc.(CompoundDesc).ElemTypes
v.(Map).IterAll(func(k, v Value) {
w.writeValue(k, elemTypes[0], pkg)
w.writeValue(v, elemTypes[1], pkg)
})
case RefKind:
w.writeRef(v.Ref())
case SetKind:
w.writeSet(t, v.(Set), pkg)
case EnumKind, StructKind:
panic("Enums and Structs use TypeRefKind at top level")
elemType := tr.Desc.(CompoundDesc).ElemTypes[0]
v.(Set).IterAll(func(v Value) {
w.writeValue(v, elemType, pkg)
})
case StringKind:
w.write(v.(String).String())
case TypeRefKind:
w.writeExternal(t, v, pkg)
}
}
func (w *jsonArrayWriter) writeList(t TypeRef, l List, pkg *Package) {
desc := t.Desc.(CompoundDesc)
elemType := desc.ElemTypes[0]
l.IterAll(func(v Value, i uint64) {
w.writeValue(elemType, v, pkg)
})
}
func (w *jsonArrayWriter) writeSet(t TypeRef, s Set, pkg *Package) {
desc := t.Desc.(CompoundDesc)
elemType := desc.ElemTypes[0]
s.IterAll(func(v Value) {
w.writeValue(elemType, v, pkg)
})
}
func (w *jsonArrayWriter) writeMap(t TypeRef, m Map, pkg *Package) {
desc := t.Desc.(CompoundDesc)
keyType := desc.ElemTypes[0]
valueType := desc.ElemTypes[1]
m.IterAll(func(k, v Value) {
w.writeValue(keyType, k, pkg)
w.writeValue(valueType, v, pkg)
})
}
func (w *jsonArrayWriter) writeExternal(t TypeRef, v Value, pkg *Package) {
d.Chk.Equal(t.Kind(), TypeRefKind)
d.Chk.True(t.IsUnresolved())
if t.PackageRef() != (ref.Ref{}) {
pkg = LookupPackage(t.PackageRef())
}
t = pkg.NamedTypes().Get(t.Name())
switch t.Kind() {
case StructKind:
w.writeStruct(t, v.(Map), pkg)
case EnumKind:
w.writeEnum(t, v.(UInt32))
pkg := LookupPackage(tr.PackageRef())
w.writeTypeRefKindValue(v, tr, pkg)
case ValueKind:
d.Chk.Fail("Should be handled by callers")
default:
panic("unreachable")
d.Chk.Fail("Unknown NomsKind")
}
}
func (w *jsonArrayWriter) writeStruct(t TypeRef, m Map, pkg *Package) {
d.Chk.False(t.IsUnresolved())
func (w *jsonArrayWriter) writeValue(v Value, t TypeRef, pkg *Package) {
k := t.Kind()
switch k {
case ListKind, MapKind, SetKind:
w2 := newJsonArrayWriter()
w2.writeValueWithoutTag(v, t, pkg)
w.write(w2.toArray())
case TypeRefKind:
w.writeTypeRefKindValue(v, t, pkg)
case ValueKind:
w.writeTypeRefAsTag(v.TypeRef())
w.writeValue(v, v.TypeRef(), pkg)
default:
w.writeValueWithoutTag(v, t, pkg)
}
}
func (w *jsonArrayWriter) writeTypeRefAsValue(v TypeRef) {
k := v.Kind()
w.write(k)
switch k {
case EnumKind:
w.write(v.Name())
w2 := newJsonArrayWriter()
for _, id := range v.Desc.(EnumDesc).IDs {
w2.write(id)
}
w.write(w2.toArray())
case ListKind, MapKind, RefKind, SetKind:
w2 := newJsonArrayWriter()
for _, elemType := range v.Desc.(CompoundDesc).ElemTypes {
w2.writeTypeRefAsValue(elemType)
}
w.write(w2.toArray())
case StructKind:
w.write(v.Name())
fieldWriter := newJsonArrayWriter()
for _, field := range v.Desc.(StructDesc).Fields {
fieldWriter.write(field.Name)
fieldWriter.writeTypeRefAsValue(field.T)
fieldWriter.write(field.Optional)
}
w.write(fieldWriter.toArray())
choiceWriter := newJsonArrayWriter()
for _, choice := range v.Desc.(StructDesc).Union {
choiceWriter.write(choice.Name)
choiceWriter.writeTypeRefAsValue(choice.T)
choiceWriter.write(choice.Optional)
}
w.write(choiceWriter.toArray())
case TypeRefKind:
if _, ok := v.Desc.(PrimitiveDesc); !ok {
w.writeRef(v.PackageRef())
w.write(v.Name())
}
default:
d.Chk.True(IsPrimitiveKind(k), v.Describe())
}
}
// writeTypeRefKindValue writes either a struct, enum or a TypeRef value
func (w *jsonArrayWriter) writeTypeRefKindValue(v Value, tr TypeRef, pkg *Package) {
if t, ok := v.(TypeRef); ok {
w.writeTypeRefAsValue(t)
} else { // Enum or Struct
pkgRef := tr.PackageRef()
if pkgRef != (ref.Ref{}) {
pkg = LookupPackage(pkgRef)
}
typeDef := pkg.NamedTypes().Get(tr.Name())
k := typeDef.Kind()
if k == EnumKind {
w.write(uint32(v.(UInt32)))
} else {
d.Chk.Equal(StructKind, k)
w.writeStruct(v.(Map), typeDef, pkg)
}
}
}
func (w *jsonArrayWriter) writeStruct(m Map, t TypeRef, pkg *Package) {
desc := t.Desc.(StructDesc)
for _, f := range desc.Fields {
v, ok := m.MaybeGet(NewString(f.Name))
if f.Optional {
if ok {
w.write(true)
w.writeValue(f.T, v, pkg)
w.writeValue(v, f.T, pkg)
} else {
w.write(false)
}
} else {
d.Chk.True(ok)
w.writeValue(f.T, v, pkg)
w.writeValue(v, f.T, pkg)
}
}
if len(desc.Union) > 0 {
i := uint32(m.Get(NewString("$unionIndex")).(UInt32))
v := m.Get(NewString("$unionValue"))
w.write(i)
w.writeValue(desc.Union[i].T, v, pkg)
w.writeValue(v, desc.Union[i].T, pkg)
}
}
func (w *jsonArrayWriter) writeEnum(t TypeRef, v UInt32) {
w.write(uint32(v))
}
types/encode_noms_value_test.go
+138 -66
View File
@@ -7,36 +7,13 @@ import (
"github.com/attic-labs/noms/ref"
)
type testNomsValue struct {
Value
t TypeRef
}
func (nv testNomsValue) NomsValue() Value {
return nv.Value
}
func (nv testNomsValue) TypeRef() TypeRef {
return nv.t
}
func TestWrite(t *testing.T) {
assert := assert.New(t)
w := newJsonArrayWriter()
w.writeTypeRef(MakePrimitiveTypeRef(UInt64Kind))
assert.EqualValues([]interface{}{UInt64Kind}, *w)
}
func TestWritePrimitives(t *testing.T) {
assert := assert.New(t)
f := func(k NomsKind, v Value, ex interface{}) {
w := newJsonArrayWriter()
tref := MakePrimitiveTypeRef(k)
w.writeTypeRef(tref)
w.writeValue(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{k, ex}, *w)
}
@@ -64,8 +41,7 @@ func TestWriteList(t *testing.T) {
v := NewList(Int32(0), Int32(1), Int32(2), Int32(3))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeList(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, Int32Kind, int32(0), int32(1), int32(2), int32(3)}, *w)
}
@@ -77,8 +53,7 @@ func TestWriteListOfList(t *testing.T) {
v := NewList(NewList(Int16(0)), NewList(Int16(1), Int16(2), Int16(3)))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeList(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, ListKind, Int16Kind, []interface{}{int16(0)}, []interface{}{int16(1), int16(2), int16(3)}}, *w)
}
@@ -89,8 +64,7 @@ func TestWriteSet(t *testing.T) {
v := NewSet(UInt32(0), UInt32(1), UInt32(2), UInt32(3))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeSet(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
// the order of the elements is based on the ref of the value.
assert.EqualValues([]interface{}{SetKind, UInt32Kind, uint32(3), uint32(1), uint32(0), uint32(2)}, *w)
}
@@ -103,8 +77,7 @@ func TestWriteSetOfSet(t *testing.T) {
v := NewSet(NewSet(Int32(0)), NewSet(Int32(1), Int32(2), Int32(3)))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeSet(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
// the order of the elements is based on the ref of the value.
assert.EqualValues([]interface{}{SetKind, SetKind, Int32Kind, []interface{}{int32(0)}, []interface{}{int32(1), int32(3), int32(2)}}, *w)
}
@@ -116,8 +89,7 @@ func TestWriteMap(t *testing.T) {
v := NewMap(NewString("a"), Bool(false), NewString("b"), Bool(true))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeMap(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
// the order of the elements is based on the ref of the value.
assert.EqualValues([]interface{}{MapKind, StringKind, BoolKind, "a", false, "b", true}, *w)
}
@@ -131,8 +103,7 @@ func TestWriteMapOfMap(t *testing.T) {
v := NewMap(NewMap(NewString("a"), Int64(0)), NewSet(Bool(true)))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeMap(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
// the order of the elements is based on the ref of the value.
assert.EqualValues([]interface{}{MapKind, MapKind, StringKind, Int64Kind, SetKind, BoolKind, []interface{}{"a", int64(0)}, []interface{}{true}}, *w)
}
@@ -147,8 +118,7 @@ func TestWriteEmptyStruct(t *testing.T) {
v := NewMap()
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S"}, *w)
}
@@ -165,8 +135,7 @@ func TestWriteStruct(t *testing.T) {
v := NewMap(NewString("x"), Int8(42), NewString("b"), Bool(true))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", int8(42), true}, *w)
}
@@ -183,15 +152,13 @@ func TestWriteStructOptionalField(t *testing.T) {
v := NewMap(NewString("x"), Int8(42), NewString("b"), Bool(true))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", true, int8(42), true}, *w)
v = NewMap(NewString("b"), Bool(true))
w = newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", false, true}, *w)
}
@@ -210,15 +177,13 @@ func TestWriteStructWithUnion(t *testing.T) {
v := NewMap(NewString("x"), Int8(42), NewString("$unionIndex"), UInt32(1), NewString("$unionValue"), NewString("hi"))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", int8(42), uint32(1), "hi"}, *w)
v = NewMap(NewString("x"), Int8(42), NewString("$unionIndex"), UInt32(0), NewString("$unionValue"), Bool(true))
w = newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", int8(42), uint32(0), true}, *w)
}
@@ -234,14 +199,12 @@ func TestWriteStructWithList(t *testing.T) {
v := NewMap(NewString("l"), NewList(NewString("a"), NewString("b")))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", []interface{}{"a", "b"}}, *w)
v = NewMap(NewString("l"), NewList())
w = newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", []interface{}{}}, *w)
}
@@ -260,8 +223,7 @@ func TestWriteStructWithStruct(t *testing.T) {
v := NewMap(NewString("s"), NewMap(NewString("x"), Int32(42)))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "S", int32(42)}, *w)
}
@@ -275,8 +237,7 @@ func TestWriteEnum(t *testing.T) {
v := UInt32(1)
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeExternal(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{TypeRefKind, pkgRef.String(), "E", uint32(1)}, *w)
}
@@ -291,8 +252,7 @@ func TestWriteListOfEnum(t *testing.T) {
v := NewList(UInt32(0), UInt32(1), UInt32(2))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeList(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, TypeRefKind, pkgRef.String(), "E", uint32(0), uint32(1), uint32(2)}, *w)
}
@@ -316,8 +276,7 @@ func TestWriteListOfValue(t *testing.T) {
)
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeList(tref, v, nil)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, ValueKind,
BoolKind, true,
@@ -349,20 +308,133 @@ func TestWriteListOfValueWithStruct(t *testing.T) {
v := NewList(NewMap(NewString("$type"), st, NewString("x"), Int32(42)))
w := newJsonArrayWriter()
w.writeTypeRef(tref)
w.writeList(tref, v, &pkg)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, ValueKind, TypeRefKind, pkgRef.String(), "S", int32(42)}, *w)
}
func TestWriteListOfValueWithTypeRefs(t *testing.T) {
assert := assert.New(t)
pkg := NewPackage().SetNamedTypes(NewMapOfStringToTypeRef().Set("S",
MakeStructTypeRef("S", []Field{
Field{"x", MakePrimitiveTypeRef(Int32Kind), false},
}, Choices{})))
pkgRef := RegisterPackage(&pkg)
tref := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(ValueKind))
v := NewList(
Bool(true),
MakePrimitiveTypeRef(Int32Kind),
MakePrimitiveTypeRef(TypeRefKind),
MakeTypeRef("S", pkgRef),
)
w := newJsonArrayWriter()
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, ValueKind,
BoolKind, true,
TypeRefKind, Int32Kind,
TypeRefKind, TypeRefKind,
TypeRefKind, TypeRefKind, pkgRef.String(), "S",
}, *w)
}
func TestWriteRef(t *testing.T) {
assert := assert.New(t)
tref := MakeCompoundTypeRef("", RefKind, MakePrimitiveTypeRef(UInt32Kind))
r := ref.Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
v := Ref{R: r}
w := newJsonArrayWriter()
w.writeTypeRef(tref)
r := ref.Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
w.writeRef(r)
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{RefKind, UInt32Kind, r.String()}, *w)
}
func TestWriteTypeRefValue(t *testing.T) {
assert := assert.New(t)
test := func(expected []interface{}, v TypeRef) {
w := newJsonArrayWriter()
nv := valueAsNomsValue{Value: v, t: MakePrimitiveTypeRef(TypeRefKind)}
w.writeTopLevelValue(nv)
assert.EqualValues(expected, *w)
}
test([]interface{}{TypeRefKind, Int32Kind}, MakePrimitiveTypeRef(Int32Kind))
test([]interface{}{TypeRefKind, ListKind, []interface{}{BoolKind}},
MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(BoolKind)))
test([]interface{}{TypeRefKind, MapKind, []interface{}{BoolKind, StringKind}},
MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(BoolKind), MakePrimitiveTypeRef(StringKind)))
test([]interface{}{TypeRefKind, EnumKind, "E", []interface{}{"a", "b", "c"}},
MakeEnumTypeRef("E", "a", "b", "c"))
test([]interface{}{TypeRefKind, StructKind, "S", []interface{}{"x", Int16Kind, false, "v", ValueKind, true}, []interface{}{}},
MakeStructTypeRef("S", []Field{
Field{"x", MakePrimitiveTypeRef(Int16Kind), false},
Field{"v", MakePrimitiveTypeRef(ValueKind), true},
}, Choices{}))
test([]interface{}{TypeRefKind, StructKind, "S", []interface{}{}, []interface{}{"x", Int16Kind, false, "v", ValueKind, false}},
MakeStructTypeRef("S", []Field{}, Choices{
Field{"x", MakePrimitiveTypeRef(Int16Kind), false},
Field{"v", MakePrimitiveTypeRef(ValueKind), false},
}))
pkgRef := ref.Parse("sha1-0123456789abcdef0123456789abcdef01234567")
test([]interface{}{TypeRefKind, TypeRefKind, pkgRef.String(), "E"},
MakeTypeRef("E", pkgRef))
test([]interface{}{TypeRefKind, StructKind, "S", []interface{}{"e", TypeRefKind, pkgRef.String(), "E", false, "x", Int64Kind, false}, []interface{}{}},
MakeStructTypeRef("S", []Field{
Field{"e", MakeTypeRef("E", pkgRef), false},
Field{"x", MakePrimitiveTypeRef(Int64Kind), false},
}, Choices{}))
}
func TestWriteListOfTypeRefs(t *testing.T) {
assert := assert.New(t)
tref := MakeCompoundTypeRef("", ListKind, MakePrimitiveTypeRef(TypeRefKind))
v := NewList(MakePrimitiveTypeRef(BoolKind), MakeEnumTypeRef("E", "a", "b", "c"), MakePrimitiveTypeRef(StringKind))
w := newJsonArrayWriter()
w.writeTopLevelValue(valueAsNomsValue{Value: v, t: tref})
assert.EqualValues([]interface{}{ListKind, TypeRefKind, BoolKind, EnumKind, "E", []interface{}{"a", "b", "c"}, StringKind}, *w)
}
func TestWritePackage(t *testing.T) {
pkg := PackageDef{
NamedTypes: MapOfStringToTypeRefDef{
"EnumStruct": MakeStructTypeRef("EnumStruct",
[]Field{
Field{"hand", MakeTypeRef("Handedness", ref.Ref{}), false},
},
Choices{},
),
"Handedness": MakeEnumTypeRef("Handedness", "right", "left", "switch"),
},
}.New()
w := newJsonArrayWriter()
w.writeTopLevelValue(pkg)
// struct Package {
// Dependencies: Set(Ref(Package))
// NamedTypes: Map(String, TypeRef)
// }
exp := []interface{}{
TypeRefKind, __typesPackageInFile_package_CachedRef.String(), "Package",
[]interface{}{}, // Dependencies
[]interface{}{
"Handedness", EnumKind, "Handedness", []interface{}{"right", "left", "switch"},
"EnumStruct", StructKind, "EnumStruct", []interface{}{
"hand", TypeRefKind, "sha1-0000000000000000000000000000000000000000", "Handedness", false,
},
[]interface{}{},
},
}
assert.EqualValues(t, exp, w.toArray())
}
types/package.go
+109 -30
View File
@@ -7,6 +7,26 @@ import (
"github.com/attic-labs/noms/ref"
)
var __typesPackageInFile_package_CachedRef ref.Ref
// This function builds up a Noms value that describes the type
// package implemented by this file and registers it with the global
// type package definition cache.
func init() {
p := PackageDef{
NamedTypes: MapOfStringToTypeRefDef{
"Package": MakeStructTypeRef("Package",
[]Field{
Field{"Dependencies", MakeCompoundTypeRef("", SetKind, MakeCompoundTypeRef("", RefKind, MakeTypeRef("Package", ref.Ref{}))), false},
Field{"NamedTypes", MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(StringKind), MakePrimitiveTypeRef(TypeRefKind)), false},
},
Choices{},
),
},
}.New()
__typesPackageInFile_package_CachedRef = RegisterPackage(&p)
}
// SetOfPackage
type SetOfPackage struct {
@@ -25,21 +45,35 @@ func (s SetOfPackage) NomsValue() Value {
return s.s
}
func (s SetOfPackage) Equals(p SetOfPackage) bool {
return s.s.Equals(p.s)
func (s SetOfPackage) Equals(other Value) bool {
if other, ok := other.(SetOfPackage); ok {
return s.s.Equals(other.s)
}
return false
}
func (s SetOfPackage) Ref() ref.Ref {
return s.s.Ref()
}
func (s SetOfPackage) Chunks() []Future {
return s.s.Chunks()
}
// A Noms Value that describes SetOfPackage.
var __typeRefForSetOfPackage = MakeCompoundTypeRef("", SetKind, MakeTypeRef("Package", ref.Ref{}))
var __typeRefForSetOfPackage TypeRef
func (m SetOfPackage) TypeRef() TypeRef {
return __typeRefForSetOfPackage
}
func init() {
__typeRefForSetOfPackage = MakeCompoundTypeRef("", SetKind, MakeTypeRef("Package", __typesPackageInFile_package_CachedRef))
RegisterFromValFunction(__typeRefForSetOfPackage, func(v Value) NomsValue {
return SetOfPackageFromVal(v)
})
}
func (s SetOfPackage) Empty() bool {
return s.s.Empty()
}
@@ -125,7 +159,7 @@ type Package struct {
func NewPackage() Package {
return Package{NewMap(
NewString("$name"), NewString("Package"),
NewString("$type"), __typeRefForPackage,
NewString("$type"), MakeTypeRef("Package", __typesPackageInFile_package_CachedRef),
NewString("Dependencies"), NewSet(),
NewString("NamedTypes"), NewMap(),
)}
@@ -143,7 +177,7 @@ func (def PackageDef) New() Package {
return Package{
NewMap(
NewString("$name"), NewString("Package"),
NewString("$type"), __typeRefForPackage,
NewString("$type"), MakeTypeRef("Package", __typesPackageInFile_package_CachedRef),
NewString("Dependencies"), def.Dependencies.New().NomsValue(),
NewString("NamedTypes"), def.NamedTypes.New().NomsValue(),
)}
@@ -155,19 +189,19 @@ func (s Package) Def() (d PackageDef) {
return
}
// A Noms Value that describes Package.
var __typeRefForPackage = MakeStructTypeRef("Package",
[]Field{
Field{"Dependencies", MakeCompoundTypeRef("", SetKind, MakeCompoundTypeRef("", RefKind, MakeTypeRef("Package", ref.Ref{}))), false},
Field{"NamedTypes", MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(StringKind), MakePrimitiveTypeRef(TypeRefKind)), false},
},
Choices{},
)
var __typeRefForPackage TypeRef
func (m Package) TypeRef() TypeRef {
return __typeRefForPackage
}
func init() {
__typeRefForPackage = MakeTypeRef("Package", __typesPackageInFile_package_CachedRef)
RegisterFromValFunction(__typeRefForPackage, func(v Value) NomsValue {
return PackageFromVal(v)
})
}
func PackageFromVal(val Value) Package {
// TODO: Validate here
return Package{val.(Map)}
@@ -177,16 +211,19 @@ func (s Package) NomsValue() Value {
return s.m
}
func (s Package) Equals(other Package) bool {
return s.m.Equals(other.m)
func (s Package) Equals(other Value) bool {
if other, ok := other.(Package); ok {
return s.m.Equals(other.m)
}
return false
}
func (s Package) Ref() ref.Ref {
return s.m.Ref()
}
func (s Package) Type() TypeRef {
return s.m.Get(NewString("$type")).(TypeRef)
func (s Package) Chunks() []Future {
return s.m.Chunks()
}
func (s Package) Dependencies() SetOfRefOfPackage {
@@ -244,21 +281,35 @@ func (s SetOfRefOfPackage) NomsValue() Value {
return s.s
}
func (s SetOfRefOfPackage) Equals(p SetOfRefOfPackage) bool {
return s.s.Equals(p.s)
func (s SetOfRefOfPackage) Equals(other Value) bool {
if other, ok := other.(SetOfRefOfPackage); ok {
return s.s.Equals(other.s)
}
return false
}
func (s SetOfRefOfPackage) Ref() ref.Ref {
return s.s.Ref()
}
func (s SetOfRefOfPackage) Chunks() []Future {
return s.s.Chunks()
}
// A Noms Value that describes SetOfRefOfPackage.
var __typeRefForSetOfRefOfPackage = MakeCompoundTypeRef("", SetKind, __typeRefForPackage)
var __typeRefForSetOfRefOfPackage TypeRef
func (m SetOfRefOfPackage) TypeRef() TypeRef {
return __typeRefForSetOfRefOfPackage
}
func init() {
__typeRefForSetOfRefOfPackage = MakeCompoundTypeRef("", SetKind, MakeCompoundTypeRef("", RefKind, MakeTypeRef("Package", __typesPackageInFile_package_CachedRef)))
RegisterFromValFunction(__typeRefForSetOfRefOfPackage, func(v Value) NomsValue {
return SetOfRefOfPackageFromVal(v)
})
}
func (s SetOfRefOfPackage) Empty() bool {
return s.s.Empty()
}
@@ -357,15 +408,15 @@ func (r RefOfPackage) Ref() ref.Ref {
return r.r
}
func (r RefOfPackage) Equals(other RefOfPackage) bool {
return r.Ref() == other.Ref()
func (r RefOfPackage) Equals(other Value) bool {
if other, ok := other.(RefOfPackage); ok {
return r.r == other.r
}
return false
}
// A Noms Value that describes RefOfPackage.
var __typeRefForRefOfPackage = MakeCompoundTypeRef("", RefKind, __typeRefForPackage)
func (m RefOfPackage) TypeRef() TypeRef {
return __typeRefForRefOfPackage
func (r RefOfPackage) Chunks() []Future {
return nil
}
func (r RefOfPackage) NomsValue() Value {
@@ -376,6 +427,20 @@ func RefOfPackageFromVal(p Value) RefOfPackage {
return RefOfPackage{p.(Ref).Ref()}
}
// A Noms Value that describes RefOfPackage.
var __typeRefForRefOfPackage TypeRef
func (m RefOfPackage) TypeRef() TypeRef {
return __typeRefForRefOfPackage
}
func init() {
__typeRefForRefOfPackage = MakeCompoundTypeRef("", RefKind, MakeTypeRef("Package", __typesPackageInFile_package_CachedRef))
RegisterFromValFunction(__typeRefForRefOfPackage, func(v Value) NomsValue {
return RefOfPackageFromVal(v)
})
}
func (r RefOfPackage) GetValue(cs chunks.ChunkSource) Package {
return PackageFromVal(ReadValue(r.r, cs))
}
@@ -423,21 +488,35 @@ func (m MapOfStringToTypeRef) NomsValue() Value {
return m.m
}
func (m MapOfStringToTypeRef) Equals(p MapOfStringToTypeRef) bool {
return m.m.Equals(p.m)
func (m MapOfStringToTypeRef) Equals(other Value) bool {
if other, ok := other.(MapOfStringToTypeRef); ok {
return m.m.Equals(other.m)
}
return false
}
func (m MapOfStringToTypeRef) Ref() ref.Ref {
return m.m.Ref()
}
func (m MapOfStringToTypeRef) Chunks() []Future {
return m.m.Chunks()
}
// A Noms Value that describes MapOfStringToTypeRef.
var __typeRefForMapOfStringToTypeRef = MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(StringKind), MakePrimitiveTypeRef(TypeRefKind))
var __typeRefForMapOfStringToTypeRef TypeRef
func (m MapOfStringToTypeRef) TypeRef() TypeRef {
return __typeRefForMapOfStringToTypeRef
}
func init() {
__typeRefForMapOfStringToTypeRef = MakeCompoundTypeRef("", MapKind, MakePrimitiveTypeRef(StringKind), MakePrimitiveTypeRef(TypeRefKind))
RegisterFromValFunction(__typeRefForMapOfStringToTypeRef, func(v Value) NomsValue {
return MapOfStringToTypeRefFromVal(v)
})
}
func (m MapOfStringToTypeRef) Empty() bool {
return m.m.Empty()
}
types/package_test.go
+6 -3
View File
@@ -3,18 +3,21 @@ package types
import (
"testing"
"github.com/attic-labs/noms/Godeps/_workspace/src/github.com/stretchr/testify/assert"
"github.com/attic-labs/noms/ref"
"github.com/stretchr/testify/assert"
)
func TestType(t *testing.T) {
assert := assert.New(t)
st := NewPackage()
typ := st.Type()
typ := st.TypeRef()
name := "Package"
assert.EqualValues(name, typ.Name())
assert.Equal(StructKind, typ.Kind())
assert.Equal(TypeRefKind, typ.Kind())
assert.Equal(__typesPackageInFile_package_CachedRef, typ.PackageRef())
typ = LookupPackage(__typesPackageInFile_package_CachedRef).NamedTypes().Get(name)
desc := typ.Desc.ToValue().(Map)
fields := desc.Get(NewString("fields")).(List)
choices := desc.Get(NewString("choices")).(List)
types/write_value_test.go
+1 -1
View File
@@ -33,7 +33,7 @@ func TestWriteValue(t *testing.T) {
testEncode("j \"foo\"\n", NewString("foo"))
tref := MakePrimitiveTypeRef(StringKind)
nomsValueString := testNomsValue{Value: NewString("hi"), t: tref}
nomsValueString := valueAsNomsValue{Value: NewString("hi"), t: tref}
testEncode(fmt.Sprintf("t [%d,\"hi\"]\n", StringKind), nomsValueString)
}