initial commit

Author: markbates

.github/workflows/tests.yml

@@ -0,0 +1,25 @@
+name: Tests
+
+on: [push]
+
+jobs:
+  build:
+    name: ${{matrix.go-version}} ${{matrix.os}}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.17.x]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17.x
+
+      - name: Build
+        run: go build -v ./...
+
+      - name: Test
+        run: go test -race -cover ./...

.gitignore

@@ -0,0 +1 @@
+.vscode

book.go

@@ -0,0 +1,79 @@
+package notes
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// A Book allows for management, such as
+// inserting, updating, and deleting notes.
+type Book struct {
+	Logger io.Writer // Logger for verbose logging
+
+	notes map[int]*Note
+	curID int
+}
+
+// Len returns the number of notes in the book.
+func (book *Book) Len() int {
+	if book == nil {
+		return 0
+	}
+
+	return len(book.notes)
+}
+
+// Restore restores the book from the provided reader.
+// The reader should contain a JSON-encoded book.
+func (book *Book) Restore(r io.Reader) error {
+	if book == nil {
+		return nil
+	}
+
+	if r == nil {
+		return fmt.Errorf("no reader provided")
+	}
+
+	book.log("[RESTORE]\tstarting:\t(%d)\n", len(book.notes))
+
+	err := json.NewDecoder(r).Decode(book)
+
+	if err != nil && err != io.EOF {
+		return fmt.Errorf("failed to decode book: %w", err)
+	}
+
+	book.log("[RESTORE]\tfinished:\t(%d)\n", len(book.notes))
+
+	return nil
+}
+
+// Backup backs up the book, in JSON, to the provided writer.
+func (book *Book) Backup(w io.Writer) error {
+	if book == nil {
+		return nil
+	}
+
+	if w == nil {
+		return fmt.Errorf("no writer provided")
+	}
+
+	book.log("[BACKUP]\tstarting:\t(%d)\n", len(book.notes))
+
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "\t")
+	if err := enc.Encode(book); err != nil {
+		return fmt.Errorf("failed to encode book: %w", err)
+	}
+
+	book.log("[BACKUP]\tfinished:\t(%d)\n", len(book.notes))
+	return nil
+}
+
+func (book *Book) log(format string, a ...interface{}) {
+	if book == nil || book.Logger == nil {
+		return
+	}
+
+	fmt.Fprintf(book.Logger, format, a...)
+}

book_json.go

@@ -0,0 +1,43 @@
+package notes
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type bookJSON struct {
+	CurID int           `json:"cur_id,omitempty"`
+	Notes map[int]*Note `json:"notes,omitempty"`
+}
+
+// MarshalJSON returns the JSON encoding of the book.
+func (book *Book) MarshalJSON() ([]byte, error) {
+	if book == nil {
+		return nil, fmt.Errorf("book is nil")
+	}
+
+	b := bookJSON{
+		CurID: book.curID,
+		Notes: book.notes,
+	}
+
+	return json.MarshalIndent(b, "", "  ")
+}
+
+// UnmarshalJSON parses the JSON-encoded data and
+// stores the result in the book.
+func (book *Book) UnmarshalJSON(data []byte) error {
+	if book == nil {
+		return fmt.Errorf("book is nil")
+	}
+
+	b := &bookJSON{}
+	if err := json.Unmarshal(data, b); err != nil {
+		return err
+	}
+
+	book.curID = b.CurID
+	book.notes = b.Notes
+
+	return nil
+}

book_test.go

@@ -0,0 +1,66 @@
+package notes
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"testing"
+)
+
+func Test_Book_Backup_Restore(t *testing.T) {
+	t.Parallel()
+
+	b1 := &Book{}
+
+	if b1.Len() != 0 {
+		t.Fatalf("book should be empty")
+	}
+
+	const N = 5
+	for i := 0; i < N; i++ {
+		note := &Note{
+			Body: "test!",
+		}
+
+		err := b1.Insert(note)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if b1.Len() != N {
+		t.Fatalf("expected %d, got %d", N, b1.Len())
+	}
+
+	bb := &bytes.Buffer{}
+	err := b1.Backup(bb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	act := bb.Bytes()
+
+	b2 := &Book{
+		Logger: os.Stdout,
+	}
+
+	err = b2.Restore(bytes.NewReader(act))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if b2.Len() != N {
+		t.Fatalf("expected %d, got %d", N, b2.Len())
+	}
+
+	an := fmt.Sprint(b1.notes)
+	en := fmt.Sprint(b2.notes)
+
+	if an != en {
+		t.Fatalf("expected %s, got %s", an, en)
+	}
+
+	if b1.curID != b2.curID {
+		t.Fatalf("expected %d, got %d", b1.curID, b2.curID)
+	}
+}

delete.go

@@ -0,0 +1,29 @@
+package notes
+
+import "fmt"
+
+// Delete removes the given notes from the book, if they exist.
+func (book *Book) Delete(ids ...int) error {
+	if book == nil {
+		return fmt.Errorf("book is nil")
+	}
+
+	if len(ids) == 0 {
+		return nil
+	}
+
+	for _, id := range ids {
+		book.log("[DELETE]\tby id:\t%d\n", id)
+
+		_, ok := book.notes[id]
+		if !ok {
+			err := ErrNotFound(id)
+			book.log("[DELETE]\terror:\t%s\n", err)
+			return err
+		}
+		delete(book.notes, id)
+
+	}
+
+	return nil
+}

delete_test.go

@@ -0,0 +1,38 @@
+package notes
+
+import "testing"
+
+func Test_Book_Delete(t *testing.T) {
+	t.Parallel()
+
+	b := &Book{}
+
+	note := &Note{
+		Body: "hello",
+	}
+
+	err := b.Insert(note)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	notes, err := b.Select(note.ID())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(notes) != 1 {
+		t.Fatalf("expected 1 note, got %d", len(notes))
+	}
+
+	n2 := notes[0]
+	if n2.ID() != note.ID() {
+		t.Fatalf("expected note id %d, got %d", note.ID(), n2.ID())
+	}
+
+	err = b.Delete(note.ID())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+}

errors.go

@@ -0,0 +1,10 @@
+package notes
+
+import "fmt"
+
+// ErrNotFound is returned when a note is not found.
+type ErrNotFound int
+
+func (e ErrNotFound) Error() string {
+	return fmt.Sprintf("note %d: not found", int(e))
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/gopherguides/notes
+
+go 1.17

insert.go

@@ -0,0 +1,40 @@
+package notes
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Insert adds the given notes to the book.
+func (book *Book) Insert(notes ...*Note) error {
+	if book == nil {
+		return fmt.Errorf("book is nil")
+	}
+
+	for _, note := range notes {
+		if !note.IsValid() {
+			return fmt.Errorf("note is invalid")
+		}
+
+		book.curID = book.curID + 1
+
+		note.id = book.curID
+
+		now := time.Now()
+		note.createdAt = now
+		note.updatedAt = now
+		note.Body = strings.TrimSpace(note.Body)
+
+		book.log("[INSERT]\tinserting:\t%d\n", note.id)
+
+		if book.notes == nil {
+			book.notes = map[int]*Note{}
+		}
+
+		book.notes[note.id] = note
+
+		book.log("[INSERT]\tinserted:\t%d\n", note.id)
+	}
+	return nil
+}

insert_test.go

@@ -0,0 +1,44 @@
+package notes
+
+import "testing"
+
+func Test_Book_Insert(t *testing.T) {
+	t.Parallel()
+
+	table := []struct {
+		name string
+		note *Note
+		book *Book
+		err  bool
+	}{
+		{name: "all good", note: &Note{Body: "test"}, book: &Book{}},
+		{name: "empty book", note: &Note{Body: "test"}, err: true},
+		{name: "empty note and book", err: true},
+		{name: "empty note", book: &Book{}, err: true},
+	}
+
+	for _, tt := range table {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.book.Insert(tt.note)
+
+			if tt.err {
+				if err == nil {
+					t.Errorf("expected error, got nil")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+
+			exp := 1
+			act := tt.book.Len()
+
+			if act != exp {
+				t.Errorf("expected %v, got %v", exp, act)
+			}
+
+		})
+	}
+}