hsx 0.7.0 → 0.9.0

raw patch · 3 files changed

+49/−18 lines, 3 filesdep ~haskell-src-extsPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: haskell-src-exts

API changes (from Hackage documentation)

Files

• hsx.cabal +4/−4
• src/HSX/Transform.hs +22/−11
• src/HSX/XMLGenerator.hs +23/−3

@@ -1,9 +1,9 @@ Name:                   hsx-Version:                0.7.0+Version:                0.9.0 License:                BSD3 License-File:           LICENSE Author:                 Niklas Broberg, Joel Bjornson-Maintainer:             Niklas Broberg <nibro@cs.chalmers.se>+Maintainer:             Niklas Broberg <niklas.broberg@chalmers.se>  Stability:              Experimental Category:               Language@@ -27,7 +27,7 @@                         Achieving that is not as simple as it may seem, but the XMLGenerator module provides all the                         necessary machinery.                         -Homepage:               http://code.google.com/hsp+Homepage:               http://code.haskell.com/HSP  Tested-With:            GHC==6.8.3, GHC==6.10.1 Cabal-Version: 		>= 1.2.3@@ -36,7 +36,7 @@ Flag base4  Library-  Build-depends:	mtl, haskell-src-exts >= 1.5, utf8-string+  Build-depends:	mtl, haskell-src-exts >= 1.10, utf8-string   if flag(base4)     Build-depends:      base >= 4 && < 5     cpp-options:        -DBASE4

@@ -232,17 +232,6 @@         -- ... and lift the values into the XML datatype.         return $ paren $ metaGenElement name as mattr cs' -      where-        -- | Transform expressions appearing in child position of an xml tag.-        -- Expressions are first transformed, then wrapped in a call to-        -- @toXml@.-        transformChild :: Exp -> HsxM Exp-        transformChild e = do-            -- Transform the expression-            te <- transformExp e-            -- ... and apply the overloaded toXMLs to it-            return $ metaAsChild te-     -- An empty xml tag should be transformed just as a standard tag,     -- only that there are no children,     XETag _ name attrs mattr -> do@@ -252,6 +241,17 @@             as = map mkAttr attrs             -- ... and lift the values into the XML datatype.         return $ paren $ metaGenEElement name as mattr++    -- A child tag should be transformed into an application+    -- of asChild to a list of children.+    XChildTag _ cs  -> do+        -- After all, it IS christmas!+        setXmlTransformed+        -- ... transform the children+        cs' <- mapM transformChild cs+        -- ... and make them into a list+        return $ paren $ metaAsChild $ listE cs'+     -- PCDATA should be lifted as a string into the XML datatype.     XPcdata pcdata    -> do setXmlTransformed                             return $ strE pcdata@@ -259,6 +259,7 @@     XExpTag e     -> do setXmlTransformed                         e' <- transformExp e                         return $ paren $ metaAsChild e'+     -- Patterns as arguments to a lambda expression could be regular,     -- but we cannot put the evaluation here since a lambda expression     -- can have neither guards nor a where clause. Thus we must postpone@@ -359,6 +360,16 @@     SCCPragma  s e      -> fmap (SCCPragma  s) $ transformExp e     GenPragma  s a b e  -> fmap (GenPragma  s a b) $ transformExp e     _           -> return e     -- Warning - will not work inside TH brackets!+  where+    -- | Transform expressions appearing in child position of an xml tag.+    -- Expressions are first transformed, then wrapped in a call to+    -- @toXml@.+    transformChild :: Exp -> HsxM Exp+    transformChild e = do+        -- Transform the expression+        te <- transformExp e+        -- ... and apply the overloaded toXMLs to it+        return $ metaAsChild te  transformFieldUpdate :: FieldUpdate -> HsxM FieldUpdate transformFieldUpdate (FieldUpdate n e) =

@@ -18,15 +18,23 @@ -----------------------------------------------------------------------------
 module HSX.XMLGenerator where
 
-import Control.Monad.Trans
-import Control.Monad (MonadPlus(..),liftM)
+import Control.Applicative (Applicative, Alternative)
+import Control.Monad.Trans (MonadTrans(lift), MonadIO)
+import Control.Monad.Cont  (MonadCont)
+import Control.Monad.Error (MonadError)
+import Control.Monad.Reader(MonadReader)
+import Control.Monad.Writer(MonadWriter)
+import Control.Monad.State (MonadState)
+import Control.Monad.RWS   (MonadRWS)
+import Control.Monad       (MonadPlus(..),liftM)
 
 ----------------------------------------------
 -- General XML Generation
 
 -- | The monad transformer that allows a monad to generate XML values.
 newtype XMLGenT m a = XMLGenT (m a)
-  deriving (Monad, Functor, MonadIO, MonadPlus)
+  deriving (Applicative, Alternative, Monad, Functor, MonadIO, MonadPlus, MonadWriter w, MonadReader r,
+            MonadState s, MonadRWS r w s, MonadCont, MonadError e)
 
 -- | un-lift.
 unXMLGenT :: XMLGenT m a -> m a
@@ -65,10 +73,15 @@ class XMLGen m => EmbedAsChild m c where
  asChild :: c -> GenChildList m
 
+#if __GLASGOW_HASKELL__ >= 610
+instance (EmbedAsChild m c, m ~ n) => EmbedAsChild m (XMLGenT n c) where
+ asChild m = asChild =<< m
+#else
 instance (EmbedAsChild m c, TypeCastM m1 m) => EmbedAsChild m (XMLGenT m1 c) where
  asChild (XMLGenT m1a) = do
             a <- XMLGenT $ typeCastM m1a
             asChild a
+#endif
 
 instance EmbedAsChild m c => EmbedAsChild m [c] where
  asChild = liftM concat . mapM asChild
@@ -94,6 +107,11 @@ instance (XMLGen m, EmbedAsAttr m a) => EmbedAsAttr m (XMLGenT m a) where
  asAttr ma = ma >>= asAttr
 
+instance (EmbedAsAttr m (Attr a v), TypeCastM m1 m) => EmbedAsAttr m (Attr a (XMLGenT m1 v)) where
+ asAttr (a := (XMLGenT m1a)) = do
+            v <- XMLGenT $ typeCastM m1a
+            asAttr (a := v)
+
 instance XMLGen m => EmbedAsAttr m (Attribute m) where
  asAttr = return . return
 
@@ -104,6 +122,8 @@ class (XMLGen m,
        SetAttr m (XML m),
        AppendChild m (XML m),
+       EmbedAsChild m (XML m),
+       EmbedAsChild m [XML m],
        EmbedAsChild m String,
        EmbedAsChild m Char, -- for overlap purposes
        EmbedAsAttr m (Attr String String),