Don't use the unix package at all.

[Lucu.git] / Network / HTTP / Lucu / Utils.hs

diff --git a/Network/HTTP/Lucu/Utils.hs b/Network/HTTP/Lucu/Utils.hs
index d6e571dd0fcf3ab0a2ad30c4cd1ac8188516d96c..c07c9c9cf94891bf82213f5c24edf293ef534f12 100644 (file)
--- a/Network/HTTP/Lucu/Utils.hs
+++ b/Network/HTTP/Lucu/Utils.hs
@@ -1,38 +1,52 @@
 {-# LANGUAGE
     OverloadedStrings
+  , RecordWildCards
   , TemplateHaskell
   , UnicodeSyntax
   #-}
--- |Utility functions used internally in the Lucu httpd. These
--- functions may be useful too for something else.
+-- |Utility functions used internally in this package.
 module Network.HTTP.Lucu.Utils
     ( splitBy
     , quoteStr
     , parseWWWFormURLEncoded
     , splitPathInfo
     , trim
+
+    , getLastModified
+
+    , liftByteString
+    , liftLazyByteString
+    , liftAscii
     , liftCIAscii
     , liftText
     , liftMap
+    , liftUTCTime
     )
     where
+import Control.Applicative
 import Control.Monad
 import Data.Ascii (Ascii, CIAscii, AsciiBuilder)
 import qualified Data.Ascii as A
 import Data.ByteString (ByteString)
-import qualified Data.ByteString.Char8 as BS
+import qualified Data.ByteString.Char8 as Strict
+import qualified Data.ByteString.Lazy.Internal as Lazy
 import Data.Char
 import Data.List hiding (last)
 import Data.Map (Map)
 import qualified Data.Map as M
 import Data.Monoid.Unicode
+import Data.Ratio
 import Data.Text (Text)
 import qualified Data.Text as T
+import Data.Time
+import Data.Time.Clock.POSIX
 import Language.Haskell.TH.Lib
 import Language.Haskell.TH.Syntax
 import Network.URI
 import Prelude hiding (last)
 import Prelude.Unicode
+import System.Directory
+import System.Time (ClockTime(..))
 
 -- |>>> splitBy (== ':') "ab:c:def"
 -- ["ab", "c", "def"]
@@ -53,15 +67,17 @@ quoteStr str = A.toAsciiBuilder "\"" ⊕
                go (A.toByteString str) (∅) ⊕
                A.toAsciiBuilder "\""
     where
-      go ∷ BS.ByteString → AsciiBuilder → AsciiBuilder
+      go ∷ Strict.ByteString → AsciiBuilder → AsciiBuilder
       go bs ab
-          = case BS.break (≡ '"') bs of
+          = case Strict.break (≡ '"') bs of
               (x, y)
-                  | BS.null y → ab ⊕ b2ab x
-                  | otherwise → go (BS.tail y) (ab ⊕ b2ab x
-                                                   ⊕ A.toAsciiBuilder "\\\"")
+                  | Strict.null y
+                      → ab ⊕ b2ab x
+                  | otherwise
+                      → go (Strict.tail y)
+                           (ab ⊕ b2ab x ⊕ A.toAsciiBuilder "\\\"")
 
-      b2ab ∷ BS.ByteString → AsciiBuilder
+      b2ab ∷ Strict.ByteString → AsciiBuilder
       b2ab = A.toAsciiBuilder ∘ A.unsafeFromByteString
 
 -- |>>> parseWWWFormURLEncoded "aaa=bbb&ccc=ddd"
@@ -80,7 +96,7 @@ parseWWWFormURLEncoded src
                             )
     where
       unescape ∷ String → ByteString
-      unescape = BS.pack ∘ unEscapeString ∘ map plusToSpace
+      unescape = Strict.pack ∘ unEscapeString ∘ map plusToSpace
 
       plusToSpace ∷ Char → Char
       plusToSpace '+' = ' '
@@ -93,7 +109,7 @@ splitPathInfo uri
     = let reqPathStr = uriPath uri
           reqPath    = [unEscapeString x | x ← splitBy (≡ '/') reqPathStr, (¬) (null x)]
       in
-        map BS.pack reqPath
+        map Strict.pack reqPath
 
 -- |>>> trim "  ab c d "
 -- "ab c d"
@@ -102,24 +118,63 @@ trim = reverse ∘ f ∘ reverse ∘ f
     where
       f = dropWhile isSpace
 
+-- |Get the modification time of a given file.
+getLastModified ∷ FilePath → IO UTCTime
+getLastModified = (clockTimeToUTC <$>) ∘ getModificationTime
+    where
+      clockTimeToUTC ∷ ClockTime → UTCTime
+      clockTimeToUTC (TOD sec picoSec)
+          = posixSecondsToUTCTime
+            $ fromRational
+            $ sec % 1 + picoSec % (1000 ⋅ 1000 ⋅ 1000 ⋅ 1000)
+
+-- |Convert a 'ByteString' to an 'Exp' representing it as a literal.
+liftByteString ∷ ByteString → Q Exp
+liftByteString bs
+    = [| Strict.pack $(litE $ stringL $ Strict.unpack bs) |]
+
+-- |Convert a 'Lazy.ByteString' to an 'Exp' representing it as a
+-- literal.
+liftLazyByteString ∷ Lazy.ByteString → Q Exp
+liftLazyByteString = Lazy.foldrChunks f [| Lazy.Empty |]
+    where
+      f ∷ ByteString → Q Exp → Q Exp
+      f bs e = [| Lazy.Chunk $(liftByteString bs) $e |]
+
+-- |Convert an 'Ascii' to an 'Exp' representing it as a literal.
+liftAscii ∷ Ascii → Q Exp
+liftAscii a = [| A.unsafeFromByteString $(liftByteString $ A.toByteString a) |]
+
 -- |Convert a 'CIAscii' to an 'Exp' representing it as a literal.
 liftCIAscii ∷ CIAscii → Q Exp
-liftCIAscii a = [| A.toCIAscii (A.unsafeFromString $(strLit a)) |]
-    where
-      strLit ∷ CIAscii → Q Exp
-      strLit = liftString ∘ A.toString ∘ A.fromCIAscii
+liftCIAscii a = [| A.toCIAscii $(liftAscii $ A.fromCIAscii a) |]
 
 -- |Convert a 'Text' to an 'Exp' representing it as a literal.
 liftText ∷ Text → Q Exp
-liftText t = [| T.pack $(strLit t) |]
-    where
-      strLit ∷ Text → Q Exp
-      strLit = liftString ∘ T.unpack
+liftText t = [| T.pack $(litE $ stringL $ T.unpack t) |]
 
 -- |Convert an arbitrary 'Map' to an 'Exp' representing it as a
 -- literal, using a given key lifter and a value lifter.
 liftMap ∷ Eq k ⇒ (k → Q Exp) → (v → Q Exp) → Map k v → Q Exp
-liftMap liftK liftV m = [| M.fromAscList $(liftPairs $ M.toAscList m) |]
+liftMap liftK liftV m
+    | M.null m  = [| M.empty |]
+    | otherwise = [| M.fromDistinctAscList $(liftPairs (M.toAscList m)) |]
     where
       liftPairs       = listE ∘ map liftPair
       liftPair (k, v) = tupE [liftK k, liftV v]
+
+-- |Convert an 'UTCTime' to an 'Exp' representing it as a literal.
+liftUTCTime ∷ UTCTime → Q Exp
+liftUTCTime (UTCTime {..})
+    = [| UTCTime $(liftDay utctDay) $(liftDiffTime utctDayTime) |]
+
+liftDay ∷ Day → Q Exp
+liftDay (ModifiedJulianDay {..})
+    = [| ModifiedJulianDay $(lift toModifiedJulianDay) |]
+
+liftDiffTime ∷ DiffTime → Q Exp
+liftDiffTime dt = [| fromRational ($n % $d) ∷ DiffTime |]
+    where
+      n, d ∷ Q Exp
+      n = lift $ numerator   $ toRational dt
+      d = lift $ denominator $ toRational dt