Typos. Documentation.

cmd/migrate/main.go

@@ -11,7 +11,7 @@ import (
 )
 
 func main() {
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(1000 * time.Millisecond)
 	log.Printf("Migrating database...")
 	config.LoadEnvironmentVariables()
 	postgresConfig := config.NewPostgresConfig()

internal/collageapi/collageapi.go

@@ -27,7 +27,7 @@ func Start() {
 	r.RegisterRoute("GET /imagesets", imageSetHandler.GetImageSets)
 	r.RegisterRoute("GET /imagesets/{id}", imageSetHandler.GetImageSetById)
 
-	tiRepo, err := repository.NewTagrgetImageRepository(c, ctx)
+	tiRepo, err := repository.NewTargetImageRepository(c, ctx)
 	if err != nil {
 		panic(err)
 	}

internal/database/seed.go

@@ -102,7 +102,7 @@ func Seed() {
 			panic(err)
 		}
 	}
-	tiRepo, err := repository.NewTagrgetImageRepository(c, ctx)
+	tiRepo, err := repository.NewTargetImageRepository(c, ctx)
 	if err != nil {
 		panic(err)
 	}

internal/repository/targetimagerepository.go

@@ -12,20 +12,20 @@ import (
 	sqlc "github.com/pokemonpower92/collagegenerator/internal/sqlc/generated"
 )
 
-type TargeImageRepository struct {
+type TargetImageRepository struct {
 	client *pgxpool.Pool
 	logger *log.Logger
 	ctx    context.Context
 	q      *sqlc.Queries
 }
 
-func NewTagrgetImageRepository(
+func NewTargetImageRepository(
 	pgConfig *config.DBConfig,
 	ctx context.Context,
-) (*TargeImageRepository, error) {
+) (*TargetImageRepository, error) {
 	logger := log.New(
 		log.Writer(),
-		"TargeImageRepository: ",
+		"TargetImageRepository: ",
 		log.LstdFlags,
 	)
 	connString := GetConnectionString(pgConfig)
@@ -37,19 +37,19 @@ func NewTagrgetImageRepository(
 		return nil, err
 	}
 	q := sqlc.New(client)
-	return &TargeImageRepository{
+	return &TargetImageRepository{
 		client: client,
 		logger: logger,
 		ctx:    ctx,
 		q:      q,
 	}, nil
 }
 
-func (tir *TargeImageRepository) Close() {
+func (tir *TargetImageRepository) Close() {
 	tir.client.Close()
 }
 
-func (tir *TargeImageRepository) Get(id uuid.UUID) (*sqlc.TargetImage, error) {
+func (tir *TargetImageRepository) Get(id uuid.UUID) (*sqlc.TargetImage, error) {
 	tir.logger.Printf("Get not implemented")
 	targetImage, err := tir.q.GetTargetImage(tir.ctx, id)
 	if err != nil {
@@ -58,15 +58,15 @@ func (tir *TargeImageRepository) Get(id uuid.UUID) (*sqlc.TargetImage, error) {
 	return targetImage, nil
 }
 
-func (tir *TargeImageRepository) GetAll() ([]*sqlc.TargetImage, error) {
+func (tir *TargetImageRepository) GetAll() ([]*sqlc.TargetImage, error) {
 	targetImages, err := tir.q.ListTargetImages(tir.ctx)
 	if err != nil {
 		return nil, err
 	}
 	return targetImages, nil
 }
 
-func (tir *TargeImageRepository) Create(
+func (tir *TargetImageRepository) Create(
 	req sqlc.CreateTargetImageParams,
 ) (*sqlc.TargetImage, error) {
 	targetImage, err := tir.q.CreateTargetImage(tir.ctx, req)
@@ -76,15 +76,15 @@ func (tir *TargeImageRepository) Create(
 	return targetImage, nil
 }
 
-func (tir *TargeImageRepository) Update(
+func (tir *TargetImageRepository) Update(
 	id uuid.UUID,
 	req sqlc.CreateTargetImageParams,
 ) (*sqlc.TargetImage, error) {
 	tir.logger.Printf("Update not implemented")
 	return nil, errors.New("Update not implemented for target images")
 }
 
-func (tir *TargeImageRepository) Delete(id uuid.UUID) error {
+func (tir *TargetImageRepository) Delete(id uuid.UUID) error {
 	tir.logger.Printf("Delete not implemented")
 	return errors.New("Delete not implemented for target images")
 }

internal/server/server.go

@@ -31,15 +31,3 @@ func NewCollageServer(router *router.Router) *Server {
 		router: router,
 	}
 }
-
-func NewImageServer(router *router.Router) *Server {
-	server := &http.Server{
-		Addr:    "localhost:8004",
-		Handler: router.Mux,
-	}
-
-	return &Server{
-		server: server,
-		router: router,
-	}
-}

internal/service/collage.go

@@ -126,8 +126,10 @@ func (cs *collageService) getSectionAverageColors() ([]*color.RGBA, error) {
 	return averageColors, nil
 }
 
-// Find the image set image that best fits the given
-// section of the target image
+// findImagesForSections finds the image set image that best fits the given
+// chunk of sections of the target image by comparing the local color of the
+// section to the average color of images in the image set.
+// It processes a chunk of sections in parallel.
 func (cs *collageService) findImagesForSections(
 	startSection int,
 	numSections int,
@@ -160,7 +162,12 @@ func (cs *collageService) findImagesForSections(
 	}
 }
 
-// Find out what image set image goes where in the collage.
+// determineImagePlacements processes the target image in batches by:
+//  1. Scaling the target image to a configured resolution where the number of pixels corresponds
+//     to the final collage resolution
+//  2. Retrieves the average colors of each image in the image set.
+//  3. Concurrently finds the best fit image by average color for each section in batches.
+//  4. Encodes the placements in a metadata file stored by collage id for deferred creation.
 func (cs *collageService) determineImagePlacements() {
 	cs.logger.Printf("Finding image placements\n")
 	totalSections := cs.resolution.XSections * cs.resolution.YSections
@@ -199,6 +206,10 @@ func (cs *collageService) determineImagePlacements() {
 	cs.createMetaDataFile()
 }
 
+// createMetaDataFile generates a file containing the
+// image placements for the collage.
+// The meta data file will be stored in the configured
+// store location under the name of the collage.
 func (cs *collageService) createMetaDataFile() {
 	var buf bytes.Buffer
 	metaData := CollageMetaData{