func makeCommitType(valueType *types.Type, parentsValueTypes []*types.Type, metaType *types.Type, parentsMetaTypes []*types.Type) *types.Type {
tmp := make([]*types.Type, len(parentsValueTypes), len(parentsValueTypes)+1)
copy(tmp, parentsValueTypes)
tmp = append(tmp, valueType)
parentsValueUnionType := types.MakeUnionType(tmp...)
tmp2 := make([]*types.Type, len(parentsMetaTypes), len(parentsMetaTypes)+1)
copy(tmp2, parentsMetaTypes)
tmp2 = append(tmp2, metaType)
parentsMetaUnionType := types.MakeUnionType(tmp2...)
fieldNames := []string{MetaField, ParentsField, ValueField}
var parentsType *types.Type
if parentsValueUnionType.Equals(valueType) && parentsMetaUnionType.Equals(metaType) {
parentsType = types.MakeSetType(types.MakeRefType(types.MakeCycleType(0)))
} else {
parentsType = types.MakeSetType(types.MakeRefType(
types.MakeStructType("Commit", fieldNames, []*types.Type{
parentsMetaUnionType,
types.MakeSetType(types.MakeRefType(types.MakeCycleType(0))),
parentsValueUnionType,
})))
}
fieldTypes := []*types.Type{
metaType,
parentsType,
valueType,
}
return types.MakeStructType("Commit", fieldNames, fieldTypes)
}
func TestReadToMap(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.NumberKind, types.BoolKind}
m := ReadToMap(r, headers, 0, kinds, ds)
assert.Equal(uint64(2), m.Len())
assert.True(m.Type().Equals(
types.MakeMapType(types.StringType, types.MakeStructType("", map[string]*types.Type{
"B": types.NumberType,
"C": types.BoolType,
}))))
assert.True(m.Get(types.String("a")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(1),
"C": types.Bool(true),
})))
assert.True(m.Get(types.String("b")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(2),
"C": types.Bool(false),
})))
}
func (suite *ParsedResultTestSuite) TestCommentNextToName() {
n := "WithComment"
s := fmt.Sprintf("struct %s { /* Oy! */%s }", n, suite.prim2)
suite.assertTypes(s, types.MakeStructType(n, types.TypeMap{
suite.prim2.Name: suite.prim2.Type,
}))
}
func (suite *ParsedResultTestSuite) TestCommentAmongFields() {
n := "WithComment"
s := fmt.Sprintf("struct %s { %s \n// Nope\n%s }", n, suite.prim, suite.prim2)
suite.assertTypes(s, types.MakeStructType(n, types.TypeMap{
suite.prim.Name: suite.prim.Type,
suite.prim2.Name: suite.prim2.Type,
}))
}
// FIXME: run with pipe
func (s *testSuite) TestCSVExporter() {
setName := "csv"
header := []string{"a", "b", "c"}
payload := [][]string{
[]string{"5", "7", "100"},
[]string{"4", "10", "255"},
[]string{"512", "12", "55"},
}
structName := "SomeStruct"
// Setup data store
cs := chunks.NewLevelDBStore(s.LdbDir, "", 1, false)
ds := dataset.NewDataset(datas.NewDatabase(cs), setName)
// Build Struct fields based on header
f := make(types.TypeMap, len(header))
for _, key := range header {
f[key] = types.StringType
}
typ := types.MakeStructType(structName, f)
// Build data rows
structs := make([]types.Value, len(payload))
for i, row := range payload {
fields := make(map[string]types.Value)
for j, v := range row {
name := header[j]
fields[name] = types.String(v)
}
structs[i] = types.NewStructWithType(typ, fields)
}
ds.Commit(types.NewList(structs...))
ds.Database().Close()
// Run exporter
dataspec := test_util.CreateValueSpecString("ldb", s.LdbDir, setName)
out := s.Run(main, []string{dataspec})
// Verify output
csvReader := csv.NewReader(strings.NewReader(out))
row, err := csvReader.Read()
d.Chk.NoError(err)
s.Equal(header, row)
for i := 0; i < len(payload); i++ {
row, err := csvReader.Read()
d.Chk.NoError(err)
s.Equal(payload[i], row)
}
_, err = csvReader.Read()
s.Equal(io.EOF, err)
}
func init() {
inodeType = types.MakeStructType("Inode", []string{"attr", "contents"}, []*types.Type{
types.MakeStructType("Attr", []string{"ctime", "gid", "mode", "mtime", "uid", "xattr"}, []*types.Type{types.NumberType, types.NumberType, types.NumberType, types.NumberType, types.NumberType, types.MakeMapType(types.StringType, types.BlobType)}),
types.MakeUnionType(types.MakeStructType("Directory", []string{"entries"}, []*types.Type{
types.MakeMapType(types.StringType, types.MakeCycleType(1))}),
types.MakeStructType("File", []string{"data"}, []*types.Type{types.MakeRefType(types.BlobType)}),
types.MakeStructType("Symlink", []string{"targetPath"}, []*types.Type{types.StringType}),
),
})
// Root around for some useful types.
attrType = inodeType.Desc.(types.StructDesc).Field("attr")
for _, elemType := range inodeType.Desc.(types.StructDesc).Field("contents").Desc.(types.CompoundDesc).ElemTypes {
switch elemType.Desc.(types.StructDesc).Name {
case "Directory":
directoryType = elemType
case "File":
fileType = elemType
case "Symlink":
symlinkType = elemType
}
}
fsType = types.MakeStructType("Filesystem", []string{"root"}, []*types.Type{inodeType})
}
func (suite *ParsedResultTestSuite) parseAndCheckStructs(structs ...structTestCase) {
source := ""
expectedTypes := make([]*types.Type, len(structs))
for i, s := range structs {
source += s.String() + "\n"
fields := make(types.TypeMap, len(s.Fields))
for _, f := range s.Fields {
fields[f.Name] = f.Type
}
expectedTypes[i] = types.MakeStructType(s.Name, fields)
}
suite.assertTypes(source, expectedTypes...)
}
// MakeStructTypeFromHeaders creates a struct type from the headers using |kinds| as the type of each field. If |kinds| is empty, default to strings.
func MakeStructTypeFromHeaders(headers []string, structName string, kinds KindSlice) *types.Type {
useStringType := len(kinds) == 0
d.Chk.True(useStringType || len(headers) == len(kinds))
fields := make(types.TypeMap, len(headers))
for i, key := range headers {
kind := types.StringKind
if !useStringType {
kind = kinds[i]
}
_, ok := fields[key]
d.Exp.False(ok, `Duplicate field name "%s"`, key)
fields[key] = types.MakePrimitiveType(kind)
}
return types.MakeStructType(structName, fields)
}
func init() {
structName := "Commit"
// struct Commit {
// parents: Set<Ref<Commit>>
// value: Value
// }
fieldTypes := types.TypeMap{
ParentsField: nil,
ValueField: types.ValueType,
}
commitType = types.MakeStructType(structName, fieldTypes)
commitType.Desc.(types.StructDesc).SetField(ParentsField, types.MakeSetType(types.MakeRefType(commitType)))
refOfCommitType = types.MakeRefType(commitType)
}
func TestNewCommit(t *testing.T) {
assert := assert.New(t)
commitFieldNames := []string{MetaField, ParentsField, ValueField}
assertTypeEquals := func(e, a *types.Type) {
assert.True(a.Equals(e), "Actual: %s\nExpected %s", a.Describe(), e.Describe())
}
commit := NewCommit(types.Number(1), types.NewSet(), types.EmptyStruct)
at := commit.Type()
et := types.MakeStructType("Commit", commitFieldNames, []*types.Type{
types.EmptyStructType,
types.MakeSetType(types.MakeRefType(types.MakeCycleType(0))),
types.NumberType,
})
assertTypeEquals(et, at)
// Commiting another Number
commit2 := NewCommit(types.Number(2), types.NewSet(types.NewRef(commit)), types.EmptyStruct)
at2 := commit2.Type()
et2 := et
assertTypeEquals(et2, at2)
// Now commit a String
commit3 := NewCommit(types.String("Hi"), types.NewSet(types.NewRef(commit2)), types.EmptyStruct)
at3 := commit3.Type()
et3 := types.MakeStructType("Commit", commitFieldNames, []*types.Type{
types.EmptyStructType,
types.MakeSetType(types.MakeRefType(types.MakeStructType("Commit", commitFieldNames, []*types.Type{
types.EmptyStructType,
types.MakeSetType(types.MakeRefType(types.MakeCycleType(0))),
types.MakeUnionType(types.NumberType, types.StringType),
}))),
types.StringType,
})
assertTypeEquals(et3, at3)
// Now commit a String with MetaInfo
meta := types.NewStruct("Meta", types.StructData{"date": types.String("some date"), "number": types.Number(9)})
metaType := types.MakeStructType("Meta", []string{"date", "number"}, []*types.Type{types.StringType, types.NumberType})
assertTypeEquals(metaType, meta.Type())
commit4 := NewCommit(types.String("Hi"), types.NewSet(types.NewRef(commit2)), meta)
at4 := commit4.Type()
et4 := types.MakeStructType("Commit", commitFieldNames, []*types.Type{
metaType,
types.MakeSetType(types.MakeRefType(types.MakeStructType("Commit", commitFieldNames, []*types.Type{
types.MakeUnionType(types.EmptyStructType, metaType),
types.MakeSetType(types.MakeRefType(types.MakeCycleType(0))),
types.MakeUnionType(types.NumberType, types.StringType),
}))),
types.StringType,
})
assertTypeEquals(et4, at4)
}
func (c *current) onStruct1(i, l interface{}) (interface{}, error) {
ll := l.([]interface{})
fields := make(types.TypeMap, len(ll))
for _, e := range ll {
switch e := e.(type) {
case Field:
if fields[e.Name] != nil {
return nil, fmt.Errorf("Redefinition of field %s in struct %s", e.Name, i.(string))
}
fields[e.Name] = e.Type
default:
return nil, fmt.Errorf("Structs must be made up of field declarations.")
}
}
return types.MakeStructType(i.(string), fields), nil
}
// resolveReferences replaces references with the actual Type
func resolveReferences(i *intermediate, aliases map[string][]*types.Type) {
var rec func(t *types.Type) *types.Type
resolveFields := func(desc types.StructDesc) *types.Type {
fields := make(types.TypeMap, desc.Len())
desc.IterFields(func(name string, t *types.Type) {
fields[name] = rec(t)
})
return types.MakeStructType(desc.Name, fields)
}
rec = func(t *types.Type) *types.Type {
switch t.Kind() {
case UnresolvedKind:
desc := t.Desc.(UnresolvedDesc)
if desc.Namespace == "" {
return findType(desc.Name, i.Types)
}
ts, ok := aliases[desc.Namespace]
d.Exp.True(ok, "No such namespace: %s", desc.Namespace)
return findType(desc.Name, ts)
case types.ListKind:
return types.MakeListType(rec(t.Desc.(types.CompoundDesc).ElemTypes[0]))
case types.SetKind:
return types.MakeSetType(rec(t.Desc.(types.CompoundDesc).ElemTypes[0]))
case types.RefKind:
return types.MakeRefType(rec(t.Desc.(types.CompoundDesc).ElemTypes[0]))
case types.MapKind:
elemTypes := t.Desc.(types.CompoundDesc).ElemTypes
return types.MakeMapType(rec(elemTypes[0]), rec(elemTypes[1]))
case types.StructKind:
return resolveFields(t.Desc.(types.StructDesc))
}
return t
}
for idx, t := range i.Types {
i.Types[idx] = rec(t)
}
}
func (s *testSuite) Teardown() {
out := s.NodeOutput()
s.Contains(out, "1 of 1 entries")
s.Contains(out, "done")
db := s.Database()
defer db.Close()
ds := dataset.NewDataset(db, dsName)
v := ds.HeadValue()
s.True(v.Type().Equals(types.MakeStructType("File",
[]string{"content"},
[]*types.Type{
types.MakeRefType(types.BlobType),
},
)))
s.Equal("File", v.(types.Struct).Type().Desc.(types.StructDesc).Name)
b := v.(types.Struct).Get("content").(types.Ref).TargetValue(db).(types.Blob)
bs, err := ioutil.ReadAll(b.Reader())
s.NoError(err)
s.Equal([]byte("Hello World!\n"), bs)
}
// MakeStructTypeFromHeaders creates a struct type from the headers using |kinds| as the type of each field. If |kinds| is empty, default to strings.
func MakeStructTypeFromHeaders(headers []string, structName string, kinds KindSlice) (typ *types.Type, fieldOrder []int, kindMap []types.NomsKind) {
useStringType := len(kinds) == 0
d.Chk.True(useStringType || len(headers) == len(kinds))
fieldMap := make(types.TypeMap, len(headers))
origOrder := make(map[string]int, len(headers))
fieldNames := make(sort.StringSlice, len(headers))
for i, key := range headers {
fn := types.EscapeStructField(key)
origOrder[fn] = i
kind := types.StringKind
if !useStringType {
kind = kinds[i]
}
_, ok := fieldMap[fn]
d.PanicIfTrue(ok, `Duplicate field name "%s"`, key)
fieldMap[fn] = types.MakePrimitiveType(kind)
fieldNames[i] = fn
}
sort.Sort(fieldNames)
kindMap = make([]types.NomsKind, len(fieldMap))
fieldOrder = make([]int, len(fieldMap))
fieldTypes := make([]*types.Type, len(fieldMap))
for i, fn := range fieldNames {
typ := fieldMap[fn]
fieldTypes[i] = typ
kindMap[i] = typ.Kind()
fieldOrder[origOrder[fn]] = i
}
typ = types.MakeStructType(structName, fieldNames, fieldTypes)
return
}
}
return buff.Bytes()
}
func createString(i uint64) types.Value {
return types.String(fmt.Sprintf("%s%d", strPrefix, i))
}
func createNumber(i uint64) types.Value {
return types.Number(i)
}
var structType = types.MakeStructType("S1",
[]string{"bool", "num", "str"},
[]*types.Type{
types.BoolType,
types.NumberType,
types.StringType,
})
func createStruct(i uint64) types.Value {
return types.NewStructWithType(structType, types.ValueSlice{
types.Bool(i%2 == 0),
types.Number(i),
types.String(fmt.Sprintf("i am a 55 bytes............................%12d", i)),
})
}
func buildList(count uint64, createFn createValueFn) types.Collection {
values := make([]types.Value, count)
for i := uint64(0); i < count; i++ {
counter++
}
return buff.Bytes()
}
func createString(i uint64) types.Value {
return types.String(fmt.Sprintf("%s%d", strPrefix, i))
}
func createNumber(i uint64) types.Value {
return types.Number(i)
}
var structType = types.MakeStructType("S1", map[string]*types.Type{
"str": types.StringType,
"num": types.NumberType,
"bool": types.BoolType,
})
func createStruct(i uint64) types.Value {
return types.NewStructWithType(structType, map[string]types.Value{
"str": types.String(fmt.Sprintf("i am a 55 bytes............................%12d", i)),
"num": types.Number(i),
"bool": types.Bool(i%2 == 0),
})
}
func buildList(count uint64, createFn createValueFn) types.Collection {
values := make([]types.Value, count)
for i := uint64(0); i < count; i++ {
values[i] = createFn(i)