Refactor per code climate rules

License: MIT
Signed-off-by: Michael Avila <davidmichaelavila@gmail.com>

core/builder.go

@@ -277,7 +277,7 @@ func setupNode(ctx context.Context, n *IpfsNode, cfg *BuildCfg) error {
 	n.Resolver = resolver.NewBasicResolver(n.DAG)
 
 	// Provider
-	queue, err := provider.NewQueue("provider-v1", ctx, n.Repo.Datastore())
+	queue, err := provider.NewQueue(ctx, "provider-v1", n.Repo.Datastore())
 	if err != nil {
 		return err
 	}

core/coreapi/coreapi.go

@@ -20,8 +20,8 @@ import (
 
 	"github.com/ipfs/go-ipfs/core"
 	"github.com/ipfs/go-ipfs/namesys"
-	"github.com/ipfs/go-ipfs/provider"
 	"github.com/ipfs/go-ipfs/pin"
+	"github.com/ipfs/go-ipfs/provider"
 	"github.com/ipfs/go-ipfs/repo"
 
 	bserv "github.com/ipfs/go-blockservice"

core/coreapi/provider.go

@@ -4,8 +4,10 @@ import (
 	cid "github.com/ipfs/go-cid"
 )
 
+// ProviderAPI brings Provider behavior to CoreAPI
 type ProviderAPI CoreAPI
 
-func (api *ProviderAPI) Provide(root cid.Cid) error {
-	return api.provider.Provide(root)
+// Provide the given cid using the current provider
+func (api *ProviderAPI) Provide(cid cid.Cid) error {
+	return api.provider.Provide(cid)
 }

provider/offline.go

@@ -4,6 +4,7 @@ import "github.com/ipfs/go-cid"
 
 type offlineProvider struct{}
 
+// NewOfflineProvider creates a Provider that does nothing
 func NewOfflineProvider() Provider {
 	return &offlineProvider{}
 }

provider/provider.go

@@ -18,13 +18,12 @@ const (
 	provideOutgoingWorkerLimit = 8
 )
 
+// Provider announces blocks to the network
 type Provider interface {
 	Run()
 	Provide(cid.Cid) error
 }
 
-// Provider announces blocks to the network, tracks which blocks are
-// being provided, and untracks blocks when they're no longer in the blockstore.
 type provider struct {
 	ctx context.Context
 	// the CIDs for which provide announcements should be made
@@ -33,6 +32,7 @@ type provider struct {
 	contentRouting routing.ContentRouting
 }
 
+// NewProvider creates a provider that announces blocks to the network using a content router
 func NewProvider(ctx context.Context, queue *Queue, contentRouting routing.ContentRouting) Provider {
 	return &provider{
 		ctx:            ctx,

provider/queue.go

@@ -22,6 +22,7 @@ type Entry struct {
 	queue *Queue
 }
 
+// Complete the entry by removing it from the queue
 func (e *Entry) Complete() error {
 	return e.queue.remove(e.key)
 }
@@ -50,9 +51,10 @@ type Queue struct {
 	isRunning bool
 }
 
-func NewQueue(name string, ctx context.Context, datastore ds.Datastore) (*Queue, error) {
+// NewQueue creates a queue for cids
+func NewQueue(ctx context.Context, name string, datastore ds.Datastore) (*Queue, error) {
 	namespaced := namespace.Wrap(datastore, ds.NewKey("/"+name+"/queue/"))
-	head, tail, err := getQueueHeadTail(name, ctx, namespaced)
+	head, tail, err := getQueueHeadTail(ctx, name, namespaced)
 	if err != nil {
 		return nil, err
 	}
@@ -70,7 +72,7 @@ func NewQueue(name string, ctx context.Context, datastore ds.Datastore) (*Queue,
 	return q, nil
 }
 
-// Put a cid in the queue
+// Enqueue puts a cid in the queue
 func (q *Queue) Enqueue(cid cid.Cid) error {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -95,21 +97,18 @@ func (q *Queue) Enqueue(cid cid.Cid) error {
 	return nil
 }
 
-// Remove an entry from the queue.
+// Dequeue returns a channel that if listened to will remove entries from the queue
 func (q *Queue) Dequeue() <-chan *Entry {
 	return q.dequeue
 }
 
+// IsEmpty returns whether or not the queue has any items
 func (q *Queue) IsEmpty() bool {
 	return (q.tail - q.head) == 0
 }
 
-func (q *Queue) remove(key ds.Key) error {
-	return q.datastore.Delete(key)
-}
-
-// dequeue items when the dequeue channel is available to
-// be written to
+// Run dequeues items when the dequeue channel is available to
+// be written to.
 func (q *Queue) Run() {
 	q.isRunning = true
 	go func() {
@@ -194,14 +193,14 @@ func (q *Queue) queueKey(id uint64) ds.Key {
 }
 
 // crawl over the queue entries to find the head and tail
-func getQueueHeadTail(name string, ctx context.Context, datastore ds.Datastore) (uint64, uint64, error) {
+func getQueueHeadTail(ctx context.Context, name string, datastore ds.Datastore) (uint64, uint64, error) {
 	query := query.Query{}
 	results, err := datastore.Query(query)
 	if err != nil {
 		return 0, 0, err
 	}
 
-	var tail uint64 = 0
+	var tail uint64
 	var head uint64 = math.MaxUint64
 	for entry := range results.Next() {
 		select {
@@ -233,3 +232,6 @@ func getQueueHeadTail(name string, ctx context.Context, datastore ds.Datastore)
 	return head, tail, nil
 }
 
+func (q *Queue) remove(key ds.Key) error {
+	return q.datastore.Delete(key)
+}