// Summary prints a summary of the diff between two values to stdout.
func Summary(value1, value2 types.Value) {
if datas.IsCommitType(value1.Type()) && datas.IsCommitType(value2.Type()) {
fmt.Println("Comparing commit values")
value1 = value1.(types.Struct).Get(datas.ValueField)
value2 = value2.(types.Struct).Get(datas.ValueField)
}
var singular, plural string
if value1.Type().Kind() == value2.Type().Kind() {
switch value1.Type().Kind() {
case types.StructKind:
singular = "field"
plural = "fields"
case types.MapKind:
singular = "entry"
plural = "entries"
default:
singular = "value"
plural = "values"
}
}
// waitChan := make(chan struct{})
ch := make(chan diffSummaryProgress)
go func() {
diffSummary(ch, value1, value2)
close(ch)
}()
acc := diffSummaryProgress{}
for p := range ch {
acc.Adds += p.Adds
acc.Removes += p.Removes
acc.Changes += p.Changes
acc.NewSize += p.NewSize
acc.OldSize += p.OldSize
if status.WillPrint() {
formatStatus(acc, singular, plural)
}
}
formatStatus(acc, singular, plural)
status.Done()
}
func (ds *Dataset) validateRefAsCommit(r types.Ref) types.Struct {
v := ds.store.ReadValue(r.TargetHash())
if v == nil {
panic(r.TargetHash().String() + " not found")
}
if !datas.IsCommitType(v.Type()) {
panic("Not a commit: " + types.EncodedValue(v))
}
return v.(types.Struct)
}
func runLog(args []string) int {
useColor = shouldUseColor()
database, value, err := spec.GetPath(args[0])
if err != nil {
d.CheckErrorNoUsage(err)
}
defer database.Close()
if value == nil {
d.CheckErrorNoUsage(fmt.Errorf("Object not found: %s", args[0]))
}
origCommit, ok := value.(types.Struct)
if !ok || !datas.IsCommitType(origCommit.Type()) {
d.CheckError(fmt.Errorf("%s does not reference a Commit object", args[0]))
}
iter := NewCommitIterator(database, origCommit)
displayed := 0
if maxCommits <= 0 {
maxCommits = math.MaxInt32
}
inChan := make(chan interface{}, parallelism)
outChan := orderedparallel.New(inChan, func(node interface{}) interface{} {
buff := &bytes.Buffer{}
printCommit(node.(LogNode), buff, database)
return buff.Bytes()
}, parallelism)
go func() {
for ln, ok := iter.Next(); ok && displayed < maxCommits; ln, ok = iter.Next() {
inChan <- ln
displayed++
}
close(inChan)
}()
pgr := outputpager.Start()
defer pgr.Stop()
for commitBuff := range outChan {
io.Copy(pgr.Writer, bytes.NewReader(commitBuff.([]byte)))
}
return 0
}
