X-Git-Url: http://git.cielonegro.org/gitweb.cgi?p=Lucu.git;a=blobdiff_plain;f=Network%2FHTTP%2FLucu%2FUtils.hs;h=55acf0adc481929338a4639c7c88118f614a7e76;hp=d6e571dd0fcf3ab0a2ad30c4cd1ac8188516d96c;hb=4e41b11200285142757434e9d67e17ed20fae455;hpb=8f43b567adc06b30a2536ba28b98058d563899ca

diff --git a/Network/HTTP/Lucu/Utils.hs b/Network/HTTP/Lucu/Utils.hs
index d6e571d..55acf0a 100644
--- a/Network/HTTP/Lucu/Utils.hs
+++ b/Network/HTTP/Lucu/Utils.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE
     OverloadedStrings
+  , RecordWildCards
   , TemplateHaskell
   , UnicodeSyntax
   #-}
@@ -11,28 +12,37 @@ module Network.HTTP.Lucu.Utils
     , parseWWWFormURLEncoded
     , splitPathInfo
     , trim
+    , liftByteString
+    , liftLazyByteString
+    , liftAscii
     , liftCIAscii
     , liftText
     , liftMap
+    , liftUTCTime
     )
     where
 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.Unsafe 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 Language.Haskell.TH.Lib
 import Language.Haskell.TH.Syntax
 import Network.URI
 import Prelude hiding (last)
 import Prelude.Unicode
+import System.IO.Unsafe
 
 -- |>>> splitBy (== ':') "ab:c:def"
 -- ["ab", "c", "def"]
@@ -53,15 +63,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 +92,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 +105,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 +114,70 @@ trim = reverse ∘ f ∘ reverse ∘ f
     where
       f = dropWhile isSpace
 
+-- |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
+                 $ unsafePerformIO
+                 $ Strict.unsafePackAddressLen $len $ptr
+               |]
+    where
+      bs ∷ Strict.ByteString
+      bs = A.toByteString a
+
+      len, ptr ∷ Q Exp
+      len = lift $ Strict.length bs
+      ptr = litE $ stringPrimL $ Strict.unpack bs
+
 -- |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 {
+           utctDay     = $(liftDay utctDay)
+         , utctDayTime = $(liftDiffTime utctDayTime)
+         }
+       |]
+
+liftDay ∷ Day → Q Exp
+liftDay (ModifiedJulianDay {..})
+    = [| ModifiedJulianDay {
+           toModifiedJulianDay = $(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