Initial

4 files changed, 190 insertions, 0 deletions

diff --git a/src/Text/BlazeT/Renderer/Pretty.hs b/src/Text/BlazeT/Renderer/Pretty.hs
new file mode 100644
index 0000000..8977c94
--- /dev/null
+++ b/src/Text/BlazeT/Renderer/Pretty.hs
@@ -0,0 +1,22 @@
+module Text.BlazeT.Renderer.Pretty
+    ( renderMarkup
+    , renderHtml
+    , renderMarkupT
+    , renderHtmlT
+  ) where
+
+import           Control.Monad
+import           Control.Monad.Identity
+import qualified Text.Blaze.Renderer.Pretty as BU
+import           Text.BlazeT
+
+renderMarkup :: MarkupM a -> String
+renderMarkup = runIdentity . renderMarkupT
+renderMarkupT :: Monad m => MarkupT m a -> m String
+renderMarkupT = liftM BU.renderMarkup . execMarkupT
+
+renderHtml :: MarkupM a -> String
+renderHtml = renderMarkup
+renderHtmlT :: Monad m => MarkupT m a -> m String
+renderHtmlT = renderMarkupT
+
diff --git a/src/Text/BlazeT/Renderer/String.hs b/src/Text/BlazeT/Renderer/String.hs
new file mode 100644
index 0000000..0a2de8a
--- /dev/null
+++ b/src/Text/BlazeT/Renderer/String.hs
@@ -0,0 +1,27 @@
+module Text.BlazeT.Renderer.String
+    ( fromChoiceString
+    , renderMarkup
+    , renderHtml
+    , renderMarkupT
+    , renderHtmlT
+  ) where
+
+import           Control.Monad
+import           Control.Monad.Identity
+import           Text.Blaze.Internal (ChoiceString)
+import qualified Text.Blaze.Renderer.String as BU
+import           Text.BlazeT
+
+fromChoiceString :: ChoiceString -> String -> String       
+fromChoiceString = BU.fromChoiceString
+
+renderMarkup :: MarkupM a -> String
+renderMarkup = runIdentity . renderMarkupT
+renderMarkupT :: Monad m => MarkupT m a -> m String
+renderMarkupT = liftM BU.renderMarkup . execMarkupT
+
+renderHtml :: MarkupM a -> String
+renderHtml = renderMarkup
+renderHtmlT :: Monad m => MarkupT m a -> m String
+renderHtmlT = renderMarkupT
+
diff --git a/src/Text/BlazeT/Renderer/Text.hs b/src/Text/BlazeT/Renderer/Text.hs
new file mode 100644
index 0000000..31181eb
--- /dev/null
+++ b/src/Text/BlazeT/Renderer/Text.hs
@@ -0,0 +1,75 @@
+module Text.BlazeT.Renderer.Text
+    ( renderMarkupBuilderT
+    , renderMarkupBuilder
+    , renderMarkupBuilderWithT
+    , renderMarkupT
+    , renderMarkupWithT
+    , renderHtmlBuilderT
+    , renderHtmlBuilderWithT
+    , renderHtmlT
+    , renderHtmlWithT
+    , renderMarkupBuilderWith
+    , renderMarkup
+    , renderMarkupWith
+    , renderHtmlBuilder
+    , renderHtmlBuilderWith
+    , renderHtml
+    , renderHtmlWith
+  ) where
+
+import           Control.Monad
+import           Data.ByteString (ByteString)
+import           Control.Monad.Identity
+import           Data.Text (Text)
+import qualified Data.Text.Lazy as L
+import qualified Data.Text.Lazy.Builder as B
+import qualified Text.Blaze.Html.Renderer.Text as BH
+import qualified Text.Blaze.Renderer.Text as BU
+import           Text.BlazeT
+
+renderMarkupBuilder :: MarkupM a -> B.Builder
+renderMarkupBuilder = runIdentity . renderMarkupBuilderT
+
+renderMarkupBuilderT :: Monad m => MarkupT m a -> m B.Builder
+renderMarkupBuilderT = liftM BU.renderMarkupBuilder . execMarkupT
+
+renderHtmlBuilder :: MarkupM a -> B.Builder
+renderHtmlBuilder = renderMarkupBuilder
+
+renderHtmlBuilderT :: Monad m => MarkupT m a -> m B.Builder
+renderHtmlBuilderT = renderMarkupBuilderT
+
+renderMarkup :: MarkupM a -> L.Text
+renderMarkup = runIdentity . renderMarkupT
+renderMarkupT :: Monad m => MarkupT m a -> m L.Text
+renderMarkupT = liftM BU.renderMarkup . execMarkupT
+
+renderHtml :: MarkupM a -> L.Text
+renderHtml = renderMarkup
+renderHtmlT :: Monad m => MarkupT m a -> m L.Text
+renderHtmlT = renderMarkupT
+
+renderMarkupWithT :: Monad m => (ByteString -> Text) -> MarkupT m a -> m L.Text
+renderMarkupWithT g = liftM (BU.renderMarkupWith g) . execMarkupT
+
+renderMarkupWith :: (ByteString -> Text) -> MarkupM a -> L.Text
+renderMarkupWith g = runIdentity . renderMarkupWithT g
+
+renderHtmlWithT :: Monad m => (ByteString -> Text) -> MarkupT m a -> m L.Text
+renderHtmlWithT g = liftM (BH.renderHtmlWith g) . execMarkupT
+
+renderHtmlWith :: (ByteString -> Text) -> MarkupM a -> L.Text
+renderHtmlWith g = runIdentity . renderHtmlWithT g
+
+renderHtmlBuilderWithT :: Monad m => (ByteString -> Text) -> MarkupT m a -> m B.Builder       
+renderHtmlBuilderWithT g = liftM (BH.renderHtmlBuilderWith g) . execMarkupT
+
+renderHtmlBuilderWith :: (ByteString -> Text) -> MarkupM a -> B.Builder       
+renderHtmlBuilderWith g = runIdentity . renderHtmlBuilderWithT g
+
+
+renderMarkupBuilderWithT :: Monad m => (ByteString -> Text) -> MarkupT m a -> m B.Builder      
+renderMarkupBuilderWithT g = liftM (BU.renderMarkupBuilderWith g) . execMarkupT
+
+renderMarkupBuilderWith :: (ByteString -> Text) -> MarkupM a -> B.Builder       
+renderMarkupBuilderWith g = runIdentity . renderMarkupBuilderWithT g
diff --git a/src/Text/BlazeT/Renderer/Utf8.hs b/src/Text/BlazeT/Renderer/Utf8.hs
new file mode 100644
index 0000000..292f81f
--- /dev/null
+++ b/src/Text/BlazeT/Renderer/Utf8.hs
@@ -0,0 +1,66 @@
+{-# OPTIONS_GHC -fsimpl-tick-factor=230 #-}
+
+-- the above option was not needed with
+  --   ,blaze-html >= 0.6.0.0 && < 0.7.0.0
+  --   ,blaze-builder >= 0.2
+  --   ,text  < 1.2
+
+module Text.BlazeT.Renderer.Utf8
+    (
+    renderMarkupBuilder
+    , renderMarkup
+    , renderMarkupToByteStringIO
+    , renderHtmlBuilder
+    , renderHtml
+    , renderHtmlToByteStringIO
+
+    -- * new BlazeT stuff
+    , renderMarkupBuilderT
+    , renderMarkupT
+    , renderMarkupToByteStringIOT
+    , renderHtmlToByteStringIOT
+    , renderHtmlBuilderT
+    , renderHtmlT
+  ) where
+
+import qualified Blaze.ByteString.Builder as B
+import           Control.Monad
+import           Control.Monad.Identity
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Lazy as BL
+import qualified Text.Blaze.Renderer.Utf8 as BU
+import           Text.BlazeT
+
+renderMarkupBuilder :: MarkupM a -> B.Builder
+renderMarkupBuilder = runIdentity . renderMarkupBuilderT
+
+renderMarkupBuilderT :: Monad m => MarkupT m a -> m B.Builder
+renderMarkupBuilderT = liftM BU.renderMarkupBuilder . execMarkupT
+
+renderHtmlBuilder :: MarkupM a -> B.Builder
+renderHtmlBuilder = renderMarkupBuilder
+
+renderHtmlBuilderT :: Monad m => MarkupT m a -> m B.Builder
+renderHtmlBuilderT = renderMarkupBuilderT
+
+renderMarkup :: MarkupM a -> BL.ByteString
+renderMarkup = runIdentity . renderMarkupT
+renderMarkupT :: Monad m => MarkupT m a -> m BL.ByteString
+renderMarkupT = liftM BU.renderMarkup . execMarkupT
+
+renderHtml :: MarkupM a -> BL.ByteString
+renderHtml = renderMarkup
+renderHtmlT :: Monad m => MarkupT m a -> m BL.ByteString
+renderHtmlT = renderMarkupT
+
+renderMarkupToByteStringIO :: (BS.ByteString -> IO ()) -> MarkupM a -> IO ()
+renderMarkupToByteStringIO g = runIdentity . renderMarkupToByteStringIOT g 
+renderMarkupToByteStringIOT :: Monad m => (BS.ByteString -> IO ()) ->
+                               MarkupT m a -> m (IO ())
+renderMarkupToByteStringIOT g = liftM (BU.renderMarkupToByteStringIO g) . execMarkupT
+
+renderHtmlToByteStringIO :: (BS.ByteString -> IO ()) -> MarkupM a -> IO ()
+renderHtmlToByteStringIO g = runIdentity . renderMarkupToByteStringIOT g 
+renderHtmlToByteStringIOT :: Monad m => (BS.ByteString -> IO ()) ->
+                             MarkupT m a -> m (IO ())
+renderHtmlToByteStringIOT g = liftM (BU.renderMarkupToByteStringIO g) . execMarkupT