Extract the structs into their own files

Signed-off-by: Chris Cummer <[email protected]>

Author: senorprogrammer

main.go

@@ -0,0 +1,23 @@
+package src
+
+import "fmt"
+
+var (
+	// Blue writes blue text
+	Blue = Colour("\033[1;36m%s\033[0m")
+
+	// Green writes green text
+	Green = Colour("\033[1;32m%s\033[0m")
+
+	// Red writes red text
+	Red = Colour("\033[1;31m%s\033[0m")
+)
+
+// Colour returns a function that defines a printable colour string
+func Colour(colorString string) func(...interface{}) string {
+	sprint := func(args ...interface{}) string {
+		return fmt.Sprintf(colorString,
+			fmt.Sprint(args...))
+	}
+	return sprint
+}

src/colours.go

@@ -0,0 +1,185 @@
+package src
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/olebedev/config"
+)
+
+const (
+	defaultConfig = `--- 
+commitMessage: "build, save, push"
+committerEmail: [email protected]
+committerName: "TIL Autobot"
+editor: ""
+targetDirectory: 
+	a: "~/Documents/tilblog"
+`
+
+	tilConfigDir  = "~/.config/til/"
+	tilConfigFile = "config.yml"
+)
+
+const (
+	errConfigDirCreate  = "could not create the configuration directory"
+	errConfigExpandPath = "could not expand the config directory"
+	errConfigFileAssert = "could not assert the configuration file exists"
+	errConfigFileCreate = "could not create the configuration file"
+	errConfigFileWrite  = "could not write the configuration file"
+	errConfigPathEmpty  = "config path cannot be empty"
+)
+
+// GlobalConfig holds and makes available all the user-configurable
+// settings that are stored in the config file.
+// (I know! Friends don't let friends use globals, but since I have
+// no friends working on this, there's no one around to stop me)
+var GlobalConfig *config.Config
+
+// Config handles all things to do with configuration
+type Config struct{}
+
+// Load reads the configuration file
+func (c *Config) Load() {
+	makeConfigDir()
+	makeConfigFile()
+
+	GlobalConfig = readConfigFile()
+}
+
+// getConfigDir returns the string path to the directory that should
+// contain the configuration file.
+// It tries to be XDG-compatible
+func getConfigDir() (string, error) {
+	cDir := os.Getenv("XDG_CONFIG_HOME")
+	if cDir == "" {
+		cDir = tilConfigDir
+	}
+
+	// If the user hasn't changed the default path then we expect it to start
+	// with a tilde (the user's home), and we need to turn that into an
+	// absolute path. If it does not start with a '~' then we assume the
+	// user has set their $XDG_CONFIG_HOME to something specific, and we
+	// do not mess with it (because doing so makes the archlinux people
+	// very cranky)
+	if cDir[0] != '~' {
+		return cDir, nil
+	}
+
+	dir, err := os.UserHomeDir()
+	if err != nil {
+		return "", errors.New(errConfigExpandPath)
+	}
+
+	cDir = filepath.Join(dir, cDir[1:])
+
+	if cDir == "" {
+		return "", errors.New(errConfigPathEmpty)
+	}
+
+	return cDir, nil
+}
+
+// GetConfigFilePath returns the string path to the configuration file
+func GetConfigFilePath() (string, error) {
+	cDir, err := getConfigDir()
+	if err != nil {
+		return "", err
+	}
+
+	if cDir == "" {
+		return "", errors.New(errConfigPathEmpty)
+	}
+
+	return fmt.Sprintf("%s/%s", cDir, tilConfigFile), nil
+}
+
+func makeConfigDir() {
+	cDir, err := getConfigDir()
+	if err != nil {
+		Defeat(err)
+	}
+
+	if cDir == "" {
+		Defeat(errors.New(errConfigPathEmpty))
+	}
+
+	if _, err := os.Stat(cDir); os.IsNotExist(err) {
+		err := os.MkdirAll(cDir, os.ModePerm)
+		if err != nil {
+			Defeat(errors.New(errConfigDirCreate))
+		}
+
+		Progress(fmt.Sprintf("created %s", cDir))
+	}
+}
+
+func makeConfigFile() {
+	cPath, err := GetConfigFilePath()
+	if err != nil {
+		Defeat(err)
+	}
+
+	if cPath == "" {
+		Defeat(errors.New(errConfigPathEmpty))
+	}
+
+	_, err = os.Stat(cPath)
+
+	if err != nil {
+		// Something went wrong trying to find the config file.
+		// Let's see if we can figure out what happened
+		if os.IsNotExist(err) {
+			// Ah, the config file does not exist, which is probably fine
+			_, err = os.Create(cPath)
+			if err != nil {
+				// That was not fine
+				Defeat(errors.New(errConfigFileCreate))
+			}
+
+		} else {
+			// But wait, it's some kind of other error. What kind?
+			// I dunno, but it's probably bad so die
+			Defeat(err)
+		}
+	}
+
+	// Let's double-check that the file's there now
+	fileInfo, err := os.Stat(cPath)
+	if err != nil {
+		Defeat(errors.New(errConfigFileAssert))
+	}
+
+	// Write the default config, but only if the file is empty.
+	// Don't want to stop on any non-default values the user has written in there
+	if fileInfo.Size() == 0 {
+		if ioutil.WriteFile(cPath, []byte(defaultConfig), 0600) != nil {
+			Defeat(errors.New(errConfigFileWrite))
+		}
+
+		Progress(fmt.Sprintf("created %s", cPath))
+	}
+}
+
+// readConfigFile reads the contents of the config file and jams them
+// into the global config variable
+func readConfigFile() *config.Config {
+	cPath, err := GetConfigFilePath()
+	if err != nil {
+		Defeat(err)
+	}
+
+	if cPath == "" {
+		Defeat(errors.New(errConfigPathEmpty))
+	}
+
+	cfg, err := config.ParseYamlFile(cPath)
+	if err != nil {
+		Defeat(err)
+	}
+
+	return cfg
+}

src/configuration.go

@@ -0,0 +1,32 @@
+package src
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+// LL is a go routine-safe implementation of Logger
+// (More globals! This is getting crazy)
+var LL *log.Logger
+
+// Defeat writes out an error message
+func Defeat(err error) {
+	LL.Fatal(fmt.Sprintf("%s %s", Red("✘"), err.Error()))
+}
+
+// Info writes out an informative message
+func Info(msg string) {
+	LL.Print(fmt.Sprintf("%s %s", Green("->"), msg))
+}
+
+// Progress writes out a progress status message
+func Progress(msg string) {
+	LL.Print(fmt.Sprintf("\t%s %s\n", Blue("->"), msg))
+}
+
+// Victory writes out a victorious final message and then expires dramatically
+func Victory(msg string) {
+	LL.Print(fmt.Sprintf("%s %s", Green("✓"), msg))
+	os.Exit(0)
+}

src/logging.go

@@ -0,0 +1,119 @@
+package src
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const (
+	// A custom datetime format that plays nicely with GitHub Pages filename restrictions
+	ghFriendlyDateFormat = "2006-01-02T15-04-05"
+
+	// FileExtension defines the extension to write on the generated file
+	FileExtension = "md"
+)
+
+// Page represents a TIL page
+type Page struct {
+	Content  string `fm:"content" yaml:"-"`
+	Date     string `yaml:"date"`
+	FilePath string `yaml:"filepath"`
+	TagsStr  string `yaml:"tags"`
+	Title    string `yaml:"title"`
+}
+
+// NewPage creates and returns an instance of page
+func NewPage(title string, targetDir string) *Page {
+	date := time.Now()
+
+	page := &Page{
+		Date: date.Format(time.RFC3339),
+		FilePath: fmt.Sprintf(
+			"%s/%s-%s.%s",
+			targetDir,
+			date.Format(ghFriendlyDateFormat),
+			strings.ReplaceAll(strings.ToLower(title), " ", "-"),
+			FileExtension,
+		),
+		Title: title,
+	}
+
+	page.Save()
+
+	return page
+}
+
+// CreatedAt returns a time instance representing when the page was created
+func (page *Page) CreatedAt() time.Time {
+	date, err := time.Parse(time.RFC3339, page.Date)
+	if err != nil {
+		return time.Time{}
+	}
+
+	return date
+}
+
+// CreatedMonth returns the month the page was created
+func (page *Page) CreatedMonth() time.Month {
+	if page.CreatedAt().IsZero() {
+		return 0
+	}
+
+	return page.CreatedAt().Month()
+}
+
+// FrontMatter returns the front-matter of the page
+func (page *Page) FrontMatter() string {
+	return fmt.Sprintf(
+		"---\ndate: %s\ntitle: %s\ntags: %s\n---\n\n",
+		page.Date,
+		page.Title,
+		page.TagsStr,
+	)
+}
+
+// IsContentPage returns true if the page is a valid entry page, false if it is not
+func (page *Page) IsContentPage() bool {
+	return page.Title != ""
+}
+
+// Link returns a link string suitable for embedding in a Markdown page
+func (page *Page) Link() string {
+	return fmt.Sprintf(
+		"<code>%s</code> [%s](%s)",
+		page.PrettyDate(),
+		page.Title,
+		filepath.Base(page.FilePath),
+	)
+}
+
+// PrettyDate returns a human-friendly representation of the CreatedAt date
+func (page *Page) PrettyDate() string {
+	return page.CreatedAt().Format("Jan 02, 2006")
+}
+
+// Save writes the content of the page to file
+func (page *Page) Save() {
+	pageSrc := page.FrontMatter()
+	pageSrc += fmt.Sprintf("# %s\n\n", page.Title)
+
+	err := ioutil.WriteFile(page.FilePath, []byte(pageSrc), 0644)
+	if err != nil {
+		Defeat(err)
+	}
+}
+
+// Tags returns a slice of tags assigned to this page
+func (page *Page) Tags() []*Tag {
+	tags := []*Tag{}
+
+	names := strings.Split(page.TagsStr, ",")
+	for _, name := range names {
+		tags = append(tags, NewTag(name, page))
+	}
+
+	return tags
+}

src/page.go

@@ -0,0 +1,13 @@
+package src
+
+import (
+	"fmt"
+	"time"
+)
+
+func Footer() string {
+	return fmt.Sprintf(
+		"<sup><sub>generated %s by <a href='https://github.com/senorprogrammer/til'>til</a></sub></sup>\n",
+		time.Now().Format("2 Jan 2006 15:04:05"),
+	)
+}