Take steps to clarify API

err.go

@@ -1,6 +1,6 @@
 package windex
 
-import(
+import (
 	"errors"
 )
 

indexer.go

@@ -1,18 +1,17 @@
 package windex
 
 type Indexer interface {
-  Parse() error
-  Flush() error
+	Parse() error
+	Flush() error
 }
 
 type StdoutIndexer struct {
-
 }
 
-func (i *Indexer) Parse() (err error) {
-
+func (i *StdoutIndexer) Parse() (err error) {
+	return
 }
 
-func (i *Indexer) Flush() (err error) {
-
+func (i *StdoutIndexer) Flush() (err error) {
+	return
 }

log_file.go

@@ -1,10 +1,14 @@
 package windex
 
+import (
+	"os"
+)
+
 type LogFile struct {
-	FileName    string
-	File        *os.File
-	FileSize    int64
-	Cursor      *LogFileCursor
+	FileName string
+	File     *os.File
+	FileSize int64
+	Cursor   *LogFileCursor
 }
 
 type LogFileCursor struct {
@@ -13,14 +17,21 @@ type LogFileCursor struct {
 	Delta int64
 }
 
-func NewLogFile(filename string, ){
-    &LogFile{
+func NewLogFile(filename string) (log_file *LogFile, err error) {
+	file, err := os.Open(filename)
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	return &LogFile{
 		File:     file,
 		FileName: filename,
 		FileSize: 0,
 		Pair:     &LogFileCursor{0, 0, 0},
 	}
-
 }
 
 func (m *LogFileCursor) setDelta() (err error) {
@@ -34,7 +45,7 @@ func (m *LogFileCursor) setDelta() (err error) {
 	return nil
 }
 
-func (log *Log) moveAndFlush() {
+func (log *LogFile) moveAndFlush() {
 	if ok := log.movePair(); ok {
 		log.flush()
 	}
@@ -68,6 +79,7 @@ func (log *LogFile) updateFileSize() (err error) {
 	return nil
 }
 
+//
 func (log *LogFile) flush() {
 	delta := log.Pair.Delta
 	file := log.File

watcher.go

@@ -1,11 +1,28 @@
 package windex
 
-import(
+import (
 	"github.com/howeyc/fsnotify"
 )
 
 type Watcher struct {
+	watcher *fsnotify.Watcher
+}
 
+func NewWatcher() (watcher *Watcher, err error) {
+	return &Watcher{
+		watcher: &fsnotify.Watcher,
+	}
+}
+
+func (log *LogFile) Watch() (err error) {
+	err = log.watchable()
+	if err != nil {
+		return
+	}
+
+	log.Watcher.Watch(log.FileName)
+
+	return
 }
 
 func (log *LogFile) watchable() (err error) {
@@ -24,17 +41,7 @@ func (log *LogFile) watchable() (err error) {
 	return
 }
 
-func (log *LogFile) Watch() (err error) {
-	err = log.watchable()
-	if err != nil {
-		return
-	}
-
-	log.Watcher.Watch(log.FileName)
-
-	return
-}
-
+/*
 go func() {
   for {
 	select {
@@ -48,5 +55,18 @@ go func() {
 	}
   }
 }()
+*/
+/*
 
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	logfile := &LogFile{}
+
+	if err = log.updateFileSize(); err != nil {
+		return nil, err
+	}
 
+*/

windex.go

@@ -1,51 +1,51 @@
 package windex
 
-import (
-	"os"
-)
-
 type Windex struct {
-  watcher *Watcher
-  logfile *LogFile
-  indexer *Indexer
-  logchan chan []byte
+	logfile      *LogFile
+	watcher      *Watcher
+	indexer      *Indexer
+	log_to_index chan []byte
+	exit         chan bool
 }
 
 /*
 
-watched_index, err = windex.New("logfile01.log")
-watched_index.Watch()
-watched_index.Index()
+windex, err = windex.New("logfile01.log")
+err = windex.Watch()
+err = windex.Index()
 // or .Index(StdoutIndex) where StdoutIndex implements
 // Index interface
 
+exit <- windex.exit
+
 Windex methods orchestrate between logfile and indexer,
 getting signals from watcher to know when to act
 
 []byte channel between logfile and indexer
+bool channel between windex and the outside world
 
 */
 func New(filename string) (windex *Windex, err error) {
-	Watcher     *fsnotify.Watcher
-
-        if err != nil {
+	logfile, err := NewLogFile(filename)
+	if err != nil {
 		return nil, err
 	}
 
-	defer file.Close()
-
-	watcher, err := fsnotify.NewWatcher()
+	watcher, err := NewWatcher()
 	if err != nil {
 		return nil, err
 	}
 
-	logfile := &LogFile{}
+	return &Windex{
+		logfile: logfile,
+		watcher: watcher,
+	}, nil
+}
 
-	if err = log.updateFileSize(); err != nil {
-		return nil, err
-	}
+func (windex *Windex) Watch() (err error) {
 
-	return log, nil
 }
 
+func (windex *Windex) Index() (err error) {
 
+}