aeson-better-errors 0.9.0 → 0.9.0.1

raw patch · 3 files changed

+33/−11 lines, 3 filesdep ~transformers-compatPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: transformers-compat

API changes (from Hackage documentation)

Files

• aeson-better-errors.cabal +2/−2
• src/Data/Aeson/BetterErrors.hs +4/−0
• src/Data/Aeson/BetterErrors/Internal.hs +27/−9

@@ -1,5 +1,5 @@ name:                aeson-better-errors-version:             0.9.0+version:             0.9.0.1 synopsis:            Better error messages when decoding JSON values. license:             MIT license-file:        LICENSE@@ -34,7 +34,7 @@                    , scientific                    , vector                    , transformers-                   , transformers-compat >= 0.3+                   , transformers-compat >= 0.4                    , mtl                    , void 

@@ -20,6 +20,7 @@   , (.!)    -- * Basic parsers+  , asValue   , asText   , asString   , asScientific@@ -42,10 +43,12 @@   , nthMay    , eachInArray+  , forEachInObject   , eachInObject   , eachInObjectWithKey    -- * Custom validations+  , withValue   , withText   , withString   , withScientific@@ -57,6 +60,7 @@   , throwCustomError    -- ** Monadic validators+  , withValueM   , withTextM   , withStringM   , withScientificM

@@ -2,10 +2,15 @@ {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-}+{-# LANGUAGE CPP #-}  module Data.Aeson.BetterErrors.Internal where -import Control.Applicative+#if !MIN_VERSION_base(4,8,0)+import Control.Applicative (Applicative, pure, (<$>), (<*>))+import Data.Foldable (foldMap)+#endif+ import Control.Arrow (left) import Control.Monad.Identity import Control.Monad.Reader@@ -13,7 +18,6 @@ import Control.Monad.Error.Class (MonadError(..))  import Data.Void-import Data.Foldable (foldMap) import Data.Monoid import Data.DList (DList) import qualified Data.DList as DList@@ -296,6 +300,13 @@ as pat ty = liftParse $ \v ->   maybe (Left (WrongType ty v)) Right (pat v) +-- | Return the current JSON 'A.Value' as is.  This does no error checking and+-- thus always succeeds. You probably don't want this parser unless the JSON+-- at the current part of your structure is truly arbitrary. You should prefer+-- to use more specific parsers, like 'asText' or 'asIntegral', where possible.+asValue :: (Functor m, Monad m) => ParseT err m A.Value+asValue = asks rdrValue+ -- | Parse a single JSON string as 'Text'. asText :: (Functor m, Monad m) => ParseT err m Text asText = as patString TyString@@ -413,27 +424,34 @@   forM xs $ \(i, x) ->     local (appendPath (ArrayIndex i) . setValue x) p +-- | Parse each property in an object with the given parser, given the key as+-- an argument, and collect the results.+forEachInObject :: (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]+forEachInObject p = do+  xs <- HashMap.toList <$> asObject+  forM xs $ \(k, x) ->+    local (appendPath (ObjectKey k) . setValue x) (p k)+ -- | Attempt to parse each property value in the object with the given parser, -- and collect the results. eachInObject :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]-eachInObject p = do-  xs <- HashMap.toList <$> asObject-  forM xs $ \(k, x) ->-    (k,) <$> local (appendPath (ObjectKey k) . setValue x) p+eachInObject = eachInObjectWithKey Right  -- | Attempt to parse each property in the object: parse the key with the -- given validation function, parse the value with the given parser, and -- collect the results. eachInObjectWithKey :: (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]-eachInObjectWithKey parseKey parseVal =-  eachInObject parseVal-      >>= mapM ((\(k,v) -> liftEither ((,) <$> parseKey k <*> pure v)))+eachInObjectWithKey parseKey parseVal = forEachInObject $ \k ->+  (,) <$> liftEither (parseKey k) <*> parseVal  -- | Lifts a function attempting to validate an arbitrary JSON value into a -- parser. You should only use this if absolutely necessary; the other -- functions in this module will generally give better error reporting. withValue :: (Functor m, Monad m) => (A.Value -> Either err a) -> ParseT err m a withValue f = liftParse (left CustomError . f)++withValueM :: (Functor m, Monad m) => (A.Value -> m (Either err a)) -> ParseT err m a+withValueM f = liftParseM (fmap (left CustomError) . f)  liftEither :: (Functor m, Monad m) => Either err a -> ParseT err m a liftEither = withValue . const