Merge pull request #23 from jasonzoladz/master

Updates for psc 0.9.1 and dependencies.

Author: garyb

.travis.yml

@@ -1,18 +1,17 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 5
+node_js: 6
 install:
-  - npm install
   - npm install -g bower
-  - bower install
+  - npm install
 script:
-  - npm run build
+  - bower install --production
+  - npm run -s build
+  - bower install
+  - npm -s test
 after_success:
 - >-
   test $TRAVIS_TAG &&
-  node_modules/.bin/psc-publish > .pursuit.json &&
-  curl -X POST http://pursuit.purescript.org/packages \
-    -d @.pursuit.json \
-    -H 'Accept: application/json' \
-    -H "Authorization: token ${GITHUB_TOKEN}"
+  echo $GITHUB_TOKEN | pulp login &&
+  echo y | pulp publish --no-push

bower.json

@@ -24,20 +24,22 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-aff": "^0.16.0",
-    "purescript-dom": "^0.2.6",
-    "purescript-eff": "^0.1.1",
-    "purescript-either": "^0.2.2",
-    "purescript-globals": "^0.2.1",
-    "purescript-lists": "^0.7.4",
-    "purescript-maps": "^0.5.0",
-    "purescript-maybe": "^0.3.4",
-    "purescript-prelude": "^0.1.2",
-    "purescript-semirings": "^0.2.0",
-    "purescript-tuples": "^0.4.0",
-    "purescript-validation": "^0.2.0"
+    "purescript-dom": "^1.1.0",
+    "purescript-eff": "^1.0.0",
+    "purescript-either": "^1.0.0",
+    "purescript-globals": "^1.0.0",
+    "purescript-lists": "^1.0.1",
+    "purescript-maps": "^1.1.0",
+    "purescript-maybe": "^1.0.0",
+    "purescript-prelude": "^1.0.1",
+    "purescript-semirings": "^1.0.0",
+    "purescript-tuples": "^1.0.0",
+    "purescript-validation": "^1.0.0",
+    "purescript-aff": "^1.0.0",
+    "purescript-control": "^1.0.0",
+    "purescript-console": "^1.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^0.1.0"
+    "purescript-console": "^1.0.0"
   }
 }

package.json

@@ -2,12 +2,13 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp build",
-    "test": "pulp build --include test --to public/test.js"
+    "build": "pulp build --censor-lib --strict",
+    "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^8.1.0",
-    "purescript": "^0.7.6",
-    "rimraf": "^2.5.2"
+    "pulp": "^9.0.1",
+    "purescript-psa": "^0.3.9",
+    "purescript": "^0.9.1",
+    "rimraf": "^2.5.0"
   }
 }

src/Routing.purs

@@ -9,16 +9,16 @@ module Routing (
   matchesAff'
   ) where
 
-import Prelude
+import Prelude (Unit, unit, pure, const, ($))
 import Control.Monad.Eff (Eff())
 import Control.Monad.Aff (Aff(), makeAff)
 import Data.Maybe (Maybe(..))
-import Data.Either (Either(), either)
+import Data.Either (Either(..), either)
 import Data.Tuple (Tuple(..))
-import qualified Data.String.Regex as R
+import Data.String.Regex as R
 
-import Routing.Parser
-import Routing.Match
+import Routing.Parser (parse)
+import Routing.Match (Match, runMatch)
 
 
 foreign import decodeURIComponent :: String -> String
@@ -30,7 +30,10 @@ hashes :: forall e. (String -> String -> Eff e Unit) -> Eff e Unit
 hashes cb =
   hashChanged $ \old new -> do
     cb (dropHash old) (dropHash new)
-  where dropHash h = R.replace (R.regex "^[^#]*#" R.noFlags) "" h
+  where dropHash h =
+          case R.regex "^[^#]*#" R.noFlags of
+            Right regX -> R.replace regX "" h
+            Left _     -> h
 
 
 -- | Stream of hash changed, callback called when new hash can be matched

src/Routing/Hash.purs

@@ -1,6 +1,6 @@
 module Routing.Hash where
 
-import Prelude 
+import Prelude (Unit, (>>=), (<$>))
 import Control.Monad.Eff (Eff())
 import DOM (DOM())
 
@@ -9,4 +9,4 @@ foreign import setHash :: forall e. String -> Eff (dom :: DOM |e) Unit
 foreign import getHash :: forall e. Eff (dom :: DOM |e) String
 
 modifyHash :: forall e. (String -> String) -> Eff (dom :: DOM|e) Unit
-modifyHash fn = (fn <$> getHash) >>= setHash 
+modifyHash fn = (fn <$> getHash) >>= setHash

src/Routing/Hash/Aff.purs

@@ -1,14 +1,13 @@
 module Routing.Hash.Aff where
 
-import Prelude
+import Prelude (($), Unit)
 import DOM (DOM())
 import Control.Monad.Aff (Aff())
 import Control.Monad.Eff.Class (liftEff)
-import qualified Routing.Hash as R
+import Routing.Hash as R
 
-modifyHash :: forall e. (String -> String) -> Aff (dom :: DOM|e) Unit 
-modifyHash func = liftEff $ R.modifyHash func 
+modifyHash :: forall e. (String -> String) -> Aff (dom :: DOM|e) Unit
+modifyHash func = liftEff $ R.modifyHash func
 
-setHash :: forall e. String -> Aff (dom :: DOM|e) Unit 
+setHash :: forall e. String -> Aff (dom :: DOM|e) Unit
 setHash hash = liftEff $ R.setHash hash
-

src/Routing/Match.purs

@@ -1,24 +1,25 @@
 module Routing.Match where
 
-import Prelude
+
+import Prelude (class Applicative, class Apply, class Functor, pure, bind, const, one, id, unit, ($), (<<<), (<$>), (<>), (*), (==))
 import Data.Either (Either(..))
 import Data.Tuple (Tuple(..), snd)
 import Data.Maybe (Maybe(..))
 import Data.List (List(..), reverse)
-import Control.Alt (Alt, (<|>))
-import Control.Plus (Plus)
-import Control.Alternative (Alternative)
+import Control.Alt (class Alt, (<|>))
+import Control.Plus (class Plus)
+import Control.Alternative (class Alternative)
 import Global (readFloat, isNaN)
 import Data.Semiring.Free (Free(), free, runFree)
-import Data.Foldable
-import Data.Validation.Semiring
+import Data.Foldable (foldl)
+import Data.Validation.Semiring (V, invalid, unV)
 
 
-import qualified Data.Map as M
+import Data.Map as M
 
-import Routing.Types
-import Routing.Match.Class
-import Routing.Match.Error
+import Routing.Types (Route, RoutePart(..))
+import Routing.Match.Class (class MatchClass)
+import Routing.Match.Error (MatchError(..), showMatchError)
 
 newtype Match a = Match (Route -> V (Free MatchError) (Tuple Route a))
 unMatch :: forall a. Match a -> (Route -> V (Free MatchError) (Tuple Route a))
@@ -84,7 +85,7 @@ instance matchMatchClass :: MatchClass Match where
 
 instance matchFunctor :: Functor Match where
   map fn (Match r2e) = Match $ \r ->
-    runV invalid (\(Tuple rs a) -> pure $ Tuple rs (fn a)) $ r2e r
+    unV invalid (\(Tuple rs a) -> pure $ Tuple rs (fn a)) $ r2e r
 
 instance matchAlt :: Alt Match where
   alt (Match r2e1) (Match r2e2) = Match $ \r -> do
@@ -97,11 +98,11 @@ instance matchAlternative :: Alternative Match
 
 instance matchApply :: Apply Match where
   apply (Match r2a2b) (Match r2a) =
-    Match $ (\r -> runV (processFnErr r) processFnRes (r2a2b r))
+    Match $ (\r -> unV (processFnErr r) processFnRes (r2a2b r))
     where processFnErr r err =
-            invalid $ err * runV id (const one) (r2a r)
+            invalid $ err * unV id (const one) (r2a r)
           processFnRes (Tuple rs a2b) =
-            runV invalid (\(Tuple rss a) -> pure $ Tuple rss (a2b a)) (r2a rs)
+            unV invalid (\(Tuple rss a) -> pure $ Tuple rss (a2b a)) (r2a rs)
 
 instance matchApplicative :: Applicative Match where
   pure a = Match \r -> pure $ Tuple r a
@@ -113,7 +114,7 @@ list (Match r2a) =
   Match $ go Nil
   where go :: List a -> Route -> V (Free MatchError) (Tuple Route (List a))
         go accum r =
-          runV
+          unV
           (const $ pure (Tuple r (reverse accum)))
           (\(Tuple rs a) -> go (Cons a accum) rs)
           (r2a r)
@@ -125,7 +126,7 @@ list (Match r2a) =
 -- [[String]] -fold with semicolon-> [String] -fold with newline-> String
 runMatch :: forall a. Match a -> Route -> Either String a
 runMatch (Match fn) route =
-  runV foldErrors (Right <<< snd) $ fn route
+  unV foldErrors (Right <<< snd) $ fn route
   where
   foldErrors errs =
     Left $ foldl (\b a -> a <> "\n" <> b) "" do
@@ -151,7 +152,7 @@ runMatch (Match fn) route =
 -- | ```
 eitherMatch :: forall a b. Match (Either a b) -> Match b
 eitherMatch (Match r2eab) = Match $ \r ->
-  runV invalid runEither $ (r2eab r)
+  unV invalid runEither $ (r2eab r)
   where
   runEither (Tuple rs eit) =
     case eit of

src/Routing/Match/Class.purs

@@ -1,7 +1,7 @@
 module Routing.Match.Class where
 
-import Prelude
-import Control.Alternative (Alternative)
+import Prelude (Unit)
+import Control.Alternative (class Alternative)
 import Data.Map as M
 
 class (Alternative f) <= MatchClass f where

src/Routing/Parser.purs

@@ -2,17 +2,16 @@ module Routing.Parser (
   parse
   ) where
 
-import Prelude
+import Prelude (map, bind, (>>>), ($), (<<<), (==), (<*>), (<$>), (<=))
+import Routing.Types (Route, RoutePart(..))
+import Data.Array as A
+import Data.Map as M
+import Data.String as S
 import Control.MonadPlus (guard)
-import Data.Maybe (Maybe(), fromMaybe)
-import Data.Tuple (Tuple(..))
-import Data.List (toList, List())
+import Data.List (fromFoldable, List)
+import Data.Maybe (Maybe, fromMaybe)
 import Data.Traversable (traverse)
-import qualified Data.Map as M
-import qualified Data.String as S
-import qualified Data.Array as A
-
-import Routing.Types
+import Data.Tuple (Tuple(..))
 
 -- | Parse part of hash. Will return `Query (Map String String)` for query
 -- | i.e. `"?foo=bar&bar=baz"` -->
@@ -24,7 +23,7 @@ parsePart str = fromMaybe (Path str) do
     $ traverse part2tuple parts
   where
   parts :: List String
-  parts = toList $ S.split "&" $ S.drop 1 str
+  parts = fromFoldable $ S.split "&" $ S.drop 1 str
 
   part2tuple :: String -> Maybe (Tuple String String)
   part2tuple input = do
@@ -37,4 +36,4 @@ parsePart str = fromMaybe (Path str) do
 -- | applied to every hash part (usually `decodeURIComponent`)
 parse :: (String -> String) -> String -> Route
 parse decoder hash =
-  map ( decoder >>> parsePart ) $ toList (S.split "/" hash)
+  map ( decoder >>> parsePart ) $ fromFoldable (S.split "/" hash)

test/Test/Main.purs

@@ -1,17 +1,16 @@
 module Test.Main where
 
-import Prelude
-import Control.Monad.Eff
-import Control.Monad.Eff.Console
-import Control.Alt
-import Control.Apply
-import Data.List
+import Prelude (class Show, Unit, show, ($), (<$>), (*>), (<*>), (<>))
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE(), logShow)
+import Control.Alt ((<|>))
+import Data.List (List)
 import Data.Map as M
 
 
-import Routing
-import Routing.Match
-import Routing.Match.Class
+import Routing (matchHash)
+import Routing.Match (Match, list)
+import Routing.Match.Class (num, param, bool, lit, params)
 
 data FooBar = Foo Number (M.Map String String) | Bar Boolean String | Baz (List Number)
 
@@ -29,7 +28,10 @@ routing =
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
-  print $ matchHash routing "foo/12/?welp='hi'&b=false"
-  matches routing $ \old new -> void do
-    print old
-    print new
+  logShow $ matchHash routing "foo/12/?welp='hi'&b=false"
+
+  -- (minimal test for browser)
+
+  -- matches routing $ \old new -> void do
+  --   logShow old
+  --   logShow new