spata 2009.9.18.1 → 2010.10.10

raw patch · 3 files changed

+79/−24 lines, 3 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• spata.cabal +6/−6
• src/Network/Spata/DSL.hs +64/−16
• src/Network/Spata/Type.hs +9/−2

@@ -1,19 +1,19 @@ Name:                 spata-Version:              2009.9.18.1+Version:              2010.10.10 Build-type:           Simple-Synopsis:             bruteforce form validation+Synopsis:             brainless form validation Description:         -    who needs a brain when it can be solved with fists+    tiny validation library  License:              BSD3 License-file:         LICENSE-Author:               Wang, Jinjing-Maintainer:           Wang, Jinjing <nfjinjing@gmail.com>+Author:               Jinjing Wang+Maintainer:           Jinjing Wang <nfjinjing@gmail.com> Build-Depends:        base Cabal-version:        >= 1.2 category:             Web-homepage:             http://github.com/nfjinjing/spata/tree/master+homepage:             http://github.com/nfjinjing/spata data-files:           readme.md, changelog.md, known-issues.md, Nemesis, src/test.hs  library

@@ -1,41 +1,89 @@+{-# LANGUAGE PackageImports #-}+ module Network.Spata.DSL where  import Data.DList (singleton, toList, fromList)-import Control.Monad.Writer+import "mtl" Control.Monad.Writer+import "mtl" Control.Monad.Error () import MPS.Env import Prelude () import Data.Maybe import Network.Spata.Type-import Control.Monad.Error-import MPS (empty)+import MPS (empty, match)  guard :: Assoc -> Guardians -> Either String Assoc-guard xs m = execWriter m .toList .inject (Right xs) (>>=)+guard inputs m = execWriter m .toList .inject (Right inputs) (>>=)  validate :: Guard -> [String]-> Guardians-validate f xs = -  tell - fromList - xs.map f+validate f inputs = +  tell - fromList - inputs.map f  train :: Task -> Guardians train f = tell - singleton f  inclusion_of :: Guard-inclusion_of = p (const True) ""+inclusion_of = predicate (const True) ""  presence_of :: Guard-presence_of = p (empty > not) "should not be empty"+presence_of = predicate (empty > not) "should not be empty"  length_of :: (Integer -> Bool) -> Guard-length_of f = p (length > from_i > f) "should satisfy length properties"+length_of f = predicate (length > from_i > f) "should satisfy length properties" -p = predicate+int_of :: Guard+int_of = predicate (match "^\\d+$" > isJust) "should be integer" -predicate, p :: (String -> Bool) -> String -> Guard-predicate f s x xs =-  case xs.lookup x of-    Nothing -> Left - x ++ " should exist"++predicate :: (String -> Bool) -> String -> Guard+predicate f s x inputs =+  case inputs.lookup x of+    Nothing -> Left - x + " should exist"     Just y ->       if f y-        then Right xs-        else Left - x ++ " " ++ s+        then Right inputs+        else Left - x + " " + s+++-- monad, mostly used in IO++validate_m :: (Monad m) => GuardM m -> [String] -> GuardiansM m+validate_m f inputs =+  tell - fromList - inputs.map f++predicate_m :: (Monad m) => (String -> m Bool) -> String -> GuardM m+predicate_m f s x inputs =+  case inputs.lookup x of+    Nothing -> return - Left - x + " should exist"+    Just y -> do+      r <- f y+      if r+        then return - Right inputs+        else return - Left - x + " " + s++guard_m :: (Monad m) => Assoc -> GuardiansM m -> m (Either String Assoc)+guard_m inputs m = do+  let tasks = execWriter m .toList+  +  lazy_eval tasks - Right inputs+  where+    lazy_eval [] last_validation_result = return - last_validation_result+    lazy_eval _ (Left r) = return - Left r+    lazy_eval (p':ps) (Right xs) = do+      validation_result <- p' xs+      lazy_eval ps validation_result+           +        +        +-- alias+p :: (String -> Bool) -> String -> Guard+p = predicate++validateM :: (Monad m) => GuardM m -> [String] -> GuardiansM m+validateM = validate_m++predicateM :: (Monad m) => (String -> m Bool) -> String -> GuardM m+predicateM = predicate_m++guardM :: (Monad m) => Assoc -> GuardiansM m -> m (Either String Assoc)+guardM = guard_m

@@ -1,13 +1,20 @@+{-# LANGUAGE PackageImports #-}+ module Network.Spata.Type where  import Data.DList (DList)-import Control.Monad.Writer+import "mtl" Control.Monad.Writer  type Assoc = [(String, String)] type Guard = String -> Assoc -> Either String Assoc-type Guards = [String] -> Assoc -> Either String Assoc++-- type Guards = [String] -> Assoc -> Either String Assoc type Task = Assoc -> Either String Assoc  type GuardiansT a = Writer (DList Task) a type Guardians = GuardiansT () +type GuardM m = String -> Assoc -> m (Either String Assoc)+type TaskM m = Assoc -> m (Either String Assoc)+type GuardiansTM a m = Writer (DList (TaskM m)) a+type GuardiansM m = GuardiansTM () m