path-pieces 0.0.0 → 0.1.0

raw patch · 3 files changed

+153/−39 lines, 3 filesdep +HUnitdep +QuickCheckdep +file-locationdep ~textPVP ok

version bump matches the API change (PVP)

Dependencies added: HUnit, QuickCheck, file-location, hspec, path-pieces

Dependency ranges changed: text

API changes (from Hackage documentation)

Files

• Web/PathPieces.hs +67/−37
• path-pieces.cabal +16/−2
• test/main.hs +70/−0

@@ -1,8 +1,12 @@-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances, TypeSynonymInstances  #-} module Web.PathPieces-    ( SinglePiece (..)-    , MultiPiece (..)+    ( PathPiece (..)+    , PathMultiPiece (..)+    -- * Deprecated+    , toSinglePiece+    , toMultiPiece+    , fromSinglePiece+    , fromMultiPiece     ) where  import Data.Int (Int64)@@ -10,46 +14,72 @@ import qualified Data.Text.Lazy as L import qualified Data.Text.Read -class SinglePiece s where-    fromSinglePiece :: S.Text -> Maybe s-    toSinglePiece :: s -> S.Text-instance SinglePiece String where-    fromSinglePiece s = if S.null s then Nothing else Just (S.unpack s)-    toSinglePiece = S.pack-instance SinglePiece S.Text where-    fromSinglePiece s = if S.null s then Nothing else Just s-    toSinglePiece = id-instance SinglePiece L.Text where-    fromSinglePiece s = if S.null s then Nothing else Just (L.fromChunks [s])-    toSinglePiece = S.concat . L.toChunks-instance SinglePiece Integer where-    fromSinglePiece s =+class PathPiece s where+    fromPathPiece :: S.Text -> Maybe s+    toPathPiece :: s -> S.Text++instance PathPiece String where+    fromPathPiece s = if S.null s then Nothing else Just (S.unpack s)+    toPathPiece = S.pack++instance PathPiece S.Text where+    fromPathPiece s = if S.null s then Nothing else Just s+    toPathPiece = id++instance PathPiece L.Text where+    fromPathPiece s = if S.null s then Nothing else Just (L.fromChunks [s])+    toPathPiece = S.concat . L.toChunks++instance PathPiece Integer where+    fromPathPiece s =         case Data.Text.Read.decimal s of             Right (i, _) -> Just i             Left _ -> Nothing-    toSinglePiece = S.pack . show-instance SinglePiece Int where-    fromSinglePiece s =+    toPathPiece = S.pack . show++instance PathPiece Int where+    fromPathPiece s =         case Data.Text.Read.decimal s of             Right (i, _) -> Just i             Left _ -> Nothing-    toSinglePiece = S.pack . show-instance SinglePiece Int64 where-    fromSinglePiece s =+    toPathPiece = S.pack . show++instance PathPiece Int64 where+    fromPathPiece s =         case Data.Text.Read.decimal s of             Right (i, _) -> Just i             Left _ -> Nothing-    toSinglePiece = S.pack . show+    toPathPiece = S.pack . show -class MultiPiece s where-    fromMultiPiece :: [S.Text] -> Maybe s-    toMultiPiece :: s -> [S.Text]-instance MultiPiece [String] where-    fromMultiPiece = Just . map S.unpack-    toMultiPiece = map S.pack-instance MultiPiece [S.Text] where-    fromMultiPiece = Just-    toMultiPiece = id-instance MultiPiece [L.Text] where-    fromMultiPiece = Just . map (L.fromChunks . return)-    toMultiPiece = map $ S.concat . L.toChunks++class PathMultiPiece s where+    fromPathMultiPiece :: [S.Text] -> Maybe s+    toPathMultiPiece :: s -> [S.Text]++instance PathMultiPiece [String] where+    fromPathMultiPiece = Just . map S.unpack+    toPathMultiPiece = map S.pack++instance PathMultiPiece [S.Text] where+    fromPathMultiPiece = Just+    toPathMultiPiece = id++instance PathMultiPiece [L.Text] where+    fromPathMultiPiece = Just . map (L.fromChunks . return)+    toPathMultiPiece = map $ S.concat . L.toChunks++{-# DEPRECATED toSinglePiece "Use toPathPiece instead of toSinglePiece" #-}+toSinglePiece :: PathPiece p => p -> S.Text+toSinglePiece = toPathPiece++{-# DEPRECATED fromSinglePiece "Use fromPathPiece instead of fromSinglePiece" #-}+fromSinglePiece :: PathPiece p => S.Text -> Maybe p+fromSinglePiece = fromPathPiece++{-# DEPRECATED toMultiPiece "Use toPathMultiPiece instead of toMultiPiece" #-}+toMultiPiece :: PathMultiPiece ps => ps -> [S.Text]+toMultiPiece = toPathMultiPiece++{-# DEPRECATED fromMultiPiece "Use fromPathMultiPiece instead of fromMultiPiece" #-}+fromMultiPiece :: PathMultiPiece ps => [S.Text] -> Maybe ps+fromMultiPiece = fromPathMultiPiece

@@ -1,5 +1,5 @@ name:            path-pieces-version:         0.0.0+version:         0.1.0 license:         BSD3 license-file:    LICENSE author:          Michael Snoyman <michael@snoyman.com>@@ -7,15 +7,29 @@ synopsis:        Components of paths. category:        Web, Yesod stability:       unstable-cabal-version:   >= 1.6+cabal-version:   >= 1.8 build-type:      Simple homepage:        http://github.com/snoyberg/path-pieces+extra-source-files: test/main.hs  library     build-depends:   base             >= 4       && < 5                    , text             >= 0.5     && < 0.12     exposed-modules: Web.PathPieces     ghc-options:     -Wall++test-suite test+    type:          exitcode-stdio-1.0+    main-is:       main.hs+    hs-source-dirs: test+    ghc-options:   -Wall+    build-depends:   HUnit+                   , hspec >= 0.8 && < 0.9+                   , file-location >= 0.4 && < 0.5+                   , base >= 4 && < 5+                   , QuickCheck == 2.4.*+                   , path-pieces+                   , text  source-repository head   type:     git

@@ -0,0 +1,70 @@+{-# Language ScopedTypeVariables #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+module Main where++import Test.Hspec.Monadic (Specs, describe, hspecX)+import Test.Hspec.HUnit()+import Test.Hspec.QuickCheck(prop)+import Test.QuickCheck++import Web.PathPieces+import qualified Data.Text as T+import Data.Maybe (fromJust)++-- import FileLocation (debug)++instance Arbitrary T.Text where+  arbitrary = fmap T.pack arbitrary+++main :: IO ()+main = hspecX specs++specs :: Specs+specs = do+  describe "RoutePiece" $ do+    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::String) ->+      case (fromRoutePiece . toSinglePiece) p of+        Nothing -> null p+        Just pConverted -> p == pConverted++    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::T.Text) ->+      case (fromRoutePiece . toSinglePiece) p of+        Nothing -> T.null p+        Just pConverted -> p == pConverted++    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::Int) ->+      case (fromRoutePiece . toSinglePiece) p of+        Nothing -> p < 0+        Just pConverted -> p == pConverted++  describe "RouteMultiPiece" $ do+    prop "toRouteMultiPiece <=> fromMultiPiece String" $ \(p::[String]) ->+      p == (fromJust . fromRouteMultiPiece . toMultiPiece) p++    prop "toRouteMultiPiece <=> fromMultiPiece String" $ \(p::[T.Text]) ->+      p == (fromJust . fromRouteMultiPiece . toMultiPiece) p+++  describe "SinglePiece" $ do+    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::String) ->+      case (fromSinglePiece . toSinglePiece) p of+        Nothing -> null p+        Just pConverted -> p == pConverted++    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::T.Text) ->+      case (fromSinglePiece . toSinglePiece) p of+        Nothing -> T.null p+        Just pConverted -> p == pConverted++    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::Int) ->+      case (fromSinglePiece . toSinglePiece) p of+        Nothing -> p < 0+        Just pConverted -> p == pConverted++  describe "MultiPiece" $ do+    prop "toMultiPiece <=> fromMultiPiece String" $ \(p::[String]) ->+      p == (fromJust . fromMultiPiece . toMultiPiece) p++    prop "toMultiPiece <=> fromMultiPiece String" $ \(p::[T.Text]) ->+      p == (fromJust . fromMultiPiece . toMultiPiece) p