Minor formattings

README.md

@@ -132,7 +132,7 @@ Options of awesome-cli:
 ### Sample Execution
 
 ```bash
-> $ go run main.go
+> $ awesome-cli random
 aweome-cli Version 0.2.0
 ✔ Platforms
 ✔ Linux

internal/package/favourite/favourite.go

@@ -1,22 +1,22 @@
 package favourite
 
 import (
+	"encoding/gob"
 	"math/rand"
-    "time"
-    "os"
-    "encoding/gob"
+	"os"
+	"time"
 
 	"github.com/umutphp/awesome-cli/internal/package/fetcher"
 )
 
 type Favourite struct {
-	Name string
+	Name     string
 	Children map[string]Favourite
 }
 
 func New(name string) Favourite {
 	return Favourite{
-		Name: name,
+		Name:     name,
 		Children: map[string]Favourite{},
 	}
 }
@@ -46,7 +46,7 @@ func (f *Favourite) GetRandom() Favourite {
 	rint := rand.Intn(len(f.Children))
 
 	i := 0
-	for _,fav := range f.Children  {
+	for _, fav := range f.Children {
 		if i == rint {
 			return fav
 		}
@@ -77,23 +77,23 @@ func (f *Favourite) SaveCache() {
 }
 
 func NewFromCache(cachename string) Favourite {
-	filename   := fetcher.GetCachePath(cachename)
-	_, err     := os.Stat(filename)
+	filename := fetcher.GetCachePath(cachename)
+	_, err := os.Stat(filename)
 	favourites := Favourite{
-		Name: cachename,
+		Name:     cachename,
 		Children: map[string]Favourite{},
 	}
 
-    if os.IsNotExist(err) {
-        return favourites
-    }
-	
+	if os.IsNotExist(err) {
+		return favourites
+	}
+
 	decodeFile, err := os.Open(filename)
-	
+
 	if err != nil {
 		panic(err)
 	}
-	
+
 	defer decodeFile.Close()
 
 	decoder := gob.NewDecoder(decodeFile)

internal/package/fetcher/fetcher.go

@@ -1,19 +1,19 @@
 package fetcher
 
 import (
-    "log"
-    "net/url"
-    "strings"
-	"net/http"
+	"crypto/md5"
+	"encoding/hex"
 	"io/ioutil"
-    "os"
-    "time"
-    "crypto/md5"
-    "encoding/hex"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
 )
 
-const AWESOMEREPOURL       = "https://github.com/sindresorhus/awesome/"
-const AWESOMECACHEFOLDER   = ".awesomecache"
+const AWESOMEREPOURL = "https://github.com/sindresorhus/awesome/"
+const AWESOMECACHEFOLDER = ".awesomecache"
 const RAWGITHUBUSERCONTENT = "https://raw.githubusercontent.com"
 
 func FetchAwsomeRootRepo() (string, error) {
@@ -25,163 +25,162 @@ func FetchAwsomeRepo(repourl string) (string, error) {
 		CreateCacheFolder()
 	}
 
-    cacheFile := GetCachePath(repourl)
+	cacheFile := GetCachePath(repourl)
+
+	if CacheFileExists(cacheFile) && CacheFileUptoDate(cacheFile) {
+		content, err := ioutil.ReadFile(cacheFile)
 
-    if CacheFileExists(cacheFile) && CacheFileUptoDate(cacheFile) {
-        content, err := ioutil.ReadFile(cacheFile)
-
-        if err != nil {
-            log.Println(err)
-            return "", err
-        } else {
-            return string(content), nil
-        }
-    }
+		if err != nil {
+			log.Println(err)
+			return "", err
+		} else {
+			return string(content), nil
+		}
+	}
 
-    readmes := GetPossibleReadmeFileURLs(repourl)
+	readmes := GetPossibleReadmeFileURLs(repourl)
 
-    for _,rurl := range readmes {
-        response, err := http.Get(rurl)
+	for _, rurl := range readmes {
+		response, err := http.Get(rurl)
 
-        if err != nil {
-            log.Println(err)
-            continue
-        }
+		if err != nil {
+			log.Println(err)
+			continue
+		}
 
-        if response.StatusCode == http.StatusNotFound {
-            //log.Println(rurl, "gives 404.")
-            continue
-        }
+		if response.StatusCode == http.StatusNotFound {
+			//log.Println(rurl, "gives 404.")
+			continue
+		}
 
-        defer response.Body.Close()
+		defer response.Body.Close()
 
-        responseData, err := ioutil.ReadAll(response.Body)
+		responseData, err := ioutil.ReadAll(response.Body)
 
-        if err != nil {
-            log.Println(err)
-            return "", err
-        } 
+		if err != nil {
+			log.Println(err)
+			return "", err
+		}
 
-        responseString := string(responseData)
+		responseString := string(responseData)
 
-        return SaveCache(cacheFile, responseString), nil   
-    }
+		return SaveCache(cacheFile, responseString), nil
+	}
 
-    return "", nil
+	return "", nil
 }
 
 func GetPossibleReadmeFileURLs(repourl string) []string {
-    // Parse the URL and ensure there are no errors.
-    u, err := url.Parse(repourl)
-    if err != nil {
-        log.Println(err)
-    }
-
-    if strings.Count(u.Host, "github.com") == 0 {
-        return []string{}
-    }
-
-    prefix := RAWGITHUBUSERCONTENT + u.Path + "/master/"
-
-    return []string{
-        prefix + "README",
-        prefix + "README.MD",
-        prefix + "README.md",
-        prefix + "readme",
-        prefix + "readme.md",
-        prefix + "readme.MD",
-    }
+	// Parse the URL and ensure there are no errors.
+	u, err := url.Parse(repourl)
+	if err != nil {
+		log.Println(err)
+	}
+
+	if strings.Count(u.Host, "github.com") == 0 {
+		return []string{}
+	}
+
+	prefix := RAWGITHUBUSERCONTENT + u.Path + "/master/"
+
+	return []string{
+		prefix + "README",
+		prefix + "README.MD",
+		prefix + "README.md",
+		prefix + "readme",
+		prefix + "readme.md",
+		prefix + "readme.MD",
+	}
 }
 
 func GetCachePath(url string) string {
-    return GetCacheFolderPath() + string(os.PathSeparator) + CacheFileName(url)
+	return GetCacheFolderPath() + string(os.PathSeparator) + CacheFileName(url)
 }
 
 func GetCacheFolderPath() string {
 	home, err := os.UserHomeDir()
 
-    if err != nil {
-        log.Println(err)
-        return ""
-    }
+	if err != nil {
+		log.Println(err)
+		return ""
+	}
 
-    return home + string(os.PathSeparator) + AWESOMECACHEFOLDER
+	return home + string(os.PathSeparator) + AWESOMECACHEFOLDER
 }
 
 func SaveCache(filename string, text string) string {
 	file, err := os.Create(filename)
 
-    if err != nil {
-        log.Println(err)
-        return ""
-    }
+	if err != nil {
+		log.Println(err)
+		return ""
+	}
 
-    file.WriteString(text)
+	file.WriteString(text)
 
-    return text
+	return text
 }
 
 func CacheFileName(url string) string {
 	hasher := md5.New()
-
-    hasher.Write([]byte(url))
 
-    return hex.EncodeToString(hasher.Sum(nil))
+	hasher.Write([]byte(url))
+
+	return hex.EncodeToString(hasher.Sum(nil))
 }
 
 func CacheFolderExists() bool {
 	info, err := os.Stat(GetCacheFolderPath())
-
-    if os.IsNotExist(err) {
-        return false
-    }
 
-    return info.IsDir()
+	if os.IsNotExist(err) {
+		return false
+	}
+
+	return info.IsDir()
 }
 
 func CreateCacheFolder() bool {
 	err := os.MkdirAll(GetCacheFolderPath(), 0755)
 
 	if err != nil {
-	      return false
+		return false
 	}
 
 	return true
 }
 
 func CacheFileExists(filename string) bool {
-    info, err := os.Stat(filename)
+	info, err := os.Stat(filename)
+
+	if os.IsNotExist(err) {
+		return false
+	}
 
-    if os.IsNotExist(err) {
-        return false
-    }
-
-    return !info.IsDir()
+	return !info.IsDir()
 }
 
 func CacheFileUptoDate(filename string) bool {
-    info, _      := os.Stat(filename)
-    modifiedtime := info.ModTime()
+	info, _ := os.Stat(filename)
+	modifiedtime := info.ModTime()
 
-    return !IsOlderThanOneDay(modifiedtime)
+	return !IsOlderThanOneDay(modifiedtime)
 }
 
 func IsOlderThanOneDay(t time.Time) bool {
-      return time.Now().Sub(t) > 24*time.Hour
+	return time.Now().Sub(t) > 24*time.Hour
 }
 
 func PadLeft(str, pad string, lenght int) string {
-    for {
-        str = pad + str
-        if len(str) >= lenght {
-            return str[0:lenght]
-        }
-    }
+	for {
+		str = pad + str
+		if len(str) >= lenght {
+			return str[0:lenght]
+		}
+	}
 }
 
-
 func IsUrl(str string) bool {
-    u, err := url.Parse(str)
-    
-    return err == nil && u.Scheme != "" && u.Host != ""
+	u, err := url.Parse(str)
+
+	return err == nil && u.Scheme != "" && u.Host != ""
 }