Fix golint errors in windows.go for #116

closes #121
fixes #116

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f806c370ee974ffa4800e93c5d66cf58048db8c..44ca62e5370ecd946256445698d0ddbaa80e9fa7 100644 (file)
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## v1.2.10 / 2016-03-02
+
+* Fix golint errors in windows.go [#121](https://github.com/fsnotify/fsnotify/pull/121) (thanks @tiffanyfj)
+
 ## v1.2.9 / 2016-01-13
 
 kqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsnotify/pull/111) (thanks @bep)

diff --git a/README.md b/README.md
index ec0917a11d0d1bcf5058b52c6af92b50173542f5..ba184c06392b4ccf68932048ce6e396304893c9e 100644 (file)
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # File system notifications for Go
 
-[![GoDoc](https://godoc.org/github.com/fsnotify/fsnotify?status.svg)](https://godoc.org/github.com/fsnotify/fsnotify) [![Coverage](http://gocover.io/_badge/github.com/fsnotify/fsnotify)](http://gocover.io/github.com/fsnotify/fsnotify) 
+[![GoDoc](https://godoc.org/github.com/fsnotify/fsnotify?status.svg)](https://godoc.org/github.com/fsnotify/fsnotify) [![Go Report Card](https://goreportcard.com/badge/github.com/fsnotify/fsnotify)](https://goreportcard.com/report/github.com/fsnotify/fsnotify) [![Coverage](http://gocover.io/_badge/github.com/fsnotify/fsnotify)](http://gocover.io/github.com/fsnotify/fsnotify) 
 
 Go 1.3+ required.
 

diff --git a/windows.go b/windows.go
index 811585227d89bb23ea3246a9d1660ed6b30a84a3..c836bdb3dbb14223af43c6d48af447ef699ff944 100644 (file)
--- a/windows.go
+++ b/windows.go
@@ -71,7 +71,7 @@ func (w *Watcher) Add(name string) error {
        in := &input{
                op:    opAddWatch,
                path:  filepath.Clean(name),
-               flags: sys_FS_ALL_EVENTS,
+               flags: sysFSALLEVENTS,
                reply: make(chan error),
        }
        w.input <- in
@@ -97,43 +97,43 @@ func (w *Watcher) Remove(name string) error {
 
 const (
        // Options for AddWatch
-       sys_FS_ONESHOT = 0x80000000
-       sys_FS_ONLYDIR = 0x1000000
+       sysFSONESHOT = 0x80000000
+       sysFSONLYDIR = 0x1000000
 
        // Events
-       sys_FS_ACCESS      = 0x1
-       sys_FS_ALL_EVENTS  = 0xfff
-       sys_FS_ATTRIB      = 0x4
-       sys_FS_CLOSE       = 0x18
-       sys_FS_CREATE      = 0x100
-       sys_FS_DELETE      = 0x200
-       sys_FS_DELETE_SELF = 0x400
-       sys_FS_MODIFY      = 0x2
-       sys_FS_MOVE        = 0xc0
-       sys_FS_MOVED_FROM  = 0x40
-       sys_FS_MOVED_TO    = 0x80
-       sys_FS_MOVE_SELF   = 0x800
+       sysFSACCESS     = 0x1
+       sysFSALLEVENTS  = 0xfff
+       sysFSATTRIB     = 0x4
+       sysFSCLOSE      = 0x18
+       sysFSCREATE     = 0x100
+       sysFSDELETE     = 0x200
+       sysFSDELETESELF = 0x400
+       sysFSMODIFY     = 0x2
+       sysFSMOVE       = 0xc0
+       sysFSMOVEDFROM  = 0x40
+       sysFSMOVEDTO    = 0x80
+       sysFSMOVESELF   = 0x800
 
        // Special events
-       sys_FS_IGNORED    = 0x8000
-       sys_FS_Q_OVERFLOW = 0x4000
+       sysFSIGNORED   = 0x8000
+       sysFSQOVERFLOW = 0x4000
 )
 
 func newEvent(name string, mask uint32) Event {
        e := Event{Name: name}
-       if mask&sys_FS_CREATE == sys_FS_CREATE || mask&sys_FS_MOVED_TO == sys_FS_MOVED_TO {
+       if mask&sysFSCREATE == sysFSCREATE || mask&sysFSMOVEDTO == sysFSMOVEDTO {
                e.Op |= Create
        }
-       if mask&sys_FS_DELETE == sys_FS_DELETE || mask&sys_FS_DELETE_SELF == sys_FS_DELETE_SELF {
+       if mask&sysFSDELETE == sysFSDELETE || mask&sysFSDELETESELF == sysFSDELETESELF {
                e.Op |= Remove
        }
-       if mask&sys_FS_MODIFY == sys_FS_MODIFY {
+       if mask&sysFSMODIFY == sysFSMODIFY {
                e.Op |= Write
        }
-       if mask&sys_FS_MOVE == sys_FS_MOVE || mask&sys_FS_MOVE_SELF == sys_FS_MOVE_SELF || mask&sys_FS_MOVED_FROM == sys_FS_MOVED_FROM {
+       if mask&sysFSMOVE == sysFSMOVE || mask&sysFSMOVESELF == sysFSMOVESELF || mask&sysFSMOVEDFROM == sysFSMOVEDFROM {
                e.Op |= Rename
        }
-       if mask&sys_FS_ATTRIB == sys_FS_ATTRIB {
+       if mask&sysFSATTRIB == sysFSATTRIB {
                e.Op |= Chmod
        }
        return e
@@ -242,7 +242,7 @@ func (w *Watcher) addWatch(pathname string, flags uint64) error {
        if err != nil {
                return err
        }
-       if flags&sys_FS_ONLYDIR != 0 && pathname != dir {
+       if flags&sysFSONLYDIR != 0 && pathname != dir {
                return nil
        }
        ino, err := getIno(dir)
@@ -302,11 +302,11 @@ func (w *Watcher) remWatch(pathname string) error {
                return fmt.Errorf("can't remove non-existent watch for: %s", pathname)
        }
        if pathname == dir {
-               w.sendEvent(watch.path, watch.mask&sys_FS_IGNORED)
+               w.sendEvent(watch.path, watch.mask&sysFSIGNORED)
                watch.mask = 0
        } else {
                name := filepath.Base(pathname)
-               w.sendEvent(watch.path+"\\"+name, watch.names[name]&sys_FS_IGNORED)
+               w.sendEvent(watch.path+"\\"+name, watch.names[name]&sysFSIGNORED)
                delete(watch.names, name)
        }
        return w.startRead(watch)
@@ -316,13 +316,13 @@ func (w *Watcher) remWatch(pathname string) error {
 func (w *Watcher) deleteWatch(watch *watch) {
        for name, mask := range watch.names {
                if mask&provisional == 0 {
-                       w.sendEvent(watch.path+"\\"+name, mask&sys_FS_IGNORED)
+                       w.sendEvent(watch.path+"\\"+name, mask&sysFSIGNORED)
                }
                delete(watch.names, name)
        }
        if watch.mask != 0 {
                if watch.mask&provisional == 0 {
-                       w.sendEvent(watch.path, watch.mask&sys_FS_IGNORED)
+                       w.sendEvent(watch.path, watch.mask&sysFSIGNORED)
                }
                watch.mask = 0
        }
@@ -353,8 +353,8 @@ func (w *Watcher) startRead(watch *watch) error {
                err := os.NewSyscallError("ReadDirectoryChanges", e)
                if e == syscall.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 {
                        // Watched directory was probably removed
-                       if w.sendEvent(watch.path, watch.mask&sys_FS_DELETE_SELF) {
-                               if watch.mask&sys_FS_ONESHOT != 0 {
+                       if w.sendEvent(watch.path, watch.mask&sysFSDELETESELF) {
+                               if watch.mask&sysFSONESHOT != 0 {
                                        watch.mask = 0
                                }
                        }
@@ -428,7 +428,7 @@ func (w *Watcher) readEvents() {
                        }
                case syscall.ERROR_ACCESS_DENIED:
                        // Watched directory was probably removed
-                       w.sendEvent(watch.path, watch.mask&sys_FS_DELETE_SELF)
+                       w.sendEvent(watch.path, watch.mask&sysFSDELETESELF)
                        w.deleteWatch(watch)
                        w.startRead(watch)
                        continue
@@ -444,7 +444,7 @@ func (w *Watcher) readEvents() {
                var offset uint32
                for {
                        if n == 0 {
-                               w.Events <- newEvent("", sys_FS_Q_OVERFLOW)
+                               w.Events <- newEvent("", sysFSQOVERFLOW)
                                w.Errors <- errors.New("short read in readEvents()")
                                break
                        }
@@ -458,22 +458,22 @@ func (w *Watcher) readEvents() {
                        var mask uint64
                        switch raw.Action {
                        case syscall.FILE_ACTION_REMOVED:
-                               mask = sys_FS_DELETE_SELF
+                               mask = sysFSDELETESELF
                        case syscall.FILE_ACTION_MODIFIED:
-                               mask = sys_FS_MODIFY
+                               mask = sysFSMODIFY
                        case syscall.FILE_ACTION_RENAMED_OLD_NAME:
                                watch.rename = name
                        case syscall.FILE_ACTION_RENAMED_NEW_NAME:
                                if watch.names[watch.rename] != 0 {
                                        watch.names[name] |= watch.names[watch.rename]
                                        delete(watch.names, watch.rename)
-                                       mask = sys_FS_MOVE_SELF
+                                       mask = sysFSMOVESELF
                                }
                        }
 
                        sendNameEvent := func() {
                                if w.sendEvent(fullname, watch.names[name]&mask) {
-                                       if watch.names[name]&sys_FS_ONESHOT != 0 {
+                                       if watch.names[name]&sysFSONESHOT != 0 {
                                                delete(watch.names, name)
                                        }
                                }
@@ -482,11 +482,11 @@ func (w *Watcher) readEvents() {
                                sendNameEvent()
                        }
                        if raw.Action == syscall.FILE_ACTION_REMOVED {
-                               w.sendEvent(fullname, watch.names[name]&sys_FS_IGNORED)
+                               w.sendEvent(fullname, watch.names[name]&sysFSIGNORED)
                                delete(watch.names, name)
                        }
                        if w.sendEvent(fullname, watch.mask&toFSnotifyFlags(raw.Action)) {
-                               if watch.mask&sys_FS_ONESHOT != 0 {
+                               if watch.mask&sysFSONESHOT != 0 {
                                        watch.mask = 0
                                }
                        }
@@ -529,16 +529,16 @@ func (w *Watcher) sendEvent(name string, mask uint64) bool {
 
 func toWindowsFlags(mask uint64) uint32 {
        var m uint32
-       if mask&sys_FS_ACCESS != 0 {
+       if mask&sysFSACCESS != 0 {
                m |= syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS
        }
-       if mask&sys_FS_MODIFY != 0 {
+       if mask&sysFSMODIFY != 0 {
                m |= syscall.FILE_NOTIFY_CHANGE_LAST_WRITE
        }
-       if mask&sys_FS_ATTRIB != 0 {
+       if mask&sysFSATTRIB != 0 {
                m |= syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES
        }
-       if mask&(sys_FS_MOVE|sys_FS_CREATE|sys_FS_DELETE) != 0 {
+       if mask&(sysFSMOVE|sysFSCREATE|sysFSDELETE) != 0 {
                m |= syscall.FILE_NOTIFY_CHANGE_FILE_NAME | syscall.FILE_NOTIFY_CHANGE_DIR_NAME
        }
        return m
@@ -547,15 +547,15 @@ func toWindowsFlags(mask uint64) uint32 {
 func toFSnotifyFlags(action uint32) uint64 {
        switch action {
        case syscall.FILE_ACTION_ADDED:
-               return sys_FS_CREATE
+               return sysFSCREATE
        case syscall.FILE_ACTION_REMOVED:
-               return sys_FS_DELETE
+               return sysFSDELETE
        case syscall.FILE_ACTION_MODIFIED:
-               return sys_FS_MODIFY
+               return sysFSMODIFY
        case syscall.FILE_ACTION_RENAMED_OLD_NAME:
-               return sys_FS_MOVED_FROM
+               return sysFSMOVEDFROM
        case syscall.FILE_ACTION_RENAMED_NEW_NAME:
-               return sys_FS_MOVED_TO
+               return sysFSMOVEDTO
        }
        return 0
 }