hw-succinct 0.0.0.10 → 0.0.0.11

raw patch · 11 files changed

+258/−242 lines, 11 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• hw-succinct.cabal +6/−4
• src/HaskellWorks/Data/Json.hs +11/−0
• src/HaskellWorks/Data/Json/Final/Tokenize.hs +0/−5
• src/HaskellWorks/Data/Json/Final/Tokenize/Internal.hs +0/−122
• src/HaskellWorks/Data/Json/Succinct/Cursor.hs +1/−21
• src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs +23/−0
• src/HaskellWorks/Data/Json/Token.hs +5/−40
• src/HaskellWorks/Data/Json/Token/Tokenize.hs +122/−0
• src/HaskellWorks/Data/Json/Token/Types.hs +41/−0
• test/HaskellWorks/Data/Json/Final/TokenizeSpec.hs +0/−50
• test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs +49/−0

@@ -1,5 +1,5 @@ name:                   hw-succinct-version:                0.0.0.10+version:                0.0.0.11 synopsis:               Conduits for tokenizing streams. description:            Please see README.md homepage:               http://github.com/haskell-works/hw-succinct#readme@@ -36,8 +36,7 @@ library   hs-source-dirs:       src   exposed-modules:      HaskellWorks.Data.Attoparsec.Final.Parser-                      , HaskellWorks.Data.Json.Final.Tokenize-                      , HaskellWorks.Data.Json.Final.Tokenize.Internal+                      , HaskellWorks.Data.Json                       , HaskellWorks.Data.Json.Succinct                       , HaskellWorks.Data.Json.Succinct.Cursor                       , HaskellWorks.Data.Json.Succinct.Cursor.BalancedParens@@ -45,6 +44,9 @@                       , HaskellWorks.Data.Json.Succinct.Cursor.CursorType                       , HaskellWorks.Data.Json.Succinct.Cursor.InterestBits                       , HaskellWorks.Data.Json.Succinct.Cursor.Internal+                      , HaskellWorks.Data.Json.Succinct.Cursor.Token+                      , HaskellWorks.Data.Json.Token.Tokenize+                      , HaskellWorks.Data.Json.Token.Types                       , HaskellWorks.Data.Json.Token                       , HaskellWorks.Data.Succinct   build-depends:        base                            >= 4.7  && < 5@@ -66,7 +68,7 @@   type:                 exitcode-stdio-1.0   hs-source-dirs:       test   main-is:              Spec.hs-  other-modules:        HaskellWorks.Data.Json.Final.TokenizeSpec+  other-modules:        HaskellWorks.Data.Json.Token.TokenizeSpec                       , HaskellWorks.Data.Json.Succinct.CursorSpec                       , HaskellWorks.Data.Json.Succinct.Cursor.InterestBitsSpec   build-depends:        base

@@ -0,0 +1,11 @@+-- |+-- Copyright: 2016 John Ky+-- License: MIT+--+-- Json+module HaskellWorks.Data.Json+    ( module X+    ) where++import           HaskellWorks.Data.Json.Succinct  as X+import           HaskellWorks.Data.Json.Token     as X

@@ -1,5 +0,0 @@-module HaskellWorks.Data.Json.Final.Tokenize-    ( parseJsonToken-    ) where--import           HaskellWorks.Data.Json.Final.Tokenize.Internal

@@ -1,122 +0,0 @@-{-# LANGUAGE FlexibleContexts  #-}-{-# LANGUAGE OverloadedStrings #-}--module HaskellWorks.Data.Json.Final.Tokenize.Internal-    ( IsChar(..)-    , JsonToken(..)-    , AFP.Parser(..)-    , parseJsonToken-    , parseJsonTokenString-    , escapedChar-    ) where--import           Control.Applicative-import           Control.Monad-import qualified Data.Attoparsec.ByteString.Char8          as BC-import qualified Data.Attoparsec.Combinator                as AC-import qualified Data.Attoparsec.Types                     as T-import           Data.Bits-import           Data.Char-import           Data.String-import           HaskellWorks.Data.Attoparsec.Final.Parser as AFP-import           HaskellWorks.Data.Char.IsChar-import           HaskellWorks.Data.Json.Token--hexDigitNumeric :: AFP.Parser t => T.Parser t Int-hexDigitNumeric = do-  c <- satisfyChar (\c -> '0' <= c && c <= '9')-  return $ ord c - ord '0'--hexDigitAlphaLower :: AFP.Parser t => T.Parser t Int-hexDigitAlphaLower = do-  c <- satisfyChar (\c -> 'a' <= c && c <= 'z')-  return $ ord c - ord 'a' + 10--hexDigitAlphaUpper :: AFP.Parser t => T.Parser t Int-hexDigitAlphaUpper = do-  c <- satisfyChar (\c -> 'A' <= c && c <= 'Z')-  return $ ord c - ord 'A' + 10--hexDigit :: AFP.Parser t => T.Parser t Int-hexDigit = hexDigitNumeric <|> hexDigitAlphaLower <|> hexDigitAlphaUpper--verbatimChar :: AFP.Parser t => T.Parser t Char-verbatimChar  = satisfyChar (BC.notInClass "\"\\") <?> "invalid string character"--escapedChar :: (IsString t, AFP.Parser t) => T.Parser t Char-escapedChar   = do-  _ <- string "\\"-  (   char '"'  >> return '"'  ) <|>-    ( char 'b'  >> return '\b' ) <|>-    ( char 'n'  >> return '\n' ) <|>-    ( char 'f'  >> return '\f' ) <|>-    ( char 'r'  >> return '\r' ) <|>-    ( char 't'  >> return '\t' ) <|>-    ( char '\\' >> return '\\' ) <|>-    ( char '\'' >> return '\'' ) <|>-    ( char '/'  >> return '/'  )--escapedCode :: (IsString t, AFP.Parser t) => T.Parser t Char-escapedCode   = do-  _ <- string "\\u"-  a <- hexDigit-  b <- hexDigit-  c <- hexDigit-  d <- hexDigit-  return $ chr $ a `shift` 24 .|. b `shift` 16 .|. c `shift` 8 .|. d--parseJsonTokenString :: (JsonTokenLike j, AFP.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j-parseJsonTokenString = do-  _ <- string "\""-  value <- many (verbatimChar <|> escapedChar <|> escapedCode)-  _ <- string "\""-  return $ jsonTokenString value--parseJsonTokenBraceL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenBraceL = string "{" >> return jsonTokenBraceL--parseJsonTokenBraceR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenBraceR = string "}" >> return jsonTokenBraceR--parseJsonTokenBracketL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenBracketL = string "[" >> return jsonTokenBracketL--parseJsonTokenBracketR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenBracketR = string "]" >> return jsonTokenBracketR--parseJsonTokenComma :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenComma = string "," >> return jsonTokenComma--parseJsonTokenColon :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenColon = string ":" >> return jsonTokenColon--parseJsonTokenWhitespace :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenWhitespace = do-  _ <- AC.many1' $ BC.choice [string " ", string "\t", string "\n", string "\r"]-  return jsonTokenWhitespace--parseJsonTokenNull :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenNull = string "null" >> return jsonTokenNull--parseJsonTokenBoolean :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenBoolean = true <|> false-  where-    true  = string "true"   >> return (jsonTokenBoolean True)-    false = string "false"  >> return (jsonTokenBoolean False)--parseJsonTokenDouble :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonTokenDouble = liftM jsonTokenNumber rational--parseJsonToken :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j-parseJsonToken =-  parseJsonTokenString     <|>-  parseJsonTokenBraceL     <|>-  parseJsonTokenBraceR     <|>-  parseJsonTokenBracketL   <|>-  parseJsonTokenBracketR   <|>-  parseJsonTokenComma      <|>-  parseJsonTokenColon      <|>-  parseJsonTokenWhitespace <|>-  parseJsonTokenNull       <|>-  parseJsonTokenBoolean    <|>-  parseJsonTokenDouble

@@ -1,28 +1,8 @@-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE InstanceSigs          #-}-{-# LANGUAGE MultiParamTypeClasses #-}  module HaskellWorks.Data.Json.Succinct.Cursor   ( module X-  , jsonTokenAt   ) where -import qualified Data.Attoparsec.ByteString.Char8                           as ABC-import           Data.ByteString.Internal                                   as BSI-import           HaskellWorks.Data.Bits.BitWise-import           HaskellWorks.Data.Json.Final.Tokenize.Internal import           HaskellWorks.Data.Json.Succinct.Cursor.CursorType          as X import           HaskellWorks.Data.Json.Succinct.Cursor.Internal            as X-import           HaskellWorks.Data.Positioning-import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Rank1-import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Select1-import           HaskellWorks.Data.Vector.VectorLike--jsonTokenAt :: (Rank1 w, Select1 v, TestBit w) => JsonCursor ByteString v w -> Maybe JsonToken-jsonTokenAt k = if balancedParens k .?. lastPositionOf (cursorRank k)-  then case ABC.parse parseJsonToken (vDrop (toCount (jsonCursorPos k)) (cursorText k)) of-    ABC.Fail    {}  -> error "Failed to parse token in cursor"-    ABC.Partial _   -> error "Failed to parse token in cursor"-    ABC.Done    _ r -> Just r-  else Nothing+import           HaskellWorks.Data.Json.Succinct.Cursor.Token               as X

@@ -0,0 +1,23 @@++module HaskellWorks.Data.Json.Succinct.Cursor.Token+  ( jsonTokenAt+  ) where++import qualified Data.Attoparsec.ByteString.Char8                           as ABC+import           Data.ByteString.Internal                                   as BSI+import           HaskellWorks.Data.Bits.BitWise+import           HaskellWorks.Data.Json.Succinct.Cursor.CursorType+import           HaskellWorks.Data.Json.Succinct.Cursor.Internal+import           HaskellWorks.Data.Json.Token.Tokenize+import           HaskellWorks.Data.Positioning+import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Rank1+import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Select1+import           HaskellWorks.Data.Vector.VectorLike++jsonTokenAt :: (Rank1 w, Select1 v, TestBit w) => JsonCursor ByteString v w -> Maybe JsonToken+jsonTokenAt k = if balancedParens k .?. lastPositionOf (cursorRank k)+  then case ABC.parse parseJsonToken (vDrop (toCount (jsonCursorPos k)) (cursorText k)) of+    ABC.Fail    {}  -> error "Failed to parse token in cursor"+    ABC.Partial _   -> error "Failed to parse token in cursor"+    ABC.Done    _ r -> Just r+  else Nothing

@@ -1,41 +1,6 @@-module HaskellWorks.Data.Json.Token (JsonToken(..), JsonTokenLike(..)) where--class JsonTokenLike j where-  jsonTokenBraceL     :: j-  jsonTokenBraceR     :: j-  jsonTokenBracketL   :: j-  jsonTokenBracketR   :: j-  jsonTokenComma      :: j-  jsonTokenColon      :: j-  jsonTokenWhitespace :: j-  jsonTokenString     :: String -> j-  jsonTokenBoolean    :: Bool -> j-  jsonTokenNumber     :: Double -> j-  jsonTokenNull       :: j--data JsonToken-  = JsonTokenBraceL-  | JsonTokenBraceR-  | JsonTokenBracketL-  | JsonTokenBracketR-  | JsonTokenComma-  | JsonTokenColon-  | JsonTokenWhitespace-  | JsonTokenString String-  | JsonTokenBoolean Bool-  | JsonTokenNumber Double-  | JsonTokenNull-  deriving (Eq, Show)+module HaskellWorks.Data.Json.Token+  ( module X+  ) where -instance JsonTokenLike JsonToken where-  jsonTokenBraceL     = JsonTokenBraceL-  jsonTokenBraceR     = JsonTokenBraceR-  jsonTokenBracketL   = JsonTokenBracketL-  jsonTokenBracketR   = JsonTokenBracketR-  jsonTokenComma      = JsonTokenComma-  jsonTokenColon      = JsonTokenColon-  jsonTokenWhitespace = JsonTokenWhitespace-  jsonTokenString     = JsonTokenString-  jsonTokenBoolean    = JsonTokenBoolean-  jsonTokenNumber     = JsonTokenNumber-  jsonTokenNull       = JsonTokenNull+  import           HaskellWorks.Data.Json.Token.Types as X+  import           HaskellWorks.Data.Json.Token.Tokenize as X

@@ -0,0 +1,122 @@+{-# LANGUAGE FlexibleContexts  #-}+{-# LANGUAGE OverloadedStrings #-}++module HaskellWorks.Data.Json.Token.Tokenize+    ( IsChar(..)+    , JsonToken(..)+    , AFP.Parser(..)+    , parseJsonToken+    , parseJsonTokenString+    , escapedChar+    ) where++import           Control.Applicative+import           Control.Monad+import qualified Data.Attoparsec.ByteString.Char8          as BC+import qualified Data.Attoparsec.Combinator                as AC+import qualified Data.Attoparsec.Types                     as T+import           Data.Bits+import           Data.Char+import           Data.String+import           HaskellWorks.Data.Attoparsec.Final.Parser as AFP+import           HaskellWorks.Data.Char.IsChar+import           HaskellWorks.Data.Json.Token.Types++hexDigitNumeric :: AFP.Parser t => T.Parser t Int+hexDigitNumeric = do+  c <- satisfyChar (\c -> '0' <= c && c <= '9')+  return $ ord c - ord '0'++hexDigitAlphaLower :: AFP.Parser t => T.Parser t Int+hexDigitAlphaLower = do+  c <- satisfyChar (\c -> 'a' <= c && c <= 'z')+  return $ ord c - ord 'a' + 10++hexDigitAlphaUpper :: AFP.Parser t => T.Parser t Int+hexDigitAlphaUpper = do+  c <- satisfyChar (\c -> 'A' <= c && c <= 'Z')+  return $ ord c - ord 'A' + 10++hexDigit :: AFP.Parser t => T.Parser t Int+hexDigit = hexDigitNumeric <|> hexDigitAlphaLower <|> hexDigitAlphaUpper++verbatimChar :: AFP.Parser t => T.Parser t Char+verbatimChar  = satisfyChar (BC.notInClass "\"\\") <?> "invalid string character"++escapedChar :: (IsString t, AFP.Parser t) => T.Parser t Char+escapedChar   = do+  _ <- string "\\"+  (   char '"'  >> return '"'  ) <|>+    ( char 'b'  >> return '\b' ) <|>+    ( char 'n'  >> return '\n' ) <|>+    ( char 'f'  >> return '\f' ) <|>+    ( char 'r'  >> return '\r' ) <|>+    ( char 't'  >> return '\t' ) <|>+    ( char '\\' >> return '\\' ) <|>+    ( char '\'' >> return '\'' ) <|>+    ( char '/'  >> return '/'  )++escapedCode :: (IsString t, AFP.Parser t) => T.Parser t Char+escapedCode   = do+  _ <- string "\\u"+  a <- hexDigit+  b <- hexDigit+  c <- hexDigit+  d <- hexDigit+  return $ chr $ a `shift` 24 .|. b `shift` 16 .|. c `shift` 8 .|. d++parseJsonTokenString :: (JsonTokenLike j, AFP.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j+parseJsonTokenString = do+  _ <- string "\""+  value <- many (verbatimChar <|> escapedChar <|> escapedCode)+  _ <- string "\""+  return $ jsonTokenString value++parseJsonTokenBraceL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenBraceL = string "{" >> return jsonTokenBraceL++parseJsonTokenBraceR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenBraceR = string "}" >> return jsonTokenBraceR++parseJsonTokenBracketL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenBracketL = string "[" >> return jsonTokenBracketL++parseJsonTokenBracketR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenBracketR = string "]" >> return jsonTokenBracketR++parseJsonTokenComma :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenComma = string "," >> return jsonTokenComma++parseJsonTokenColon :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenColon = string ":" >> return jsonTokenColon++parseJsonTokenWhitespace :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenWhitespace = do+  _ <- AC.many1' $ BC.choice [string " ", string "\t", string "\n", string "\r"]+  return jsonTokenWhitespace++parseJsonTokenNull :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenNull = string "null" >> return jsonTokenNull++parseJsonTokenBoolean :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenBoolean = true <|> false+  where+    true  = string "true"   >> return (jsonTokenBoolean True)+    false = string "false"  >> return (jsonTokenBoolean False)++parseJsonTokenDouble :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonTokenDouble = liftM jsonTokenNumber rational++parseJsonToken :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j+parseJsonToken =+  parseJsonTokenString     <|>+  parseJsonTokenBraceL     <|>+  parseJsonTokenBraceR     <|>+  parseJsonTokenBracketL   <|>+  parseJsonTokenBracketR   <|>+  parseJsonTokenComma      <|>+  parseJsonTokenColon      <|>+  parseJsonTokenWhitespace <|>+  parseJsonTokenNull       <|>+  parseJsonTokenBoolean    <|>+  parseJsonTokenDouble

@@ -0,0 +1,41 @@+module HaskellWorks.Data.Json.Token.Types (JsonToken(..), JsonTokenLike(..)) where++class JsonTokenLike j where+  jsonTokenBraceL     :: j+  jsonTokenBraceR     :: j+  jsonTokenBracketL   :: j+  jsonTokenBracketR   :: j+  jsonTokenComma      :: j+  jsonTokenColon      :: j+  jsonTokenWhitespace :: j+  jsonTokenString     :: String -> j+  jsonTokenBoolean    :: Bool -> j+  jsonTokenNumber     :: Double -> j+  jsonTokenNull       :: j++data JsonToken+  = JsonTokenBraceL+  | JsonTokenBraceR+  | JsonTokenBracketL+  | JsonTokenBracketR+  | JsonTokenComma+  | JsonTokenColon+  | JsonTokenWhitespace+  | JsonTokenString String+  | JsonTokenBoolean Bool+  | JsonTokenNumber Double+  | JsonTokenNull+  deriving (Eq, Show)++instance JsonTokenLike JsonToken where+  jsonTokenBraceL     = JsonTokenBraceL+  jsonTokenBraceR     = JsonTokenBraceR+  jsonTokenBracketL   = JsonTokenBracketL+  jsonTokenBracketR   = JsonTokenBracketR+  jsonTokenComma      = JsonTokenComma+  jsonTokenColon      = JsonTokenColon+  jsonTokenWhitespace = JsonTokenWhitespace+  jsonTokenString     = JsonTokenString+  jsonTokenBoolean    = JsonTokenBoolean+  jsonTokenNumber     = JsonTokenNumber+  jsonTokenNull       = JsonTokenNull

@@ -1,50 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--module HaskellWorks.Data.Json.Final.TokenizeSpec (spec) where--import qualified Data.Attoparsec.ByteString.Char8      as BC-import           Data.ByteString                       as BS-import           HaskellWorks.Data.Json.Final.Tokenize-import           HaskellWorks.Data.Json.Token-import           Test.Hspec--{-# ANN module ("HLint: ignore Redundant do"        :: String) #-}--parseJsonToken' :: ByteString -> Either String JsonToken-parseJsonToken' = BC.parseOnly parseJsonToken--spec :: Spec-spec = describe "Data.Conduit.Succinct.JsonSpec" $ do-  describe "When parsing single token at beginning of text" $ do-    it "Empty Json should produce no bits" $-      parseJsonToken' "" `shouldBe` Left "not enough input"-    it "Json with one space should produce whitespace token" $-      parseJsonToken' " " `shouldBe` Right JsonTokenWhitespace-    it "Json with two spaces should produce whitespace token" $-      parseJsonToken' "  " `shouldBe` Right JsonTokenWhitespace-    it "Spaces and newlines should produce no bits" $-      parseJsonToken' "  \n \r \t " `shouldBe` Right JsonTokenWhitespace-    it "`null` at beginning should produce one bit" $-      parseJsonToken' "null " `shouldBe` Right JsonTokenNull-    it "number at beginning should produce one bit" $-      parseJsonToken' "1234 " `shouldBe` Right (JsonTokenNumber 1234)-    it "false at beginning should produce one bit" $-      parseJsonToken' "false " `shouldBe` Right (JsonTokenBoolean False)-    it "true at beginning should produce one bit" $-      parseJsonToken' "true " `shouldBe` Right (JsonTokenBoolean True)-    it "string at beginning should produce one bit" $-      parseJsonToken' "\"hello\" " `shouldBe` Right (JsonTokenString "hello")-    it "quoted string should parse" $-      parseJsonToken' "\"\\\"\" " `shouldBe` Right (JsonTokenString "\"")-    it "left brace at beginning should produce one bit" $-      parseJsonToken' "{ " `shouldBe` Right JsonTokenBraceL-    it "right brace at beginning should produce one bit" $-      parseJsonToken' "} " `shouldBe` Right JsonTokenBraceR-    it "left bracket at beginning should produce one bit" $-      parseJsonToken' "[ " `shouldBe` Right JsonTokenBracketL-    it "right bracket at beginning should produce one bit" $-      parseJsonToken' "] " `shouldBe` Right JsonTokenBracketR-    it "right bracket at beginning should produce one bit" $-      parseJsonToken' ": " `shouldBe` Right JsonTokenColon-    it "right bracket at beginning should produce one bit" $-      parseJsonToken' ", " `shouldBe` Right JsonTokenComma

@@ -0,0 +1,49 @@+{-# LANGUAGE OverloadedStrings #-}++module HaskellWorks.Data.Json.Token.TokenizeSpec (spec) where++import qualified Data.Attoparsec.ByteString.Char8      as BC+import           Data.ByteString                       as BS+import           HaskellWorks.Data.Json.Token.Tokenize+import           Test.Hspec++{-# ANN module ("HLint: ignore Redundant do"        :: String) #-}++parseJsonToken' :: ByteString -> Either String JsonToken+parseJsonToken' = BC.parseOnly parseJsonToken++spec :: Spec+spec = describe "Data.Conduit.Succinct.JsonSpec" $ do+  describe "When parsing single token at beginning of text" $ do+    it "Empty Json should produce no bits" $+      parseJsonToken' "" `shouldBe` Left "not enough input"+    it "Json with one space should produce whitespace token" $+      parseJsonToken' " " `shouldBe` Right JsonTokenWhitespace+    it "Json with two spaces should produce whitespace token" $+      parseJsonToken' "  " `shouldBe` Right JsonTokenWhitespace+    it "Spaces and newlines should produce no bits" $+      parseJsonToken' "  \n \r \t " `shouldBe` Right JsonTokenWhitespace+    it "`null` at beginning should produce one bit" $+      parseJsonToken' "null " `shouldBe` Right JsonTokenNull+    it "number at beginning should produce one bit" $+      parseJsonToken' "1234 " `shouldBe` Right (JsonTokenNumber 1234)+    it "false at beginning should produce one bit" $+      parseJsonToken' "false " `shouldBe` Right (JsonTokenBoolean False)+    it "true at beginning should produce one bit" $+      parseJsonToken' "true " `shouldBe` Right (JsonTokenBoolean True)+    it "string at beginning should produce one bit" $+      parseJsonToken' "\"hello\" " `shouldBe` Right (JsonTokenString "hello")+    it "quoted string should parse" $+      parseJsonToken' "\"\\\"\" " `shouldBe` Right (JsonTokenString "\"")+    it "left brace at beginning should produce one bit" $+      parseJsonToken' "{ " `shouldBe` Right JsonTokenBraceL+    it "right brace at beginning should produce one bit" $+      parseJsonToken' "} " `shouldBe` Right JsonTokenBraceR+    it "left bracket at beginning should produce one bit" $+      parseJsonToken' "[ " `shouldBe` Right JsonTokenBracketL+    it "right bracket at beginning should produce one bit" $+      parseJsonToken' "] " `shouldBe` Right JsonTokenBracketR+    it "right bracket at beginning should produce one bit" $+      parseJsonToken' ": " `shouldBe` Right JsonTokenColon+    it "right bracket at beginning should produce one bit" $+      parseJsonToken' ", " `shouldBe` Right JsonTokenComma