Merge pull request #3 from robertroeser/master

cleaned up api

Author: robertroeser

CONTRIBUTING.md

@@ -14,7 +14,7 @@ If you are adding a new file it should have a header like this:
 
 ```
 /**
- * Copyright 2014 Netflix, Inc.
+ * Copyright 2015 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

src/main/java/rx/fileutils/FileSystemEvent.java

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2015 Netflix, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package rx.fileutils;
+
+import java.nio.file.Path;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+
+public class FileSystemEvent {
+    private FileSystemEventKind fileSystemEventKind;
+
+    private Path path;
+
+    FileSystemEvent(WatchEvent event) {
+        WatchEvent.Kind kind = event.kind();
+        if (StandardWatchEventKinds.OVERFLOW != kind) {
+            this.path = (Path) event.context();
+        }
+
+        this.fileSystemEventKind = FileSystemEventKind.toFileSystemEventKind(kind);
+    }
+
+    public FileSystemEventKind getFileSystemEventKind() {
+        return fileSystemEventKind;
+    }
+
+    public Path getPath() {
+        return path;
+    }
+}

src/main/java/rx/fileutils/FileSystemEventKind.java

@@ -0,0 +1,63 @@
+package rx.fileutils;
+
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+/**
+ * Created by rroeser on 7/17/15.
+ */
+public enum FileSystemEventKind {
+    OVERFLOW,
+    ENTRY_CREATE,
+    ENTRY_DELETE,
+    ENTRY_MODIFY;
+
+    static WatchEvent.Kind<?> toWatchEventKind(FileSystemEventKind fileSystemEventKind) {
+        WatchEvent.Kind kind = null;
+
+        switch (fileSystemEventKind) {
+            case OVERFLOW:
+                kind = StandardWatchEventKinds.OVERFLOW;
+                break;
+            case ENTRY_CREATE:
+                kind = StandardWatchEventKinds.ENTRY_CREATE;
+                break;
+            case ENTRY_DELETE:
+                kind = StandardWatchEventKinds.ENTRY_DELETE;
+                break;
+            case ENTRY_MODIFY:
+                kind = StandardWatchEventKinds.ENTRY_MODIFY;
+                break;
+        }
+
+        return kind;
+    }
+
+    static WatchEvent.Kind<?>[] toWatchEventKinds(FileSystemEventKind... fileSystemEventKinds) {
+        return Arrays
+            .asList(fileSystemEventKinds)
+            .stream()
+            .map(FileSystemEventKind::toWatchEventKind)
+            .collect(Collectors.toList())
+            .toArray(new WatchEvent.Kind<?>[fileSystemEventKinds.length]);
+    }
+
+    static FileSystemEventKind toFileSystemEventKind(WatchEvent.Kind<?> watchEventKind) {
+        FileSystemEventKind kind = null;
+
+        if (watchEventKind == StandardWatchEventKinds.OVERFLOW) {
+            kind = OVERFLOW;
+        } else if (watchEventKind == StandardWatchEventKinds.ENTRY_CREATE) {
+            kind = ENTRY_CREATE;
+        } else if (watchEventKind == StandardWatchEventKinds.ENTRY_DELETE) {
+            kind = ENTRY_DELETE;
+        } else if (watchEventKind == StandardWatchEventKinds.ENTRY_MODIFY) {
+            kind = ENTRY_MODIFY;
+        }
+
+        return kind;
+    }
+
+}

…rx/fileutils/WatcherEventObservable.java …java/rx/fileutils/FileSystemWatcher.javasrc/main/java/rx/fileutils/WatcherEventObservable.java renamed to src/main/java/rx/fileutils/FileSystemWatcher.java src/main/java/rx/fileutils/WatcherEventObservable.java renamed to src/main/java/rx/fileutils/FileSystemWatcher.java

@@ -29,12 +29,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import static java.nio.file.StandardWatchEventKinds.OVERFLOW;
-
-/**
- * Created by rroeser on 7/8/15.
- */
-public class WatcherEventObservable extends Observable<WatchEvent<?>> {
+public final class FileSystemWatcher {
 
     static final boolean IS_MAC;
 
@@ -43,39 +38,32 @@ public class WatcherEventObservable extends Observable<WatchEvent<?>> {
         IS_MAC = os.contains("mac");
     }
 
-    protected WatcherEventOnSubscribe watcherEventOnSubscribe;
+    private FileSystemWatcher() {}
 
-    private static class WatcherEventOnSubscribe implements OnSubscribe<WatchEvent<?>> {
+    private static class FileSystemEventOnSubscribe implements Observable.OnSubscribe<FileSystemEvent> {
         private WatchService watcher;
 
         private Scheduler scheduler;
 
         private volatile boolean close = false;
 
-        public void addPath(Path path, WatchEvent.Kind... kinds) throws Exception {
-            if (IS_MAC) {
-                final WatchableFile watchableFile = new WatchableFile(path);
-                watchableFile.register(watcher, kinds);
-            } else {
-                path.register(watcher, kinds, SensitivityWatchEventModifier.HIGH);
-            }
-        }
-
-        public WatcherEventOnSubscribe(Map<Path, WatchEvent.Kind[]> paths, Scheduler scheduler) {
+        public FileSystemEventOnSubscribe(Map<Path, FileSystemEventKind[]> paths, Scheduler scheduler) {
             try {
                 if (IS_MAC) {
                     this.watcher = MacOSXWatchServiceFactory.newWatchService();
 
                     for (Path path : paths.keySet()) {
                         final WatchableFile watchableFile = new WatchableFile(path);
-                        watchableFile.register(watcher, paths.get(path));
+                        FileSystemEventKind[] kinds = paths.get(path);
+                        watchableFile.register(watcher, FileSystemEventKind.toWatchEventKinds(kinds));
                     }
                 }
                 else {
                     this.watcher = FileSystems.getDefault().newWatchService();
 
                     for (Path path : paths.keySet()) {
-                        path.register(watcher, paths.get(path), SensitivityWatchEventModifier.HIGH);
+                        FileSystemEventKind[] kinds = paths.get(path);
+                        path.register(watcher, FileSystemEventKind.toWatchEventKinds(kinds), SensitivityWatchEventModifier.HIGH);
                     }
                 }
                 this.scheduler = scheduler;
@@ -85,8 +73,7 @@ public WatcherEventOnSubscribe(Map<Path, WatchEvent.Kind[]> paths, Scheduler sch
         }
 
         @Override
-        public void call(Subscriber<? super WatchEvent<?>> subscriber) {
-
+        public void call(Subscriber<? super FileSystemEvent> subscriber) {
             Scheduler.Worker worker = scheduler.createWorker();
             subscriber.add(worker);
 
@@ -99,14 +86,10 @@ public void call(Subscriber<? super WatchEvent<?>> subscriber) {
                         }
 
                         for (WatchEvent<?> event : key.pollEvents()) {
-                            WatchEvent.Kind<?> kind = event.kind();
-
-                            if (kind == OVERFLOW) {
-                                continue;
-                            } else {
-                                subscriber.onNext(event);
-                            }
+                            FileSystemEvent fileSystemEvent = new FileSystemEvent(event);
+                            subscriber.onNext(fileSystemEvent);
                         }
+
                         if (!key.reset()) {
                             close();
                         }
@@ -127,64 +110,53 @@ public void close() {
             } catch (Exception e) {}
         }
 
-        public boolean isClosed() {
-            return close;
-        }
     }
 
-    protected WatcherEventObservable(WatcherEventOnSubscribe subscribe) {
-        super(subscribe);
-
-        this.watcherEventOnSubscribe = subscribe;
-    }
+    public static class Builder {
+        private Map<Path, FileSystemEventKind[]> paths = new HashMap<>();
 
-    public static WatcherEventObservable create(Map<Path, WatchEvent.Kind[]> paths, Scheduler scheduler) {
-        try {
-            WatcherEventOnSubscribe watcherEventOnSubscribe
-                = new WatcherEventOnSubscribe(paths, scheduler);
+        private Scheduler scheduler = Schedulers.newThread();
 
-            WatcherEventObservable watcherEventObservable
-                = new WatcherEventObservable(watcherEventOnSubscribe);
+        Builder() {}
 
-            watcherEventObservable
-                .doOnSubscribe(() -> {
-                })
-                .doOnUnsubscribe(watcherEventOnSubscribe::close);
+        public Builder addPath(Path path, FileSystemEventKind... kinds) {
+            paths.put(path, kinds);
 
-            return watcherEventObservable;
-        } catch (Exception e) {
-            throw new RuntimeException(e);
+            return this;
         }
-    }
-
-    public static WatcherEventObservable create(Map<Path, WatchEvent.Kind[]> paths) {
-        return create(paths, Schedulers.newThread());
-    }
 
-    public static WatcherEventObservable create(Path path, WatchEvent.Kind... kinds) {
-        Map<Path, WatchEvent.Kind[]> paths = new HashMap<>();
+        public Builder addPaths(Map<Path, FileSystemEventKind[]> paths) {
+            this.paths.putAll(paths);
 
-        paths.put(path, kinds);
+            return this;
+        }
 
-        return create(paths);
-    }
+        public Builder withScheduler(Scheduler scheduler) {
+            this.scheduler = scheduler;
 
-    public WatcherEventObservable addPath(Path path, WatchEvent.Kind... kinds) {
-        try {
-            watcherEventOnSubscribe.addPath(path, kinds);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
+            return this;
         }
 
-        return this;
-    }
+        public Observable<FileSystemEvent> build() {
+            try {
+                FileSystemEventOnSubscribe fileSystemEventOnSubscribe
+                    = new FileSystemEventOnSubscribe(paths, scheduler);
+
+                Observable<FileSystemEvent> fileSystemEventObservable
+                    = Observable.create(fileSystemEventOnSubscribe);
+
+                fileSystemEventObservable
+                    .doOnUnsubscribe(fileSystemEventOnSubscribe::close);
 
+                return fileSystemEventObservable;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
 
-    public void close() {
-        watcherEventOnSubscribe.close();
     }
 
-    public boolean isClosed() {
-        return watcherEventOnSubscribe.isClosed();
+    public static Builder newBuilder() {
+        return new Builder();
     }
 }

…leutils/WatcherEventOnSubscribeTest.java …tils/FileSystemEventOnSubscribeTest.javasrc/test/java/rx/fileutils/WatcherEventOnSubscribeTest.java renamed to src/test/java/rx/fileutils/FileSystemEventOnSubscribeTest.java src/test/java/rx/fileutils/WatcherEventOnSubscribeTest.java renamed to src/test/java/rx/fileutils/FileSystemEventOnSubscribeTest.java

@@ -16,18 +16,20 @@
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import rx.Observable;
+import rx.Subscription;
 import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.nio.file.Path;
-import java.nio.file.StandardWatchEventKinds;
-import java.nio.file.WatchEvent;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 
-public class WatcherEventOnSubscribeTest {
+public class FileSystemEventOnSubscribeTest {
     private static final String testDirPath = "/tmp/testDirPath-" + UUID.randomUUID().toString();
 
     private static File dir;
@@ -61,28 +63,33 @@ public static void deleteRecursive(File path){
 
     @Test(timeout = 15_000)
     public void testWatchForFileCreateAndModify() throws Exception {
-        HashMap<Path, WatchEvent.Kind[]> paths = new HashMap<>();
+        Map<Path, FileSystemEventKind[]> paths = new HashMap<>();
 
-        paths.put(dir.toPath(), new WatchEvent.Kind[] {
-            StandardWatchEventKinds.ENTRY_CREATE,
-            StandardWatchEventKinds.ENTRY_MODIFY } );
+        paths.put(dir.toPath(), new FileSystemEventKind[] {
+            FileSystemEventKind.ENTRY_CREATE,
+            FileSystemEventKind.ENTRY_MODIFY } );
 
-        WatcherEventObservable watcherEventObservable = WatcherEventObservable.create(paths);
+        Observable<FileSystemEvent> fileSystemWatcher =
+            FileSystemWatcher
+                .newBuilder()
+                .addPaths(paths)
+                .withScheduler(Schedulers.io())
+                .build();
 
         TestSubscriber subscriber = new TestSubscriber();
 
-        CountDownLatch latch = new CountDownLatch(WatcherEventObservable.IS_MAC ? 3 : 2);
-        watcherEventObservable
+        CountDownLatch latch = new CountDownLatch(FileSystemWatcher.IS_MAC ? 3 : 2);
+        Subscription subscribe = fileSystemWatcher
             .doOnNext(a -> {
                 latch.countDown();
-                WatchEvent.Kind<?> kind = a.kind();
+                FileSystemEventKind kind = a.getFileSystemEventKind();
 
                 System.out.println("Got an event for " + kind.name());
 
             })
             .subscribe(subscriber);
 
-        boolean closed = watcherEventObservable.isClosed();
+        boolean closed = subscribe.isUnsubscribed();
 
         Assert.assertFalse(closed);
 
@@ -98,13 +105,13 @@ public void testWatchForFileCreateAndModify() throws Exception {
 
         latch.await();
 
-        watcherEventObservable.close();
+        subscribe.unsubscribe();
 
-        closed = watcherEventObservable.isClosed();
+        closed = subscribe.isUnsubscribed();
 
         Assert.assertTrue(closed);
 
-        if (WatcherEventObservable.IS_MAC) {
+        if (FileSystemWatcher.IS_MAC) {
             subscriber.assertValueCount(3);
         } else {
             subscriber.assertValueCount(2);