Add document readyState

And make it so test failures actually fail the tests

Author: garyb

package.json

@@ -3,7 +3,7 @@
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
     "build": "eslint src && pulp build -- --censor-lib --strict",
-    "test": "PHANTOM_TEST_PATH=$(pwd) pulp test --runtime phantomjs"
+    "test": "pulp test --runtime phantomjs"
   },
   "devDependencies": {
     "eslint": "^3.19.0",

src/DOM/HTML/Document.js

@@ -5,3 +5,9 @@ exports._body = function (doc) {
     return doc.body;
   };
 };
+
+exports._readyState = function (doc) {
+  return function () {
+    return doc.readyState;
+  };
+};

src/DOM/HTML/Document.purs

@@ -1,15 +1,26 @@
 module DOM.HTML.Document
   ( body
+  , readyState
+  , module Exports
   ) where
 
 import Prelude
+
 import Control.Monad.Eff (Eff)
-import Data.Maybe (Maybe)
-import Data.Nullable (Nullable, toMaybe)
 import DOM (DOM)
+import DOM.HTML.Document.ReadyState (ReadyState(..)) as Exports
+import DOM.HTML.Document.ReadyState (ReadyState, parseReadyState)
 import DOM.HTML.Types (HTMLElement, HTMLDocument)
+import Data.Maybe (Maybe, fromJust)
+import Data.Nullable (Nullable, toMaybe)
+import Partial.Unsafe (unsafePartial)
 
 foreign import _body :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Nullable HTMLElement)
 
 body :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Maybe HTMLElement)
 body = map toMaybe <<< _body
+
+foreign import _readyState :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) String
+
+readyState :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) ReadyState
+readyState = map (unsafePartial fromJust <<< parseReadyState) <<< _readyState

src/DOM/HTML/Document/ReadyState.purs

@@ -0,0 +1,60 @@
+module DOM.HTML.Document.ReadyState where
+
+import Prelude
+import Data.Enum (class Enum, class BoundedEnum, Cardinality(..), defaultSucc, defaultPred)
+import Data.Maybe (Maybe(..))
+
+data ReadyState
+  = Loading
+  | Interactive
+  | Complete
+
+derive instance eqReadyState :: Eq ReadyState
+derive instance ordReadyState :: Ord ReadyState
+
+instance showReadyState :: Show ReadyState where
+  show = case _ of
+    Loading -> "Loading"
+    Interactive -> "Interactive"
+    Complete -> "Complete"
+
+printReadyState :: ReadyState -> String
+printReadyState = case _ of
+  Loading -> "loading"
+  Interactive -> "interactive"
+  Complete -> "complete"
+
+parseReadyState :: String -> Maybe ReadyState
+parseReadyState = case _ of
+  "loading" -> Just Loading
+  "interactive" -> Just Interactive
+  "complete" -> Just Complete
+  _ -> Nothing
+
+instance boundedReadyState :: Bounded ReadyState where
+  bottom = Loading
+  top = Complete
+
+instance enumReadyState :: Enum ReadyState where
+  succ = defaultSucc toEnumReadyState fromEnumReadyState
+  pred = defaultPred toEnumReadyState fromEnumReadyState
+
+instance boundedEnumReadyState :: BoundedEnum ReadyState where
+  cardinality = Cardinality 3
+  toEnum = toEnumReadyState
+  fromEnum = fromEnumReadyState
+
+toEnumReadyState :: Int -> Maybe ReadyState
+toEnumReadyState =
+  case _ of
+    0 -> Just Loading
+    1 -> Just Interactive
+    2 -> Just Complete
+    _ -> Nothing
+
+fromEnumReadyState :: ReadyState -> Int
+fromEnumReadyState =
+  case _ of
+    Loading -> 0
+    Interactive -> 1
+    Complete -> 2

test/DOM/HTML/Document.purs

@@ -0,0 +1,18 @@
+module Test.DOM.HTML.Document where
+
+import Prelude
+
+import Control.Monad.Eff.Class (liftEff)
+import DOM (DOM)
+import DOM.HTML (window)
+import DOM.HTML.Document (ReadyState(..), readyState)
+import DOM.HTML.Window (document)
+import Test.Unit (TestSuite, describe, it)
+import Test.Unit.Assert (shouldEqual)
+
+domHtmlDocumentTests :: forall eff. TestSuite (dom :: DOM | eff)
+domHtmlDocumentTests = do
+  describe "readyState" do
+    it "should return a sensible readyState" do
+      rs <- liftEff $ readyState =<< document =<< window
+      rs `shouldEqual` Interactive

test/Main.purs

@@ -1,32 +1,20 @@
 module Test.Main where
 
-import Prelude (($), discard)
-import Control.Monad.Aff (launchAff, Canceler)
+import Prelude
+
 import Control.Monad.Aff.AVar (AVAR)
+import Control.Monad.Aff.Console (CONSOLE)
 import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (liftEff)
-import Control.Monad.Eff.Console (CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
 import DOM (DOM)
 import DOM.HTML.Types (WINDOW)
-import Data.Enum (fromEnum)
-import ExitCodes (ExitCode(Success))
-import PhantomJS.Phantom (exit, PHANTOMJS)
+import Test.DOM.HTML.Document (domHtmlDocumentTests)
 import Test.DOM.HTML.Window (domHtmlWindowTests)
 import Test.DOM.Node.DOMTokenList (domTokenListTests)
-import Test.Unit (describe, it)
-import Test.Unit.Assert (assert)
-import Test.Unit.Output.Simple (runTest)
+import Test.Unit.Console (TESTOUTPUT)
+import Test.Unit.Main (runTest)
 
-main
-  :: forall eff
-   . Eff (exception :: EXCEPTION, console :: CONSOLE, avar :: AVAR, dom :: DOM, window :: WINDOW, phantomjs :: PHANTOMJS | eff)
-         (Canceler (console :: CONSOLE, avar :: AVAR, dom :: DOM, window :: WINDOW, phantomjs :: PHANTOMJS | eff))
-main = launchAff $ runTest do
+main :: forall eff. Eff (console :: CONSOLE, testOutput :: TESTOUTPUT, avar :: AVAR, dom :: DOM, window :: WINDOW | eff) Unit
+main = runTest do
+  domHtmlDocumentTests
   domHtmlWindowTests
   domTokenListTests
-
-  describe "exit" $ do
-    it "should exit" $ do
-      liftEff $ exit (fromEnum Success)
-      assert "failed to exit phantomjs" false