Rename RowRepoIterImplementation

Signed-off-by: Javi Fontan <[email protected]>

Author: jfontan

blobs.go

@@ -40,12 +40,12 @@ func (r *blobsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expressio
 func (r blobsTable) RowIter() (sql.RowIter, error) {
 	iter := &blobIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (blobsTable) Children() []sql.Node {
@@ -56,9 +56,7 @@ type blobIter struct {
 	iter *object.BlobIter
 }
 
-func (i *blobIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *blobIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.BlobObjects()
 	if err != nil {
 		return nil, err

commits.go

@@ -46,12 +46,12 @@ func (r *commitsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 func (r commitsTable) RowIter() (sql.RowIter, error) {
 	iter := &commitIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (commitsTable) Children() []sql.Node {
@@ -62,9 +62,7 @@ type commitIter struct {
 	iter object.CommitIter
 }
 
-func (i *commitIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *commitIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.CommitObjects()
 	if err != nil {
 		return nil, err

objects.go

@@ -40,12 +40,12 @@ func (r *objectsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 func (r objectsTable) RowIter() (sql.RowIter, error) {
 	iter := &objectIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (objectsTable) Children() []sql.Node {
@@ -56,9 +56,7 @@ type objectIter struct {
 	iter *object.ObjectIter
 }
 
-func (i *objectIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *objectIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.Objects()
 	if err != nil {
 		return nil, err

references.go

@@ -47,12 +47,12 @@ func (r *referencesTable) TransformExpressionsUp(f func(sql.Expression) sql.Expr
 func (r referencesTable) RowIter() (sql.RowIter, error) {
 	iter := &referenceIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (referencesTable) Children() []sql.Node {
@@ -63,9 +63,7 @@ type referenceIter struct {
 	iter storer.ReferenceIter
 }
 
-func (i *referenceIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *referenceIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.References()
 	if err != nil {
 		return nil, err

repository_pool.go

@@ -97,19 +97,19 @@ func (i *RepositoryIter) Close() error {
 	return nil
 }
 
-// RowRepoIterImplementation is the interface needed by each iterator
+// RowRepoIter is the interface needed by each iterator
 // implementation
-type RowRepoIterImplementation interface {
-	NewIterator(*Repository) (RowRepoIterImplementation, error)
+type RowRepoIter interface {
+	NewIterator(*Repository) (RowRepoIter, error)
 	Next() (sql.Row, error)
 	Close() error
 }
 
 // RowRepoIter is used as the base to iterate over all the repositories
 // in the pool
-type RowRepoIter struct {
+type rowRepoIter struct {
 	repositoryIter *RepositoryIter
-	implementation RowRepoIterImplementation
+	iter           RowRepoIter
 
 	wg    sync.WaitGroup
 	done  chan bool
@@ -121,47 +121,49 @@ type RowRepoIter struct {
 // NewRowRepoIter initializes a new repository iterator.
 //
 // * pool: is a RepositoryPool we want to iterate
-// * impl: implementation with RowRepoIterImplementation interface
+// * iter: specific RowRepoIter interface
 //     * NewIterator: called when a new repository is about to be iterated,
-//         returns a new RowRepoIterImplementation
+//         returns a new RowRepoIter
 //     * Next: called for each row
 //     * Close: called when a repository finished iterating
-func NewRowRepoIter(pool *RepositoryPool,
-	impl RowRepoIterImplementation) (*RowRepoIter, error) {
+func NewRowRepoIter(
+	pool *RepositoryPool,
+	iter RowRepoIter,
+) (*rowRepoIter, error) {
 
 	rIter, err := pool.RepoIter()
 	if err != nil {
 		return nil, err
 	}
 
-	rowRepoIter := RowRepoIter{
+	repoIter := rowRepoIter{
 		repositoryIter: rIter,
-		implementation: impl,
+		iter:           iter,
 		done:           make(chan bool),
 		err:            make(chan error),
 		repos:          make(chan *Repository),
 		rows:           make(chan sql.Row),
 	}
 
-	go rowRepoIter.fillRepoChannel()
+	go repoIter.fillRepoChannel()
 
 	wNum := runtime.NumCPU()
 
 	for i := 0; i < wNum; i++ {
-		rowRepoIter.wg.Add(1)
+		repoIter.wg.Add(1)
 
-		go rowRepoIter.rowReader(i)
+		go repoIter.rowReader(i)
 	}
 
 	go func() {
-		rowRepoIter.wg.Wait()
-		close(rowRepoIter.rows)
+		repoIter.wg.Wait()
+		close(repoIter.rows)
 	}()
 
-	return &rowRepoIter, nil
+	return &repoIter, nil
 }
 
-func (i *RowRepoIter) fillRepoChannel() {
+func (i *rowRepoIter) fillRepoChannel() {
 	for {
 		repo, err := i.repositoryIter.Next()
 
@@ -184,31 +186,31 @@ func (i *RowRepoIter) fillRepoChannel() {
 	}
 }
 
-func (i *RowRepoIter) rowReader(num int) {
+func (i *rowRepoIter) rowReader(num int) {
 	defer i.wg.Done()
 
 	for repo := range i.repos {
-		impl, _ := i.implementation.NewIterator(repo)
+		iter, _ := i.iter.NewIterator(repo)
 
 	loop:
 		for {
 			select {
 			case <-i.done:
-				impl.Close()
+				iter.Close()
 				return
 
 			default:
-				row, err := impl.Next()
+				row, err := iter.Next()
 				switch err {
 				case nil:
 					i.rows <- row
 
 				case io.EOF:
-					impl.Close()
+					iter.Close()
 					break loop
 
 				default:
-					impl.Close()
+					iter.Close()
 					i.err <- err
 					close(i.done)
 					return
@@ -219,7 +221,7 @@ func (i *RowRepoIter) rowReader(num int) {
 }
 
 // Next gets the next row
-func (i *RowRepoIter) Next() (sql.Row, error) {
+func (i *rowRepoIter) Next() (sql.Row, error) {
 	row, ok := <-i.rows
 	if !ok {
 		return nil, <-i.err
@@ -229,6 +231,6 @@ func (i *RowRepoIter) Next() (sql.Row, error) {
 }
 
 // Close called to close the iterator
-func (i *RowRepoIter) Close() error {
-	return i.implementation.Close()
+func (i *rowRepoIter) Close() error {
+	return i.iter.Close()
 }

repository_pool_test.go

@@ -137,8 +137,8 @@ type testCommitIter struct {
 }
 
 func (d *testCommitIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+	repo *Repository,
+) (RowRepoIter, error) {
 	iter, err := repo.Repo.CommitObjects()
 	if err != nil {
 		return nil, err
@@ -163,12 +163,12 @@ func (d *testCommitIter) Close() error {
 func testRepoIter(num int, require *require.Assertions, pool *RepositoryPool) {
 	cIter := &testCommitIter{}
 
-	rowRepoIter, err := NewRowRepoIter(pool, cIter)
+	repoIter, err := NewRowRepoIter(pool, cIter)
 	require.Nil(err)
 
 	count := 0
 	for {
-		row, err := rowRepoIter.Next()
+		row, err := repoIter.Next()
 		if err != nil {
 			require.Equal(io.EOF, err)
 			break

tags.go

@@ -45,12 +45,12 @@ func (r *tagsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expression
 func (r tagsTable) RowIter() (sql.RowIter, error) {
 	iter := &tagIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (tagsTable) Children() []sql.Node {
@@ -61,9 +61,7 @@ type tagIter struct {
 	iter *object.TagIter
 }
 
-func (i *tagIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *tagIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.TagObjects()
 	if err != nil {
 		return nil, err

tree_entries.go

@@ -45,12 +45,12 @@ func (r *treeEntriesTable) TransformExpressionsUp(f func(sql.Expression) sql.Exp
 func (r treeEntriesTable) RowIter() (sql.RowIter, error) {
 	iter := &treeEntryIter{}
 
-	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return repoIter, nil
 }
 
 func (treeEntriesTable) Children() []sql.Node {
@@ -63,9 +63,7 @@ type treeEntryIter struct {
 	t  *object.Tree
 }
 
-func (i *treeEntryIter) NewIterator(
-	repo *Repository) (RowRepoIterImplementation, error) {
-
+func (i *treeEntryIter) NewIterator(repo *Repository) (RowRepoIter, error) {
 	iter, err := repo.Repo.TreeObjects()
 	if err != nil {
 		return nil, err