Update dependencies, fix eslint warnings

Author: garyb

.eslintrc.json

@@ -0,0 +1,28 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 5
+  },
+  "extends": "eslint:recommended",
+  "env": {
+    "commonjs": true
+  },
+  "rules": {
+    "strict": [2, "global"],
+    "block-scoped-var": 2,
+    "consistent-return": 2,
+    "eqeqeq": [2, "smart"],
+    "guard-for-in": 2,
+    "no-caller": 2,
+    "no-extend-native": 2,
+    "no-loop-func": 2,
+    "no-new": 2,
+    "no-param-reassign": 2,
+    "no-return-assign": 2,
+    "no-unused-expressions": 2,
+    "no-use-before-define": 2,
+    "radix": [2, "always"],
+    "indent": [2, 2],
+    "quotes": [2, "double"],
+    "semi": [2, "always"]
+  }
+}

bower.json

@@ -23,17 +23,17 @@
     "tests"
   ],
   "dependencies": {
-    "purescript-aff": "#compiler/0.12",
-    "purescript-effect": "#compiler/0.12",
-    "purescript-maybe": "#compiler/0.12",
-    "purescript-either": "#compiler/0.12",
-    "purescript-functions": "#compiler/0.12",
-    "purescript-exceptions": "#compiler/0.12"
+    "purescript-aff": "^5.0.0",
+    "purescript-effect": "^2.0.0",
+    "purescript-maybe": "^4.0.0",
+    "purescript-either": "^4.0.0",
+    "purescript-functions": "^4.0.0",
+    "purescript-exceptions": "^4.0.0"
   },
   "devDependencies": {
-    "purescript-assert": "#compiler/0.12",
-    "purescript-console": "#compiler/0.12",
-    "purescript-transformers": "#compiler/0.12",
-    "purescript-refs": "#compiler/0.12"
+    "purescript-assert": "^4.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-transformers": "^4.0.0",
+    "purescript-refs": "^4.0.0"
   }
 }

package.json

@@ -2,14 +2,14 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "jshint src --verbose && pulp build -- --censor-lib --strict",
+    "build": "eslint src && pulp build -- --censor-lib --strict",
     "test": "pulp test"
   },
   "devDependencies": {
-    "jshint": "^2.9.5",
-    "pulp": "^12.0.0",
-    "purescript-psa": "^0.5.1",
-    "purescript": "^0.12.0",
-    "rimraf": "^2.6.1"
+    "eslint": "^4.19.1",
+    "pulp": "^12.2.0",
+    "purescript-psa": "^0.6.0",
+    "purescript": "slamdata/node-purescript#0.12",
+    "rimraf": "^2.6.2"
   }
 }

src/Effect/AVar.js

@@ -1,9 +1,8 @@
 /* globals exports, setTimeout */
-/* jshint -W097 */
-
 "use strict";
 
 var AVar = function () {
+
   function MutableQueue () {
     this.head = null;
     this.last = null;
@@ -28,6 +27,16 @@ var AVar = function () {
 
   var EMPTY = {};
 
+  function runEff(eff) {
+    try {
+      eff();
+    } catch (error) {
+      setTimeout(function () {
+        throw error;
+      }, 0);
+    }
+  }
+
   function putLast (queue, value) {
     var cell = new MutableCell(queue, value);
     switch (queue.size) {
@@ -136,8 +145,7 @@ var AVar = function () {
 
     avar.draining = true;
 
-    /* jshint -W084 */
-    while (1) {
+    while (1) { // eslint-disable-line no-constant-condition
       p = null;
       r = null;
       t = null;
@@ -146,13 +154,13 @@ var AVar = function () {
 
       if (avar.error !== null) {
         value = util.left(avar.error);
-        while (p = takeHead(ps)) {
+        while (p = takeHead(ps)) { // eslint-disable-line no-cond-assign
           runEff(p.cb(value));
         }
-        while (r = takeHead(rs)) {
+        while (r = takeHead(rs)) { // eslint-disable-line no-cond-assign
           runEff(r(value));
         }
-        while (t = takeHead(ts)) {
+        while (t = takeHead(ts)) { // eslint-disable-line no-cond-assign
           runEff(t(value));
         }
         break;
@@ -190,21 +198,9 @@ var AVar = function () {
         break;
       }
     }
-    /* jshint +W084 */
-
     avar.draining = false;
   }
 
-  function runEff(eff) {
-    try {
-      eff();
-    } catch (error) {
-      setTimeout(function () {
-        throw error;
-      }, 0);
-    }
-  }
-
   AVar.EMPTY      = EMPTY;
   AVar.putLast    = putLast;
   AVar.takeLast   = takeLast;

test/Main.purs

@@ -60,79 +60,79 @@ test_put_take = test "put/take" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   _ ← AVar.take var $ traverse_ \val →
-    Ref.modify (_ <> val) ref
+    void $ Ref.modify (_ <> val) ref
   eq "barfoo" <$> Ref.read ref
 
 test_put_read_take ∷ Effect Unit
 test_put_read_take = test "put/read/take" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   _ ← AVar.read var $ traverse_ \val →
-    Ref.modify (_ <> val <> "baz") ref
+    void $ Ref.modify (_ <> val <> "baz") ref
   _ ← AVar.take var $ traverse_ \val →
-    Ref.modify (_ <> val) ref
+    void $ Ref.modify (_ <> val) ref
   eq "foobazfoobar" <$> Ref.read ref
 
 test_take_put ∷ Effect Unit
 test_take_put = test "take/put" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.take var $ traverse_ \val →
-    Ref.modify (_ <> val) ref
+    void $ Ref.modify (_ <> val) ref
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   eq "foobar" <$> Ref.read ref
 
 test_take_read_put ∷ Effect Unit
 test_take_read_put = test "take/read/put" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.take var $ traverse_ \val →
-    Ref.modify (_ <> val) ref
+    void $ Ref.modify (_ <> val) ref
   _ ← AVar.read var $ traverse_ \val →
-    Ref.modify (_ <> val <> "baz") ref
+    void $ Ref.modify (_ <> val <> "baz") ref
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   eq "foobazfoobar" <$> Ref.read ref
 
 test_read_put_take ∷ Effect Unit
 test_read_put_take = test "read/put/take" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.read var $ traverse_ \val →
-    Ref.modify (_ <> val <> "baz") ref 
+    void $ Ref.modify (_ <> val <> "baz") ref
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   _ ← AVar.take var $ traverse_ \val → do
-    Ref.modify (_ <> val) ref
+    void $ Ref.modify (_ <> val) ref
   eq "foobazbarfoo" <$> Ref.read ref
 
 test_read_take_put ∷ Effect Unit
 test_read_take_put = test "read/take/put" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.read var $ traverse_ \val → do
-    Ref.modify (_ <> val <> "baz") ref
+    void $ Ref.modify (_ <> val <> "baz") ref
     void $ AVar.take var $ traverse_ \val' →
-      Ref.modify (_ <> val') ref
+      void $ Ref.modify (_ <> val') ref
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   eq "foobazbarfoo" <$> Ref.read ref
 
 test_kill_full ∷ Effect Unit
 test_kill_full = test "kill/full" do
   ref ← Ref.new ""
   var ← AVar.empty
   _ ← AVar.put "foo" var $ traverse_ \_ →
-    Ref.modify (_ <> "bar") ref
+    void $ Ref.modify (_ <> "bar") ref
   AVar.kill (error "Die.") var
   _ ← AVar.read var case _ of
-    Left err → Ref.modify (_ <> message err) ref
-    Right _  → Ref.modify (_ <> "BAD") ref
+    Left err → void $ Ref.modify (_ <> message err) ref
+    Right _  → void $ Ref.modify (_ <> "BAD") ref
   eq "barDie." <$> Ref.read ref
 
 test_kill_empty ∷ Effect Unit
@@ -141,8 +141,8 @@ test_kill_empty = test "kill/empty" do
   var ← AVar.empty
   AVar.kill (error "Die.") var
   _ ← AVar.read var case _ of
-    Left err → Ref.modify (_ <> message err) ref
-    Right _  → Ref.modify (_ <> "BAD") ref
+    Left err → void $ Ref.modify (_ <> message err) ref
+    Right _  → void $ Ref.modify (_ <> "BAD") ref
   eq "Die." <$> Ref.read ref
 
 test_kill_pending ∷ Effect Unit
@@ -151,8 +151,8 @@ test_kill_pending = test "kill/pending" do
   var ← AVar.empty
   let
     cb s = case _ of
-      Left err → Ref.modify (_ <> s <> message err) ref
-      Right _  → Ref.modify (_ <> "BAD") ref
+      Left err → void $ Ref.modify (_ <> s <> message err) ref
+      Right _  → void $ Ref.modify (_ <> "BAD") ref
   _ ← AVar.take var (cb "a")
   _ ← AVar.take var (cb "b")
   _ ← AVar.read var (cb "c")
@@ -164,26 +164,26 @@ test_cancel ∷ Effect Unit
 test_cancel = test "cancel" do
   ref ← Ref.new ""
   v1 ← AVar.new ""
-  c1 ← AVar.put "a" v1 $ traverse_ \_ → Ref.modify (_ <> "a") ref
-  c2 ← AVar.put "b" v1 $ traverse_ \_ → Ref.modify (_ <> "b") ref
-  c3 ← AVar.put "c" v1 $ traverse_ \_ → Ref.modify (_ <> "c") ref
+  c1 ← AVar.put "a" v1 $ traverse_ \_ → void $ Ref.modify (_ <> "a") ref
+  c2 ← AVar.put "b" v1 $ traverse_ \_ → void $ Ref.modify (_ <> "b") ref
+  c3 ← AVar.put "c" v1 $ traverse_ \_ → void $ Ref.modify (_ <> "c") ref
   c1
   c2
   _  ← AVar.tryTake v1
   _  ← AVar.tryTake v1
   _  ← AVar.tryTake v1
   v2 ← AVar.empty
-  c4 ← AVar.take v2 $ traverse_ \_ → Ref.modify (_ <> "d") ref
-  c5 ← AVar.take v2 $ traverse_ \_ → Ref.modify (_ <> "e") ref
-  c6 ← AVar.take v2 $ traverse_ \_ → Ref.modify (_ <> "f") ref
+  c4 ← AVar.take v2 $ traverse_ \_ → void $ Ref.modify (_ <> "d") ref
+  c5 ← AVar.take v2 $ traverse_ \_ → void $ Ref.modify (_ <> "e") ref
+  c6 ← AVar.take v2 $ traverse_ \_ → void $ Ref.modify (_ <> "f") ref
   c5
   _  ← AVar.tryPut "a" v2
   _  ← AVar.tryPut "b" v2
   _  ← AVar.tryPut "c" v2
   v3 ← AVar.empty
-  c7 ← AVar.read v3 $ traverse_ \_ → Ref.modify (_ <> "g") ref
-  c8 ← AVar.read v3 $ traverse_ \_ → Ref.modify (_ <> "h") ref
-  c9 ← AVar.read v3 $ traverse_ \_ → Ref.modify (_ <> "i") ref
+  c7 ← AVar.read v3 $ traverse_ \_ → void $ Ref.modify (_ <> "g") ref
+  c8 ← AVar.read v3 $ traverse_ \_ → void $ Ref.modify (_ <> "h") ref
+  c9 ← AVar.read v3 $ traverse_ \_ → void $ Ref.modify (_ <> "i") ref
   c8
   c9
   _  ← AVar.tryPut "a" v3