Update parser and server to watch file changes

Gopkg.toml

@@ -37,10 +37,6 @@
   name = "github.com/julienschmidt/httprouter"
   version = "1.1.0"
 
-[[constraint]]
-  name = "github.com/spf13/afero"
-  version = "1.1.1"
-
 [[constraint]]
   name = "github.com/sirupsen/logrus"
   version = "1.1.0"

cmd/localroast/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"flag"
-	"log"
+	log "github.com/sirupsen/logrus"
 
 	"github.com/caalberts/localroast/json"
 )
@@ -19,7 +19,12 @@ func main() {
 	flag.Parse()
 	args := flag.Args()
 
-	err := json.NewCommand().Execute(*port, args)
+	cmd, err := json.NewCommand()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = cmd.Execute(*port, args)
 	if err != nil {
 		log.Fatal(err)
 	}

filesystem/handler.go

@@ -61,9 +61,9 @@ func (f *FileHandler) Watch() error {
 					file, err := os.Open(event.Name)
 					if err != nil {
 						log.Errorf("error opening file: %s", err)
+					} else {
+						f.send(file)
 					}
-
-					f.send(file)
 				}
 			case err := <-f.watcher.Errors:
 				log.Errorf("error watching file: %s", err)

http/server.go

@@ -11,7 +11,7 @@ import (
 // Server interface.
 type Server interface {
 	ListenAndServe() error
-	Watch() chan<- []localroast.Schema
+	Watch(chan []localroast.Schema)
 }
 
 type server struct {
@@ -35,15 +35,13 @@ func NewServer(port string) Server {
 	}
 }
 
-func (s *server) Watch() chan<- []localroast.Schema {
-	updateChan := make(chan []localroast.Schema)
+func (s *server) Watch(incomingSchemas chan []localroast.Schema) {
 	go func() {
 		for {
-			schemas := <-updateChan
+			schemas := <-incomingSchemas
 			s.router.updateSchema(schemas)
 		}
 	}()
-	return updateChan
 }
 
 type router struct {

json/command.go

@@ -4,67 +4,75 @@ import (
 	"io"
 
 	"github.com/caalberts/localroast"
+	"github.com/caalberts/localroast/filesystem"
 	"github.com/caalberts/localroast/http"
-	"github.com/spf13/afero"
 	"log"
 )
 
 type validator interface {
 	Validate([]string) error
 }
 
+type fileHandler interface {
+	Output() chan io.Reader
+	Open(fileName string) error
+	Watch() error
+}
+
 type parser interface {
-	Parse(<-chan io.Reader, chan<- []localroast.Schema) error
+	Output() chan []localroast.Schema
+	Watch(chan io.Reader)
 }
 
 // Command struct contains a file reader to read input file,
 // a parser to parse input into schema,
 // and a server constructor.
 type Command struct {
-	v  validator
-	p  parser
-	s  http.ServerFunc
-	fs fileSystem
-}
-
-type fileSystem interface {
-	Open(string) (afero.File, error)
+	validator   validator
+	fileHandler fileHandler
+	parser      parser
+	serverFunc  http.ServerFunc
 }
 
 // NewCommand creates a command with a JSON file reader and parser.
-func NewCommand() Command {
-	return Command{
-		v:  Validator{},
-		p:  Parser{},
-		s:  http.NewServer,
-		fs: afero.NewOsFs(),
+func NewCommand() (*Command, error) {
+	fileHandler, err := filesystem.NewFileHandler()
+	if err != nil {
+		return nil, err
+	}
+
+	cmd := Command{
+		validator:   Validator{},
+		fileHandler: fileHandler,
+		parser:      NewParser(),
+		serverFunc:  http.NewServer,
 	}
+	return &cmd, nil
 }
 
 // Execute runs the command and start a server.
 func (c Command) Execute(port string, args []string) error {
-	if err := c.v.Validate(args); err != nil {
+	err := c.validator.Validate(args)
+	if err != nil {
 		return err
 	}
 
-	input := make(chan io.Reader)
 	filepath := args[0]
-	file, err := c.fs.Open(filepath)
+	err = c.fileHandler.Open(filepath)
 	if err != nil {
 		return err
 	}
 
-	go func() {
-		input <- file
-	}()
-
-	server := c.s(port)
-
-	err = c.p.Parse(input, server.Watch())
+	err = c.fileHandler.Watch()
 	if err != nil {
 		return err
 	}
 
+	server := c.serverFunc(port)
+
+	c.parser.Watch(c.fileHandler.Output())
+	server.Watch(c.parser.Output())
+
 	log.Println("brewing on port " + port)
 	return server.ListenAndServe()
 }