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)