mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-02-11 02:59:34 -06:00
Code Issues Packages Projects Releases 128 Wiki Activity

Remove codegen artifacts from types.

Browse Source
This commit is contained in:
Dan Willhite
2016-04-20 15:55:05 -07:00
parent 0d5b6c4223
commit bb7f039e69
11 changed files with 25 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
datas/datastore_test.go
View File

@@ -73,9 +73,10 @@ func (suite *DataStoreSuite) TestWriteRefToNonexistentValue() {
func (suite *DataStoreSuite) TestWriteWrongTypeRef() {
b := types.Bool(true)
blob := types.NewEmptyBlob()
suite.NotEqual(ref.Ref{}, suite.ds.WriteValue(b))
suite.Panics(func() { suite.ds.WriteValue(types.NewRefOfBlob(b.Ref())) })
suite.Panics(func() { suite.ds.WriteValue(types.NewTypedRef(blob.Type(), b.Ref())) })
}
func (suite *DataStoreSuite) TestWriteValueTypeRef() {
@@ -98,7 +99,7 @@ func (suite *DataStoreSuite) TestReadValueTypeRefPanics_BUG1121() {
suite.True(ok)
// Fix BUG 1121 and then uncomment this line and delete the one after
// suite.NotPanics(func() { ds2.WriteValue(types.NewRefOfBlob(b.Ref())) })
suite.Panics(func() { ds2.WriteValue(types.NewRefOfBlob(b.Ref())) })
suite.Panics(func() { ds2.WriteValue(types.NewTypedRefFromValue(b)) })
}
func (suite *DataStoreSuite) TestTolerateUngettableRefs() {

4
datas/remote_datastore_handlers_test.go
View File

@@ -33,7 +33,7 @@ func TestHandleWriteValue(t *testing.T) {
hint := l.Ref()
newItem := types.NewEmptyBlob()
itemChunk := types.EncodeValue(newItem, nil)
l2 := l.Insert(1, types.NewRefOfBlob(itemChunk.Ref()))
l2 := l.Insert(1, types.NewTypedRefFromValue(newItem))
listChunk := types.EncodeValue(l2, nil)
body := &bytes.Buffer{}
@@ -69,7 +69,7 @@ func TestHandleWriteValueBackpressure(t *testing.T) {
hint := l.Ref()
newItem := types.NewEmptyBlob()
itemChunk := types.EncodeValue(newItem, nil)
l2 := l.Insert(1, types.NewRefOfBlob(itemChunk.Ref()))
l2 := l.Insert(1, types.NewTypedRefFromValue(newItem))
listChunk := types.EncodeValue(l2, nil)
body := &bytes.Buffer{}

10
nomdl/codegen/codegen.go
View File

@@ -62,7 +62,7 @@ func main() {
pkgDS := dataset.NewDataset(ds, *pkgDSFlag)
// Ensure that, if pkgDS has stuff in it, its head is a SetOfRefOfPackage.
if h, ok := pkgDS.MaybeHead(); ok {
d.Chk.IsType(types.SetOfRefOfPackage{}, h.Value())
d.Chk.IsType(types.NewSetOfRefOfPackage(), h.Value())
}
localPkgs := refSet{}
@@ -156,18 +156,18 @@ func generateAndEmit(tag, out string, written map[string]bool, deps depsMap, p p
io.Copy(outFile, &buf)
}
func buildSetOfRefOfPackage(pkg pkg.Parsed, deps depsMap, ds dataset.Dataset) types.SetOfRefOfPackage {
func buildSetOfRefOfPackage(pkg pkg.Parsed, deps depsMap, ds dataset.Dataset) types.Set {
// Can do better once generated collections implement types.Value.
s := types.NewSetOfRefOfPackage()
if h, ok := ds.MaybeHead(); ok {
s = h.Value().(types.SetOfRefOfPackage)
s = h.Value().(types.Set)
}
for _, dep := range deps {
// Writing the deps into ds should be redundant at this point, but do it to be sure.
// TODO: consider moving all dataset work over into nomdl/pkg BUG 409
s = s.Insert(ds.Store().WriteValue(dep).(types.RefOfPackage))
s = s.Insert(ds.Store().WriteValue(dep).(types.Ref))
}
r := ds.Store().WriteValue(pkg.Package).(types.RefOfPackage)
r := ds.Store().WriteValue(pkg.Package).(types.Ref)
return s.Insert(r)
}

4
nomdl/codegen/codegen_test.go
View File

@@ -144,8 +144,8 @@ func TestCommitNewPackages(t *testing.T) {
p := parsePackageFile("name", inFile, pkgDS)
localPkgs := refSet{p.Ref(): true}
pkgDS = generate("name", inFile, filepath.Join(dir, "out.js"), dir, map[string]bool{}, p, localPkgs, pkgDS)
s := pkgDS.Head().Value().(types.SetOfRefOfPackage)
s := pkgDS.Head().Value().(types.Set)
assert.EqualValues(1, s.Len())
tr := s.First().TargetValue(ds).Types()[0]
tr := s.First().(types.Ref).TargetValue(ds).(types.Package).Types()[0]
assert.EqualValues(types.StructKind, tr.Kind())
}

62
types/blob_ref.noms.go
View File

@@ -1,62 +0,0 @@
// This file was generated by nomdl/codegen.
package types
import "github.com/attic-labs/noms/ref"
// RefOfBlob
type RefOfBlob struct {
target ref.Ref
ref *ref.Ref
}
func NewRefOfBlob(target ref.Ref) RefOfBlob {
return RefOfBlob{target, &ref.Ref{}}
}
func (r RefOfBlob) TargetRef() ref.Ref {
return r.target
}
func (r RefOfBlob) Ref() ref.Ref {
return EnsureRef(r.ref, r)
}
func (r RefOfBlob) Equals(other Value) bool {
return other != nil && __typeForRefOfBlob.Equals(other.Type()) && r.Ref() == other.Ref()
}
func (r RefOfBlob) Chunks() (chunks []RefBase) {
chunks = append(chunks, r.Type().Chunks()...)
chunks = append(chunks, r)
return
}
func (r RefOfBlob) ChildValues() []Value {
return nil
}
// A Noms Value that describes RefOfBlob.
var __typeForRefOfBlob Type
func (r RefOfBlob) Type() Type {
return __typeForRefOfBlob
}
func init() {
__typeForRefOfBlob = MakeCompoundType(RefKind, MakePrimitiveType(BlobKind))
RegisterRef(__typeForRefOfBlob, builderForRefOfBlob)
}
func builderForRefOfBlob(r ref.Ref) RefBase {
return NewRefOfBlob(r)
}
func (r RefOfBlob) TargetValue(vr ValueReader) Blob {
return vr.ReadValue(r.target).(Blob)
}
func (r RefOfBlob) SetTargetValue(val Blob, vw ValueWriter) RefOfBlob {
return vw.WriteValue(val).(RefOfBlob)
}

8
types/package.go
View File

@@ -53,12 +53,12 @@ func (p Package) ChildValues() (res []Value) {
res = append(res, t)
}
for _, d := range p.dependencies {
res = append(res, NewRefOfPackage(d))
res = append(res, NewTypedRef(p.Type(), d))
}
return
}
var typeForPackage = MakePrimitiveType(PackageKind)
var typeForPackage = PackageType
func (p Package) Type() Type {
return typeForPackage
@@ -82,3 +82,7 @@ func (p Package) Types() (types []Type) {
types = append(types, p.types...)
return
}
func NewSetOfRefOfPackage() Set {
return NewTypedSet(MakeSetType(MakeRefType(PackageType)))
}

211
types/package_set_of_ref.go
View File

@@ -1,211 +0,0 @@
// This file was generated by a slightly modified nomdl/codegen
// To generate this I added support for `Package` in the NomDL parser (Just add `Package` after `Uint32` etc)
package types
import "github.com/attic-labs/noms/ref"
// SetOfRefOfPackage
type SetOfRefOfPackage struct {
s Set
ref *ref.Ref
}
func NewSetOfRefOfPackage() SetOfRefOfPackage {
return SetOfRefOfPackage{NewTypedSet(__typeForSetOfRefOfPackage), &ref.Ref{}}
}
type SetOfRefOfPackageDef map[ref.Ref]bool
func (def SetOfRefOfPackageDef) New() SetOfRefOfPackage {
l := make([]Value, len(def))
i := 0
for d, _ := range def {
l[i] = NewRefOfPackage(d)
i++
}
return SetOfRefOfPackage{NewTypedSet(__typeForSetOfRefOfPackage, l...), &ref.Ref{}}
}
func (s SetOfRefOfPackage) Def() SetOfRefOfPackageDef {
def := make(map[ref.Ref]bool, s.Len())
s.s.Iter(func(v Value) bool {
def[v.(RefOfPackage).TargetRef()] = true
return false
})
return def
}
func (s SetOfRefOfPackage) Equals(other Value) bool {
return other != nil && __typeForSetOfRefOfPackage.Equals(other.Type()) && s.Ref() == other.Ref()
}
func (s SetOfRefOfPackage) Ref() ref.Ref {
return EnsureRef(s.ref, s)
}
func (s SetOfRefOfPackage) Chunks() (chunks []RefBase) {
chunks = append(chunks, s.Type().Chunks()...)
chunks = append(chunks, s.s.Chunks()...)
return
}
func (s SetOfRefOfPackage) ChildValues() (ret []Value) {
ret = append(ret, s.Type())
ret = append(ret, s.s.ChildValues()...)
return
}
// A Noms Value that describes SetOfRefOfPackage.
var __typeForSetOfRefOfPackage Type
func (m SetOfRefOfPackage) Type() Type {
return __typeForSetOfRefOfPackage
}
func init() {
__typeForSetOfRefOfPackage = MakeCompoundType(SetKind, MakeCompoundType(RefKind, MakePrimitiveType(PackageKind)))
RegisterValue(__typeForSetOfRefOfPackage, builderForSetOfRefOfPackage, readerForSetOfRefOfPackage)
}
func builderForSetOfRefOfPackage(v Value) Value {
return SetOfRefOfPackage{v.(Set), &ref.Ref{}}
}
func readerForSetOfRefOfPackage(v Value) Value {
return v.(SetOfRefOfPackage).s
}
func (s SetOfRefOfPackage) Empty() bool {
return s.s.Empty()
}
func (s SetOfRefOfPackage) Len() uint64 {
return s.s.Len()
}
func (s SetOfRefOfPackage) Has(p RefOfPackage) bool {
return s.s.Has(p)
}
type SetOfRefOfPackageIterCallback func(p RefOfPackage) (stop bool)
func (s SetOfRefOfPackage) Iter(cb SetOfRefOfPackageIterCallback) {
s.s.Iter(func(v Value) bool {
return cb(v.(RefOfPackage))
})
}
type SetOfRefOfPackageIterAllCallback func(p RefOfPackage)
func (s SetOfRefOfPackage) IterAll(cb SetOfRefOfPackageIterAllCallback) {
s.s.IterAll(func(v Value) {
cb(v.(RefOfPackage))
})
}
type SetOfRefOfPackageFilterCallback func(p RefOfPackage) (keep bool)
func (s SetOfRefOfPackage) Filter(cb SetOfRefOfPackageFilterCallback) SetOfRefOfPackage {
ns := NewSetOfRefOfPackage()
s.IterAll(func(v RefOfPackage) {
if cb(v) {
ns = ns.Insert(v)
}
})
return ns
}
func (s SetOfRefOfPackage) Insert(p ...RefOfPackage) SetOfRefOfPackage {
return SetOfRefOfPackage{s.s.Insert(s.fromElemSlice(p)...), &ref.Ref{}}
}
func (s SetOfRefOfPackage) Remove(p ...RefOfPackage) SetOfRefOfPackage {
return SetOfRefOfPackage{s.s.Remove(s.fromElemSlice(p)...), &ref.Ref{}}
}
func (s SetOfRefOfPackage) Union(others ...SetOfRefOfPackage) SetOfRefOfPackage {
return SetOfRefOfPackage{s.s.Union(s.fromStructSlice(others)...), &ref.Ref{}}
}
func (s SetOfRefOfPackage) First() RefOfPackage {
return s.s.First().(RefOfPackage)
}
func (s SetOfRefOfPackage) fromStructSlice(p []SetOfRefOfPackage) []Set {
r := make([]Set, len(p))
for i, v := range p {
r[i] = v.s
}
return r
}
func (s SetOfRefOfPackage) fromElemSlice(p []RefOfPackage) []Value {
r := make([]Value, len(p))
for i, v := range p {
r[i] = v
}
return r
}
// RefOfPackage
type RefOfPackage struct {
target ref.Ref
ref *ref.Ref
}
func NewRefOfPackage(target ref.Ref) RefOfPackage {
return RefOfPackage{target, &ref.Ref{}}
}
func (r RefOfPackage) TargetRef() ref.Ref {
return r.target
}
func (r RefOfPackage) Ref() ref.Ref {
return EnsureRef(r.ref, r)
}
func (r RefOfPackage) Equals(other Value) bool {
return other != nil && __typeForRefOfPackage.Equals(other.Type()) && r.Ref() == other.Ref()
}
func (r RefOfPackage) Chunks() (chunks []RefBase) {
chunks = append(chunks, r.Type().Chunks()...)
chunks = append(chunks, r)
return
}
func (r RefOfPackage) ChildValues() []Value {
return nil
}
// A Noms Value that describes RefOfPackage.
var __typeForRefOfPackage Type
func (m RefOfPackage) Type() Type {
return __typeForRefOfPackage
}
func (r RefOfPackage) Less(other OrderedValue) bool {
return r.TargetRef().Less(other.(RefBase).TargetRef())
}
func init() {
__typeForRefOfPackage = MakeCompoundType(RefKind, MakePrimitiveType(PackageKind))
RegisterRef(__typeForRefOfPackage, builderForRefOfPackage)
}
func builderForRefOfPackage(r ref.Ref) RefBase {
return NewRefOfPackage(r)
}
func (r RefOfPackage) TargetValue(vr ValueReader) Package {
return vr.ReadValue(r.target).(Package)
}
func (r RefOfPackage) SetTargetValue(val Package, vw ValueWriter) RefOfPackage {
return vw.WriteValue(val).(RefOfPackage)
}

1
types/package_set_of_ref.noms
View File

@@ -1 +0,0 @@
using Set<Ref<Package>>

3
types/type.go
View File

@@ -125,7 +125,7 @@ func (t Type) Chunks() (chunks []RefBase) {
func (t Type) ChildValues() (res []Value) {
if t.HasPackageRef() {
res = append(res, NewRefOfPackage(t.PackageRef()))
res = append(res, NewTypedRef(MakeRefType(PackageType), t.PackageRef()))
}
if !t.IsUnresolved() {
switch desc := t.Desc.(type) {
@@ -235,3 +235,4 @@ var Float64Type = MakePrimitiveType(Float64Kind)
var BoolType = MakePrimitiveType(BoolKind)
var StringType = MakePrimitiveType(StringKind)
var BlobType = MakePrimitiveType(BlobKind)
var PackageType = MakePrimitiveType(PackageKind)

2
types/value_store.go
View File

@@ -95,7 +95,7 @@ func (lvs *ValueStore) cacheChunks(v Value, r ref.Ref) {
if cur := lvs.check(hash); cur == nil || cur.Hint().IsEmpty() || cur.Hint() == hash {
lvs.set(hash, hintedChunk{getTargetType(reachable), r})
// Code-genned Packages are side-loaded when reading Values for performance reasons. This means that they won't pass through the ReadValue() codepath above, which means that they won't have their Chunks added to the cache. So, if reachable is a RefOfPackage, go look the package up in the PackageRegistry and recursively add its Chunks to the cache.
if _, ok := reachable.(RefOfPackage); ok {
if _, ok := reachable.(Ref); ok {
if p := LookupPackage(hash); p != nil {
lvs.cacheChunks(p, hash)
}

8
types/value_store_test.go
View File

@@ -119,7 +119,7 @@ func TestCheckChunksInCache(t *testing.T) {
cs.Put(EncodeValue(b, nil))
cvs.set(b.Ref(), presentChunk(b.Type()))
bref := NewRefOfBlob(b.Ref())
bref := NewTypedRefFromValue(b)
assert.NotPanics(func() { cvs.checkChunksInCache(bref) })
}
@@ -129,7 +129,7 @@ func TestCacheOnReadValue(t *testing.T) {
cvs := newLocalValueStore(cs)
b := NewEmptyBlob()
bref := cvs.WriteValue(b).(RefOfBlob)
bref := cvs.WriteValue(b).(Ref)
r := cvs.WriteValue(bref)
cvs2 := newLocalValueStore(cs)
@@ -146,7 +146,7 @@ func TestHintsOnCache(t *testing.T) {
bs := []Blob{NewEmptyBlob(), NewBlob(bytes.NewBufferString("f"))}
l := NewList()
for _, b := range bs {
bref := cvs.WriteValue(b).(RefOfBlob)
bref := cvs.WriteValue(b).(Ref)
l = l.Append(bref)
}
r := cvs.WriteValue(l)
@@ -154,7 +154,7 @@ func TestHintsOnCache(t *testing.T) {
v := cvs.ReadValue(r.TargetRef())
if assert.True(l.Equals(v)) {
l = v.(List)
bref := cvs.WriteValue(NewBlob(bytes.NewBufferString("g"))).(RefOfBlob)
bref := cvs.WriteValue(NewBlob(bytes.NewBufferString("g"))).(Ref)
l = l.Insert(0, bref)
hints := cvs.checkChunksInCache(l)