[add] Added gofmt automation/check. Added release drafter github action.

Author: filipecosta90

.circleci/config.yml

@@ -14,9 +14,7 @@ jobs:
     working_directory: /go/src/github.com/RedisBloom/redisbloom-go
     steps:
       - checkout
-      - run: go get -v -t -d ./...
-
-      #run tests with coverage
+      - run: make checkfmt
       - run: make get
       - run: make coverage
       - run: bash <(curl -s https://codecov.io/bash) -t ${CODECOV_TOKEN}

.github/release-drafter-config.yml

@@ -0,0 +1,21 @@
+name-template: 'Version $NEXT_PATCH_VERSION - Summary Here🌈'
+tag-template: 'v$NEXT_PATCH_VERSION'
+categories:
+  - title: '🚀Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: 'Bug Fixes'
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+  - title: '🧰Maintenance'
+    label: 'chore'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+exclude-labels:
+  - 'skip-changelog'
+template: |
+  ## Changes
+
+  $CHANGES

.github/workflows/release-drafter.yml

@@ -0,0 +1,19 @@
+name: Release Drafter
+
+on:
+  push:
+    # branches to consider in the event; optional, defaults to all
+    branches:
+      - master
+
+jobs:
+  update_release_draft:
+    runs-on: ubuntu-latest
+    steps:
+      # Drafts your next Release notes as Pull Requests are merged into "master"
+      - uses: release-drafter/release-drafter@v5
+        with:
+          # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml
+           config-name: release-drafter-config.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.golangci.yml

@@ -0,0 +1,15 @@
+# options for analysis running
+run:
+  # include test files or not, default is true
+  tests: false
+
+linters-settings:
+  golint:
+    # minimal confidence for issues, default is 0.8
+    min-confidence: 0.8
+
+exclude-rules:
+  # Exclude some linters from running on tests files.
+  - path: _test\.go
+    linters:
+      - errcheck

Makefile

@@ -6,14 +6,25 @@ GOCLEAN=$(GOCMD) clean
 GOTEST=$(GOCMD) test
 GOGET=$(GOCMD) get
 GOMOD=$(GOCMD) mod
+GOFMT=$(GOCMD) fmt
 
 .PHONY: all test coverage
 all: test coverage
 
+checkfmt:
+	@echo 'Checking gofmt';\
+ 	bash -c "diff -u <(echo -n) <(gofmt -d .)";\
+	EXIT_CODE=$$?;\
+	if [ "$$EXIT_CODE"  -ne 0 ]; then \
+		echo '$@: Go files must be formatted with gofmt'; \
+	fi && \
+	exit $$EXIT_CODE
+
 get:
 	$(GOGET) -t -v ./...
 
 test: get
+	$(GOFMT) ./...
 	$(GOTEST) -race -covermode=atomic ./...
 
 coverage: get test

client.go

@@ -2,9 +2,9 @@ package redis_bloom_go
 
 import (
 	"errors"
-	"strings"
-	"strconv"
 	"github.com/gomodule/redigo/redis"
+	"strconv"
+	"strings"
 )
 
 // TODO: refactor this hard limit and revise client locking
@@ -35,7 +35,6 @@ func NewClient(addr, name string, authPass *string) *Client {
 	return ret
 }
 
-
 // NewClientFromPool creates a new Client with the given pool and client name
 func NewClientFromPool(pool *redis.Pool, name string) *Client {
 	ret := &Client{
@@ -45,50 +44,49 @@ func NewClientFromPool(pool *redis.Pool, name string) *Client {
 	return ret
 }
 
-// Reserve - Creates an empty Bloom Filter with a given desired error ratio and initial capacity. 
+// Reserve - Creates an empty Bloom Filter with a given desired error ratio and initial capacity.
 // args:
 // key - the name of the filter
 // error_rate - the desired probability for false positives
-// capacity - the number of entries you intend to add to the filter 
+// capacity - the number of entries you intend to add to the filter
 func (client *Client) Reserve(key string, error_rate float64, capacity uint64) (err error) {
 	conn := client.Pool.Get()
 	defer conn.Close()
-	_, err = conn.Do("BF.RESERVE", key,  strconv.FormatFloat(error_rate, 'g', 16, 64), capacity)
+	_, err = conn.Do("BF.RESERVE", key, strconv.FormatFloat(error_rate, 'g', 16, 64), capacity)
 	return err
 }
 
-
 // Add - Add (or create and add) a new value to the filter
 // args:
-// key - the name of the filter 
-// item - the item to add 
+// key - the name of the filter
+// item - the item to add
 func (client *Client) Add(key string, item string) (exists bool, err error) {
 	conn := client.Pool.Get()
 	defer conn.Close()
 	return redis.Bool(conn.Do("BF.ADD", key, item))
 }
 
-// Exists - Determines whether an item may exist in the Bloom Filter or not. 
+// Exists - Determines whether an item may exist in the Bloom Filter or not.
 // args:
-// key - the name of the filter 
-// item - the item to check for 
+// key - the name of the filter
+// item - the item to check for
 func (client *Client) Exists(key string, item string) (exists bool, err error) {
 	conn := client.Pool.Get()
 	defer conn.Close()
 	return redis.Bool(conn.Do("BF.EXISTS", key, item))
 }
 
-// Info - Return information about key  
+// Info - Return information about key
 // args:
-// key - the name of the filter 
+// key - the name of the filter
 func (client *Client) Info(key string) (info map[string]int64, err error) {
 	conn := client.Pool.Get()
 	defer conn.Close()
 	result, err := conn.Do("BF.INFO", key)
 	if err != nil {
 		return nil, err
 	}
-	
+
 	values, err := redis.Values(result, nil)
 	if err != nil {
 		return nil, err
@@ -98,7 +96,7 @@ func (client *Client) Info(key string) (info map[string]int64, err error) {
 	}
 	info = map[string]int64{}
 	for i := 0; i < len(values); i += 2 {
-		key, err = redis.String(values[i], nil)	
+		key, err = redis.String(values[i], nil)
 		if err != nil {
 			return nil, err
 		}
@@ -107,5 +105,5 @@ func (client *Client) Info(key string) (info map[string]int64, err error) {
 			return nil, err
 		}
 	}
-	return info, nil				
+	return info, nil
 }

client_test.go

@@ -1,14 +1,13 @@
 package redis_bloom_go
 
 import (
+	"github.com/gomodule/redigo/redis"
+	"github.com/stretchr/testify/assert"
 	"os"
 	"testing"
 	"time"
-	"github.com/gomodule/redigo/redis"
-	"github.com/stretchr/testify/assert"
 )
 
-
 func getTestConnectionDetails() (string, string) {
 	value, exists := os.LookupEnv("REDISBLOOM_TEST_HOST")
 	host := "localhost:6379"
@@ -32,7 +31,6 @@ func createClient() *Client {
 	return NewClient(host, "test_client", ptr)
 }
 
-
 func TestNewClientFromPool(t *testing.T) {
 	host, password := getTestConnectionDetails()
 	pool := &redis.Pool{Dial: func() (redis.Conn, error) {
@@ -65,33 +63,33 @@ func TestReserve(t *testing.T) {
 	key := "test_RESERVE"
 	err := client.Reserve(key, 0.1, 1000)
 	assert.Nil(t, err)
-	
+
 	info, err := client.Info(key)
 	assert.Nil(t, err)
 	assert.Equal(t, info, map[string]int64{
-			"Capacity": 1000,
-			"Expansion rate": 2,
-            "Number of filters": 1,
-            "Number of items inserted": 0,
-            "Size": 932,
+		"Capacity":                 1000,
+		"Expansion rate":           2,
+		"Number of filters":        1,
+		"Number of items inserted": 0,
+		"Size":                     932,
 	})
-	
+
 	err = client.Reserve(key, 0.1, 1000)
 	assert.NotNil(t, err)
 }
 
 func TestAdd(t *testing.T) {
 	client.FlushAll()
 	key := "test_ADD"
-	value := "test_ADD_value";
+	value := "test_ADD_value"
 	exists, err := client.Add(key, value)
 	assert.Nil(t, err)
 	assert.True(t, exists)
-	
+
 	info, err := client.Info(key)
 	assert.Nil(t, err)
 	assert.NotNil(t, info)
-	
+
 	exists, err = client.Add(key, value)
 	assert.Nil(t, err)
 	assert.False(t, exists)
@@ -100,11 +98,11 @@ func TestAdd(t *testing.T) {
 func TestExists(t *testing.T) {
 	client.FlushAll()
 	client.Add("test_ADD", "test_EXISTS")
-	
+
 	exists, err := client.Exists("test_ADD", "test_EXISTS")
 	assert.Nil(t, err)
 	assert.True(t, exists)
-	
+
 	exists, err = client.Exists("test_ADD", "test_EXISTS1")
 	assert.Nil(t, err)
 	assert.False(t, exists)

pool.go

@@ -17,6 +17,7 @@ type ConnPool interface {
 type SingleHostPool struct {
 	*redis.Pool
 }
+
 //
 //func (s SingleHostPool) Close() {
 //	s.Pool.Close()
@@ -39,7 +40,6 @@ type MultiHostPool struct {
 	authPass *string
 }
 
-
 func (p *MultiHostPool) Close() (err error) {
 	p.Lock()
 	defer p.Unlock()
@@ -57,7 +57,6 @@ func (p *MultiHostPool) Close() (err error) {
 	return
 }
 
-
 func NewMultiHostPool(hosts []string, authPass *string) *MultiHostPool {
 	return &MultiHostPool{
 		pools:    make(map[string]*redis.Pool, len(hosts)),