diff --git a/Text/JSON/YAJL/Enumerator.hs b/Text/JSON/YAJL/Enumerator.hs --- a/Text/JSON/YAJL/Enumerator.hs +++ b/Text/JSON/YAJL/Enumerator.hs @@ -9,10 +9,9 @@ -- ----------------------------------------------------------------------------- module Text.JSON.YAJL.Enumerator - ( Event (..) - + ( -- * Parsing - , parseBytesIO + parseBytesIO , parseBytesST -- * Generating @@ -28,9 +27,11 @@ import qualified Data.ByteString as B import qualified Data.Text as T import qualified Data.Text.Encoding as TE +import qualified Data.Text.Lazy as TL import qualified Data.Enumerator as E import Data.Enumerator ((>>==)) import qualified Text.JSON.YAJL as Y +import qualified Data.JSON.Types as J import Control.Exception as Exc import Control.Monad.IO.Class (MonadIO, liftIO) @@ -39,21 +40,10 @@ import qualified Data.STRef as ST import qualified Data.IORef as IO -data Event - = EventNull - | EventBoolean Bool - | EventNumber B.ByteString - | EventText T.Text - | EventBeginArray - | EventEndArray - | EventBeginObject - | EventAttributeName T.Text - | EventEndObject - deriving (Show, Eq) - -- Parser {{{ -parseBytesIO :: MonadIO m => E.Enumeratee B.ByteString Event m b +-- | Requires input to be in UTF-8 +parseBytesIO :: MonadIO m => E.Enumeratee B.ByteString J.Event m b parseBytesIO s = do (p, eventRef) <- liftIO newParserIO @@ -67,7 +57,8 @@ let complete = withEvents (Y.parseComplete p) eneeParser (liftIO (Y.getBytesConsumed p)) parseChunk complete s -parseBytesST :: E.Enumeratee B.ByteString Event (ST s) b +-- | Requires input to be in UTF-8 +parseBytesST :: E.Enumeratee B.ByteString J.Event (ST s) b parseBytesST s = do (p, eventRef) <- lift newParserST @@ -81,7 +72,7 @@ let complete = withEvents (Y.parseComplete p) eneeParser (Y.getBytesConsumed p) parseChunk complete s -newParserIO :: IO (Y.Parser IO, IO.IORef [Event]) +newParserIO :: IO (Y.Parser IO, IO.IORef [J.Event]) newParserIO = do p <- Y.newParserIO eventRef <- IO.newIORef [] @@ -89,7 +80,7 @@ setCallbacks p addEvent return (p, eventRef) -newParserST :: ST s (Y.Parser (ST s), ST.STRef s [Event]) +newParserST :: ST s (Y.Parser (ST s), ST.STRef s [J.Event]) newParserST = do p <- Y.newParserST eventRef <- ST.newSTRef [] @@ -97,25 +88,28 @@ setCallbacks p addEvent return (p, eventRef) -setCallbacks :: Monad m => Y.Parser m -> (Event -> m Bool) -> m () +setCallbacks :: Monad m => Y.Parser m -> (J.Event -> m Bool) -> m () setCallbacks p addEvent = do let set = Y.setCallback p - set Y.parsedBeginArray (addEvent EventBeginArray) - set Y.parsedEndArray (addEvent EventEndArray) - set Y.parsedBeginObject (addEvent EventBeginObject) - set Y.parsedEndObject (addEvent EventEndObject) - set Y.parsedNull (addEvent EventNull) - set Y.parsedBoolean (addEvent . EventBoolean) - set Y.parsedNumber (addEvent . EventNumber) - set Y.parsedAttributeText (addEvent . EventAttributeName) - set Y.parsedText (addEvent . EventText) + set Y.parsedBeginArray (addEvent J.EventBeginArray) + set Y.parsedEndArray (addEvent J.EventEndArray) + set Y.parsedBeginObject (addEvent J.EventBeginObject) + set Y.parsedEndObject (addEvent J.EventEndObject) + set Y.parsedNull (addEvent (J.EventAtom J.AtomNull)) + set Y.parsedBoolean (addEvent . J.EventAtom . J.AtomBoolean) + set Y.parsedAttributeText (addEvent . J.EventAttributeName . TL.fromStrict) + set Y.parsedText (addEvent . J.EventAtom . J.AtomText . TL.fromStrict) + + -- this is going to bite me in the ass + set Y.parsedInteger (addEvent . J.EventAtom . J.AtomNumber . fromInteger) + set Y.parsedDouble (addEvent . J.EventAtom . J.AtomNumber . toRational) eneeParser :: Monad m => m Integer - -> (B.ByteString -> m ([Event], Y.ParseStatus)) - -> m ([Event], Y.ParseStatus) - -> E.Enumeratee B.ByteString Event m b + -> (B.ByteString -> m ([J.Event], Y.ParseStatus)) + -> m ([J.Event], Y.ParseStatus) + -> E.Enumeratee B.ByteString J.Event m b eneeParser getBytesConsumed parseChunk parseComplete = E.checkDone (E.continue . step) where step k (E.Chunks xs) = parseLoop k xs step k E.EOF = do @@ -169,26 +163,26 @@ generateTextIO :: MonadIO m => Y.GeneratorConfig - -> E.Enumeratee Event T.Text m b + -> E.Enumeratee J.Event T.Text m b generateTextIO = generateIO (fmap TE.decodeUtf8 . Y.getBuffer) generateBytesIO :: MonadIO m => Y.GeneratorConfig - -> E.Enumeratee Event B.ByteString m b + -> E.Enumeratee J.Event B.ByteString m b generateBytesIO = generateIO Y.getBuffer generateTextST :: Y.GeneratorConfig - -> E.Enumeratee Event T.Text (ST s) b + -> E.Enumeratee J.Event T.Text (ST s) b generateTextST = generateST (fmap TE.decodeUtf8 . Y.getBuffer) generateBytesST :: Y.GeneratorConfig - -> E.Enumeratee Event B.ByteString (ST s) b + -> E.Enumeratee J.Event B.ByteString (ST s) b generateBytesST = generateST Y.getBuffer generateIO :: (Nullable a, MonadIO m) => (Y.Generator RealWorld -> ST RealWorld a) -> Y.GeneratorConfig - -> E.Enumeratee Event a m b + -> E.Enumeratee J.Event a m b generateIO getBuf config s = do g <- liftIO $ stToIO $ Y.newGenerator config let takeBuf = liftIO $ stToIO $ do @@ -203,7 +197,7 @@ generateST :: Nullable a => (Y.Generator s -> ST s a) -> Y.GeneratorConfig - -> E.Enumeratee Event a (ST s) b + -> E.Enumeratee J.Event a (ST s) b generateST getBuf config s = do g <- lift $ Y.newGenerator config let takeBuf = do @@ -216,14 +210,14 @@ eneeGenerator genEvent takeBuf s eneeGenerator :: (Nullable a, Monad m) - => (Event -> m (Maybe Y.GeneratorError)) + => (J.Event -> m (Maybe Y.GeneratorError)) -> m a - -> E.Enumeratee Event a m b + -> E.Enumeratee J.Event a m b eneeGenerator genEvent takeBuf = E.checkDone (E.continue . step) where step k (E.Chunks []) = E.continue (step k) step k (E.Chunks xs) = parseLoop k xs step k E.EOF = do - maybeError <- lift (genEvent EventNull) + maybeError <- lift (genEvent (J.EventAtom J.AtomNull)) case maybeError of Just Y.GenerationComplete -> E.yield (E.Continue k) E.EOF _ -> E.throwError (Exc.ErrorCall "yajl-enumerator: Unexpected EOF while generating") @@ -233,7 +227,7 @@ maybeError <- lift (genEvent x) case maybeError of Just Y.GenerationComplete -> checkBuf k xs - (\k' -> E.yield (E.Continue k') (E.Chunks (x:xs))) + (\k' -> E.yield (E.Continue k') (E.Chunks xs)) Just err -> checkBuf k xs (\_ -> E.throwError err) Nothing -> parseLoop k xs @@ -243,16 +237,18 @@ then next k else k (E.Chunks [buf]) >>== E.checkDoneEx (E.Chunks extra) next -genEventImpl :: Y.Generator s -> Event -> ST s () +genEventImpl :: Y.Generator s -> J.Event -> ST s () genEventImpl g e = case e of - EventNull -> Y.generateNull g - EventBoolean x -> Y.generateBoolean g x - EventNumber num -> Y.generateNumber g num - EventText text -> Y.generateText g text - EventBeginArray -> Y.generateBeginArray g - EventEndArray -> Y.generateEndArray g - EventBeginObject -> Y.generateBeginObject g - EventAttributeName name -> Y.generateText g name - EventEndObject -> Y.generateEndObject g + J.EventBeginObject -> Y.generateBeginObject g + J.EventEndObject -> Y.generateEndObject g + J.EventBeginArray -> Y.generateBeginArray g + J.EventEndArray -> Y.generateEndArray g + J.EventAttributeName name -> Y.generateText g (TL.toStrict name) + + J.EventAtom atom -> case atom of + J.AtomNull -> Y.generateNull g + J.AtomBoolean x -> Y.generateBoolean g x + J.AtomNumber num -> Y.generateDouble g (fromRational num) + J.AtomText text -> Y.generateText g (TL.toStrict text) -- }}} diff --git a/yajl-enumerator.cabal b/yajl-enumerator.cabal --- a/yajl-enumerator.cabal +++ b/yajl-enumerator.cabal @@ -1,5 +1,5 @@ name: yajl-enumerator -version: 0.3 +version: 0.4 synopsis: Enumerator-based interface to YAJL, an event-based JSON implementation license: GPL-3 license-file: license.txt @@ -24,10 +24,11 @@ build-depends: base >= 4 && < 5 , bytestring >= 0.9 && < 0.10 - , text >= 0.7 && < 0.12 + , text >= 0.8 && < 0.12 , enumerator >= 0.4.3 && < 0.5 , transformers >= 0.2 && < 0.3 , yajl >= 0.3 && < 0.4 + , json-types >= 0.1 && < 0.2 exposed-modules: Text.JSON.YAJL.Enumerator