WIP on POC

Author: TheGrizzlyDev

Diff for: .gitignore

@@ -0,0 +1,2 @@
+.local
+

Diff for: .vscode/settings.json

@@ -0,0 +1,24 @@
+{
+    "editor.tokenColorCustomizations": {
+        "textMateRules": [
+            {
+                "scope": "googletest.failed",
+                "settings": {
+                    "foreground": "#f00"
+                }
+            },
+            {
+                "scope": "googletest.passed",
+                "settings": {
+                    "foreground": "#0f0"
+                }
+            },
+            {
+                "scope": "googletest.run",
+                "settings": {
+                    "foreground": "#0f0"
+                }
+            }
+        ]
+    }
+}

Diff for: bisect/bisect.go

@@ -0,0 +1,62 @@
+package bisect
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+type BisectOpts struct {
+	Jobs int
+	Good string
+	Bad  string
+	Cmd  []string
+}
+
+type bisect struct {
+	jobs   int
+	good   string
+	bad    string
+	cmd    []string
+	runner Runner
+}
+
+func NewBisect(opts BisectOpts) *bisect {
+	runner := NewLocalRunner()
+	return &bisect{
+		jobs:   opts.Jobs,
+		good:   opts.Good,
+		bad:    opts.Bad,
+		runner: runner,
+	}
+}
+
+func (b bisect) Run(ctx context.Context) error {
+	var gitLogOut bytes.Buffer
+	gitLog := exec.CommandContext(ctx, "git", "log", "--format=%h", "--ancestry-path", fmt.Sprintf("%s~1..%s", b.good, b.bad))
+	gitLog.Stdout = &gitLogOut
+	if err := gitLog.Run(); err != nil {
+		return fmt.Errorf("could not get the list of revisions: %v", err)
+	}
+
+	revisions := strings.Split(gitLogOut.String(), "\n")
+	runState := b.runner.Run(ctx, revisions, b.cmd)
+
+	for {
+		select {
+		case wip := <-runState.wip:
+			fmt.Printf("WIP (%d): %s\n", len(wip), wip)
+		case left := <-runState.left:
+			fmt.Printf("Left (%d): %s\n", len(left), left)
+		case err := <-runState.err:
+			return err
+		case found := <-runState.done:
+			fmt.Println("Found revision: ", found)
+			return nil
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}

Diff for: bisect/bisect_state.go

@@ -0,0 +1,146 @@
+package bisect
+
+import (
+	"fmt"
+	"math/rand"
+	"sync"
+)
+
+type smartRev struct {
+	Rev    string
+	Cancel chan interface{}
+	state  *BisectState
+}
+
+func (s *smartRev) Good() {
+	s.state.markAsGood(s.Rev)
+}
+
+func (s *smartRev) Bad() {
+	s.state.markAsBad(s.Rev)
+}
+
+type BisectState struct {
+	revs []string // immutable
+
+	indexes   map[string]int // written once but it's async
+	indexesMu sync.RWMutex
+
+	start   int
+	startMu sync.RWMutex
+
+	end   int
+	endMu sync.RWMutex
+
+	// bisect tracker
+	bisectSteps     []int
+	bisectIteration int
+	bisectMu        sync.Mutex
+
+	activeListenersMu sync.Mutex
+	activeListeners   []*smartRev
+}
+
+func NewBisectState(revs []string) *BisectState {
+	state := &BisectState{
+		revs:        revs,
+		end:         len(revs) - 1,
+		indexes:     make(map[string]int),
+		bisectSteps: make([]int, len(revs)),
+	}
+
+	state.initIndexesTable()
+	state.initBisectSteps()
+
+	return state
+}
+
+func (b *BisectState) initIndexesTable() {
+	for i, rev := range b.revs {
+		b.indexes[rev] = i
+	}
+}
+
+func (b *BisectState) initBisectSteps() {
+	for i := range b.bisectSteps {
+		b.bisectSteps[i] = i
+	}
+
+	rand.Seed(1)
+	rand.Shuffle(len(b.bisectSteps), func(i, j int) {
+		b.bisectSteps[i], b.bisectSteps[j] = b.bisectSteps[j], b.bisectSteps[i]
+	})
+}
+
+func (b *BisectState) Next() *smartRev {
+	b.bisectMu.Lock()
+	defer b.bisectMu.Unlock()
+	for ; b.bisectIteration < len(b.bisectSteps); b.bisectIteration++ {
+		step := b.bisectSteps[b.bisectIteration]
+		if step >= b.start && step <= b.end {
+			// TODO implement ref cancellation
+			rev := b.revs[step]
+			b.bisectIteration++
+			return &smartRev{
+				Rev:    rev,
+				Cancel: make(chan interface{}),
+				state:  b,
+			}
+		}
+	}
+	return nil
+}
+
+func (b *BisectState) getIndex(rev string) int {
+	b.indexesMu.RLock()
+	defer b.indexesMu.RUnlock()
+	return b.indexes[rev]
+}
+
+func (b *BisectState) markAsGood(rev string) error {
+	i := b.getIndex(rev)
+
+	if i <= b.start {
+		return nil
+	}
+
+	if i >= b.end {
+		return fmt.Errorf("TODO(come up with an error msg)")
+	}
+
+	b.startMu.Lock()
+	defer b.startMu.Unlock()
+	b.start = i
+	return nil
+}
+
+func (b *BisectState) markAsBad(rev string) error {
+	i := b.getIndex(rev)
+
+	if i >= b.end {
+		return nil
+	}
+
+	if i <= b.start {
+		return fmt.Errorf("TODO(come up with an error msg)")
+	}
+
+	b.endMu.Lock()
+	defer b.endMu.Unlock()
+	b.end = i
+	return nil
+}
+
+func (b *BisectState) FirstBadRev() *string {
+	b.startMu.RLock()
+	defer b.startMu.RUnlock()
+
+	b.endMu.RLock()
+	defer b.endMu.RUnlock()
+
+	if b.end-b.start == 1 {
+		return &b.revs[b.end]
+	}
+
+	return nil
+}

Diff for: bisect/bisect_state_test.go

@@ -0,0 +1,26 @@
+package bisect
+
+import (
+	"testing"
+)
+
+func TestNextReturnsNilWhenDone(t *testing.T) {
+	revs := []string{
+		"ebaf211260",
+		"1c05d39abc",
+		"416b0374fb",
+	}
+	target := NewBisectState(revs)
+
+	for i := 0; i < len(revs); i++ {
+		nextRev := target.Next()
+
+		if nextRev == nil {
+			t.Fatal("expected a revision but instead got nil")
+		}
+	}
+
+	if target.Next() != nil {
+		t.Fatal("unexpected revision after extracting all of the revs")
+	}
+}

Diff for: bisect/local_runner.go

@@ -0,0 +1,82 @@
+package bisect
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+type LocalRunner struct {
+	mu      sync.RWMutex
+	left    []string
+	wip     []string
+	lastBad string
+	cmd     []string
+}
+
+func NewLocalRunner() *LocalRunner {
+	return &LocalRunner{}
+}
+
+func (l *LocalRunner) Run(ctx context.Context, revs []string, cmd []string) *RunnerState {
+	state := NewStartedRunnerState(revs)
+	l.cmd = cmd
+	l.left = revs
+	l.lastBad = revs[len(revs)-1]
+	l.wip = []string{}
+	go func() {
+		l.start(ctx, state)
+	}()
+	go func() {
+		ticker := time.NewTicker(time.Second / 24)
+		for _ = range ticker.C {
+			l.updateState(state)
+		}
+	}()
+	return state
+}
+
+func (l *LocalRunner) updateState(state *RunnerState) {
+	if len(l.left) == 0 && len(l.wip) == 0 {
+		state.done <- l.lastBad
+		return
+	}
+	state.left <- l.left
+	state.wip <- l.wip
+}
+
+func (l *LocalRunner) bad(ctx context.Context, rev string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	// TODO figure out how to mark a bad hit
+	l.lastBad = rev
+}
+
+func (l *LocalRunner) good(ctx context.Context, rev string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	// TODO figure out how to mark a good hit
+}
+
+func (l *LocalRunner) markWip(ctx context.Context, rev string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.wip = append(l.wip, rev)
+}
+
+func (l *LocalRunner) start(ctx context.Context, state *RunnerState) {
+	// exec.CommandContext(ctx, "TODO", "TODO")
+
+	for i := len(l.left) - 1; i >= 0; i-- {
+		l.mu.RLock()
+		rev := l.left[i]
+		l.mu.RUnlock()
+		l.markWip(ctx, rev)
+		if i > 5 {
+			l.bad(ctx, rev)
+		} else {
+			l.good(ctx, rev)
+		}
+		_ = <-time.NewTimer(time.Second).C
+	}
+}

Diff for: bisect/runner.go

@@ -0,0 +1,34 @@
+package bisect
+
+import "context"
+
+type RunnerState struct {
+	left chan []string
+	wip  chan []string
+	err  chan error
+	done chan string
+}
+
+func NewStartedRunnerState(revs []string) *RunnerState {
+	left := make(chan []string)
+	wip := make(chan []string)
+	err := make(chan error)
+	done := make(chan string)
+	defer func() {
+		go func() {
+			left <- revs
+			wip <- []string{}
+		}()
+	}()
+
+	return &RunnerState{
+		left: left,
+		wip:  wip,
+		err:  err,
+		done: done,
+	}
+}
+
+type Runner interface {
+	Run(ctx context.Context, revs []string, cmd []string) *RunnerState
+}

Diff for: go.mod

@@ -0,0 +1,3 @@
+module github.com/TheGrizzlyDev/git-analyse
+
+go 1.16