Merge pull request #25 from beckyconning/ready/repeatedlyTryTo

Added repeatedlyTryTo function

Author: cryogenian

bower.json

@@ -17,8 +17,9 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
-    "purescript-base": "^0.2.0",
     "purescript-aff": "^0.11.3",
+    "purescript-aff-reattempt": "^0.1.0",
+    "purescript-base": "^0.2.0",
     "purescript-dom": "^0.2.4"
   }
 }

docs/Selenium/Monad.md

@@ -7,7 +7,7 @@ putting `Driver` to `ReaderT`
 #### `Selenium`
 
 ``` purescript
-type Selenium e o a = ReaderT { driver :: Driver | o } (Aff (console :: CONSOLE, selenium :: SELENIUM, dom :: DOM | e)) a
+type Selenium e o a = ReaderT { driver :: Driver, defaultTimeout :: Int | o } (Aff (console :: CONSOLE, selenium :: SELENIUM, dom :: DOM, ref :: REF | e)) a
 ```
 
 `Driver` is field of `ReaderT` context
@@ -94,6 +94,22 @@ get :: forall e o. String -> Selenium e o Unit
 wait :: forall e o. Selenium e o Boolean -> Int -> Selenium e o Unit
 ```
 
+#### `tryRepeatedlyTo'`
+
+``` purescript
+tryRepeatedlyTo' :: forall a e o. Int -> Selenium e o a -> Selenium e o a
+```
+
+Tries the provided Selenium computation repeatedly until the provided timeout expires
+
+#### `tryRepeatedlyTo`
+
+``` purescript
+tryRepeatedlyTo :: forall a e o. Selenium e o a -> Selenium e o a
+```
+
+Tries the provided Selenium computation repeatedly until `Selenium`'s defaultTimeout expires
+
 #### `byCss`
 
 ``` purescript
@@ -283,7 +299,7 @@ Run sequence of actions
 #### `actions`
 
 ``` purescript
-actions :: forall e o. ({ driver :: Driver | o } -> Sequence Unit) -> Selenium e o Unit
+actions :: forall e o. ({ driver :: Driver, defaultTimeout :: Int | o } -> Sequence Unit) -> Selenium e o Unit
 ```
 
 Same as `sequence` but takes function of `ReaderT` as an argument

src/Selenium.purs

@@ -63,6 +63,7 @@ foreign import get :: forall e. Driver -> String -> Aff (selenium :: SELENIUM|e)
 foreign import wait :: forall e. Aff (selenium :: SELENIUM|e) Boolean ->
                                  Int -> Driver ->
                                  Aff (selenium :: SELENIUM|e) Unit
+
 -- | Finalizer
 foreign import quit :: forall e. Driver -> Aff (selenium :: SELENIUM|e) Unit
 

src/Selenium/Combinators.purs

@@ -59,23 +59,6 @@ contra check = do
     (const $ pure unit)
     (const $ throwError $ error "check successed in contra") eR 
 
--- | takes value and repeatedly tries to evaluate it for timeout of ms (second arg)
--- | if it evaluates w/o error returns its value
--- | else throws error 
-waiter :: forall e o a. Selenium e o a -> Int -> Selenium e o a
-waiter getter timeout = do
-  wait (checker $ (isRight <$> attempt getter)) timeout
-  getter
-
-waitExistentCss :: forall e o. String -> Int -> Selenium e o Element
-waitExistentCss css timeout =
-  waiter (getElementByCss css) timeout
-
-waitNotExistentCss :: forall e o. String -> Int -> Selenium e o Unit
-waitNotExistentCss css timeout =
-  waiter (checkNotExistsByCss css) timeout
-
-
 -- | Repeatedly tries to evaluate check (third arg) for timeout ms (first arg)
 -- | finishes when check evaluates to true.
 -- | If there is an error during check or it constantly returns `false`
@@ -87,6 +70,5 @@ await timeout check = do
     Left _ -> throwError $ error "await has no success"
     Right _ -> pure unit 
 
-
 awaitUrlChanged :: forall e o. String -> Selenium e o Boolean
 awaitUrlChanged oldURL = checker $ (oldURL /=) <$> getCurrentUrl 

src/Selenium/Monad.purs

@@ -14,10 +14,12 @@ import Data.List
 import DOM
 import Selenium.Types
 import Control.Monad.Eff.Console (CONSOLE())
+import Control.Monad.Eff.Ref (REF())
 import Control.Monad.Trans
 import Control.Monad.Reader.Trans
 import Control.Monad.Reader.Class
 import qualified Control.Monad.Aff as A
+import qualified Control.Monad.Aff.Reattempt as A
 import qualified Selenium as S
 import qualified Selenium.ActionSequence as S
 import qualified Selenium.XHR as S
@@ -26,8 +28,8 @@ import qualified Selenium.XHR as S
 -- | timeouts) all those configs can be putted to `Selenium e o a`
 type Selenium e o a =
   ReaderT
-    {driver :: Driver |o}
-    (A.Aff (console :: CONSOLE, selenium :: SELENIUM, dom :: DOM |e)) a
+    {driver :: Driver, defaultTimeout :: Int |o}
+    (A.Aff (console :: CONSOLE, selenium :: SELENIUM, dom :: DOM, ref :: REF |e)) a
 
 -- | get driver from context
 getDriver :: forall e o. Selenium e o Driver
@@ -77,6 +79,15 @@ wait :: forall e o. Selenium e o Boolean -> Int -> Selenium e o Unit
 wait check time = ReaderT \r ->
   S.wait (runReaderT check r) time r.driver
 
+-- | Tries the provided Selenium computation repeatedly until the provided timeout expires
+tryRepeatedlyTo' :: forall a e o. Int -> Selenium e o a -> Selenium e o a
+tryRepeatedlyTo' time selenium = ReaderT \r ->
+  A.reattempt time (runReaderT selenium r)
+
+-- | Tries the provided Selenium computation repeatedly until `Selenium`'s defaultTimeout expires
+tryRepeatedlyTo :: forall a e o. Selenium e o a -> Selenium e o a
+tryRepeatedlyTo selenium = ask >>= \r -> tryRepeatedlyTo' r.defaultTimeout selenium
+
 byCss :: forall e o. String -> Selenium e o Locator
 byCss = lift <<< S.byCss
 
@@ -182,7 +193,7 @@ sequence seq = do
   getDriver >>= lift <<< flip S.sequence seq
 
 -- | Same as `sequence` but takes function of `ReaderT` as an argument
-actions :: forall e o. ({driver :: Driver |o} -> S.Sequence Unit) -> Selenium e o Unit
+actions :: forall e o. ({driver :: Driver, defaultTimeout :: Int |o} -> S.Sequence Unit) -> Selenium e o Unit
 actions seqFn = do
   ctx <- ask
   sequence $ seqFn ctx