shakespeare 1.0.0.2 → 1.0.1

raw patch · 4 files changed

+29/−13 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Text/Shakespeare.hs +1/−0
• Text/Shakespeare/Base.hs +22/−12
• shakespeare.cabal +1/−1
• test.hs +5/−0

@@ -138,6 +138,7 @@ eShowErrors = either (error . show) id  contentFromString :: ShakespeareSettings -> String -> [Content]+contentFromString _ "" = [] contentFromString rs s =     compressContents $ eShowErrors $ parse (parseContents rs) s s   where

@@ -35,6 +35,7 @@ import qualified System.IO as SIO import qualified Data.Text.Lazy.IO as TIO import Control.Monad (when)+import Control.Applicative ((<*))  newtype Ident = Ident String     deriving (Show, Eq, Read, Data, Typeable)@@ -48,6 +49,7 @@            | DerefString String            | DerefBranch Deref Deref            | DerefList [Deref]+           | DerefTuple [Deref]     deriving (Show, Eq, Read, Data, Typeable)  instance Lift Ident where@@ -76,16 +78,24 @@         return $ dr `AppE` InfixE (Just n) per (Just d)     lift (DerefString s) = [|DerefString|] `appE` lift s     lift (DerefList x) = [|DerefList $(lift x)|]+    lift (DerefTuple x) = [|DerefTuple $(lift x)|]  derefParens, derefCurlyBrackets :: Parser Deref derefParens        = between (char '(') (char ')') parseDeref derefCurlyBrackets = between (char '{') (char '}') parseDeref -derefList :: Parser Deref+derefList, derefTuple :: Parser Deref derefList = between (char '[') (char ']') (fmap DerefList $ sepBy parseDeref (char ','))+derefTuple = try $ do+  _ <- char '('+  x <- sepBy1 parseDeref (char ',')+  when (length x < 2) $ pzero+  _ <- char ')'+  return $ DerefTuple x  parseDeref :: Parser Deref-parseDeref = skipMany (oneOf " \t") >> (derefList <|> (do+parseDeref = skipMany (oneOf " \t") >> (derefList <|>+                                        derefTuple <|> (do     x <- derefSingle     (derefInfix x) <|> (do         res <- deref' $ (:) x@@ -95,21 +105,20 @@     delim = (many1 (char ' ') >> return())             <|> lookAhead (oneOf "(\"" >> return ())     derefOp = try $ do-        _ <- char '('-        x <- many1 $ noneOf " \t\n\r()"-        _ <- char ')'-        return $ DerefIdent $ Ident x+            _ <- char '('+            x <- many1 $ noneOf " \t\n\r()"+            _ <- char ')'+            return $ DerefIdent $ Ident x     derefInfix x = try $ do-        () <- fail "Infix operator handling is currently disabled"-        _ <- many1 $ oneOf " \t"+        _ <- delim+        xs <- many $ try $ derefSingle <* delim         op <- many1 (satisfy $ \c -> isSymbol c || c `elem` "-") <?> "operator"         -- special handling for $, which we don't deal with         when (op == "$") $ fail "don't handle $"         let op' = DerefIdent $ Ident op-        _ <- many1 (oneOf " \t")-        y <- derefSingle-        return $ DerefBranch (DerefBranch op' x) y-    derefSingle = derefOp <|> derefParens <|> numeric <|> strLit<|> ident+        ys <- many1 $ delim >> derefSingle+        return $ DerefBranch (DerefBranch op' $ foldl1 DerefBranch $ x : xs) (foldl1 DerefBranch ys)+    derefSingle = derefTuple <|> derefOp <|> derefParens <|> numeric <|> strLit<|> ident     deref' lhs =         dollar <|> derefSingle'                <|> return (foldl1 DerefBranch $ lhs [])@@ -176,6 +185,7 @@ derefToExp _ (DerefRational r) = LitE $ RationalL r derefToExp _ (DerefString s) = LitE $ StringL s derefToExp s (DerefList ds) = ListE $ map (derefToExp s) ds+derefToExp s (DerefTuple ds) = TupE $ map (derefToExp s) ds  -- FIXME shouldn't we use something besides a list here? flattenDeref :: Deref -> Maybe [String]

@@ -1,5 +1,5 @@ name:            shakespeare-version:         1.0.0.2+version:         1.0.1 license:         MIT license-file:    LICENSE author:          Michael Snoyman <michael@snoyman.com>

@@ -0,0 +1,5 @@+import Test.Hspec.Monadic+import ShakespeareBaseTest (specs)++main :: IO ()+main = hspecX $ specs