Merge pull request #36 from throughnothing/end-match

Add `end` combinator to support matching end of routes.

Author: cryogenian

src/Routing/Match.purs

@@ -13,7 +13,7 @@ import Data.List (List(..), reverse)
 import Data.Map as M
 import Data.Maybe (Maybe(..))
 import Data.Newtype (class Newtype, unwrap)
-import Data.Semiring.Free (Free(), free)
+import Data.Semiring.Free (Free, free)
 import Data.Tuple (Tuple(..), snd)
 import Data.Validation.Semiring (V, invalid, unV)
 
@@ -93,6 +93,11 @@ instance matchMatchClass :: MatchClass Match where
       _ ->
         invalid $ free ExpectedQuery
 
+  end = Match \route ->
+    case route of
+      Nil -> pure $ Tuple Nil unit
+      _ -> invalid $ free ExpectedEnd
+
   fail msg = Match \_ ->
     invalid $ free $ Fail msg
 

src/Routing/Match/Class.purs

@@ -32,4 +32,7 @@ class (Alternative f) <= MatchClass f where
   -- | `bool` matches any boolean path component.
   bool :: f Boolean
 
+  -- | `end` matches the end of a route.
+  end :: f Unit
+
   fail :: forall a. String -> f a

src/Routing/Match/Error.purs

@@ -7,6 +7,8 @@ data MatchError
   = UnexpectedPath String
     -- expected "true" or "false"
   | ExpectedBoolean
+    -- expected end
+  | ExpectedEnd
     -- expected numeric literal
   | ExpectedNumber
     -- expected integer literal
@@ -31,6 +33,7 @@ showMatchError err =
     ExpectedNumber -> "expected number"
     ExpectedInt -> "expected int"
     ExpectedBoolean -> "expected boolean"
+    ExpectedEnd -> "expected end"
     ExpectedString -> "expected string var"
     ExpectedPathPart -> "expected path part, found query"
     Fail str -> "match error: " <> str

test/Test/Main.purs

@@ -1,41 +1,49 @@
 module Test.Main where
 
-import Prelude (class Show, Unit, discard, show, ($), (<$>), (*>), (<*>), (<>))
+import Prelude (class Show, Unit, discard, show, ($), (<$>), (*>), (<*), (<*>), (<>), append)
 import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE(), logShow)
+import Control.Monad.Eff.Console (CONSOLE(), log)
 import Control.Alt ((<|>))
 import Data.List (List)
 import Data.Map as M
 
 
 import Routing (match)
 import Routing.Match (Match, list)
-import Routing.Match.Class (num, int, param, bool, lit, params)
+import Routing.Match.Class (bool, end, int, lit, num, param, params)
 
 data FooBar
   = Foo Number (M.Map String String)
   | Bar Boolean String
   | Baz (List Number)
   | Quux Int
+  | End Int
 
 instance showFooBar :: Show FooBar where
   show (Foo num q) = "(Foo " <> show num <> " " <> show q <> ")"
   show (Bar bool str) = "(Bar " <> show bool <> " " <> show str <> ")"
   show (Baz lst) = "(Baz " <> show lst <> ")"
   show (Quux i) = "(Quux " <> show i <> ")"
+  show (End i) = "(End " <> show i <> ")"
 
 routing :: Match FooBar
 routing =
   Foo <$> (lit "foo" *> num) <*> params
     <|> Bar <$> (lit "bar" *> bool) <*> (param "baz")
     <|> Quux <$> (lit "" *> lit "quux" *> int)
+    -- Order matters here.  `list` is greedy, and `end` wont match after it
+    <|> End <$> (lit "" *> int <* end)
     <|> Baz <$> (list num)
 
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
-  logShow $ match routing "foo/12/?welp='hi'&b=false"
-  logShow $ match routing "/quux/42"
+  print "Foo: " $ match routing "foo/12/?welp='hi'&b=false" -- foo
+  print "Quux: " $ match routing "/quux/42" -- quux
+  print "Baz: " $ match routing "/123/" -- baz
+  print "End: " $ match routing "/1" -- end
+
+  where print s e = log $ append s $ show e
 
   -- (minimal test for browser)