Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Text.Shakespeare
Description
future releases.
Synopsis
- data ShakespeareSettings = ShakespeareSettings {
- varChar :: Char
- urlChar :: Char
- intChar :: Char
- toBuilder :: Exp
- wrap :: Exp
- unwrap :: Exp
- justVarInterpolation :: Bool
- preConversion :: Maybe PreConvert
- modifyFinalValue :: Maybe Exp
- data PreConvert = PreConvert {
- preConvert :: PreConversion
- preEscapeIgnoreBalanced :: [Char]
- preEscapeIgnoreLine :: [Char]
- wrapInsertion :: Maybe WrapInsertion
- data WrapInsertion = WrapInsertion {
- wrapInsertionIndent :: Maybe String
- wrapInsertionStartBegin :: String
- wrapInsertionSeparator :: String
- wrapInsertionStartClose :: String
- wrapInsertionEnd :: String
- wrapInsertionAddParens :: Bool
- data PreConversion
- = ReadProcess String [String]
- | Id
- defaultShakespeareSettings :: ShakespeareSettings
- shakespeare :: ShakespeareSettings -> QuasiQuoter
- shakespeareFile :: ShakespeareSettings -> FilePath -> Q Exp
- shakespeareFileReload :: ShakespeareSettings -> FilePath -> Q Exp
- shakespeareFromString :: ShakespeareSettings -> String -> Q Exp
- shakespeareUsedIdentifiers :: ShakespeareSettings -> String -> [(Deref, VarType)]
- type RenderUrl url = url -> QueryParameters -> Text
- data VarType
- = VTPlain
- | VTUrl
- | VTUrlParam
- | VTMixin
- data Deref
- type Parser = Parsec String [String]
- preFilter :: Maybe FilePath -> ShakespeareSettings -> String -> IO String
- shakespeareRuntime :: ShakespeareSettings -> FilePath -> [(Deref, VarExp url)] -> Shakespeare url
- pack' :: String -> Text
Documentation
data ShakespeareSettings Source #
Constructors
ShakespeareSettings | |
Fields
|
Instances
Lift ShakespeareSettings Source # | |
Defined in Text.Shakespeare Methods lift :: Quote m => ShakespeareSettings -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => ShakespeareSettings -> Code m ShakespeareSettings |
data PreConvert Source #
Coffeescript, TypeScript, and other languages compiles down to Javascript. Previously we waited until the very end, at the rendering stage to perform this compilation. Lets call is a post-conversion This had the advantage that all Haskell values were inserted first: for example a value could be inserted that Coffeescript would compile into Javascript. While that is perhaps a safer approach, the advantage is not used in practice: it was that way mainly for ease of implementation. The down-side is the template must be compiled down to Javascript during every request. If instead we do a pre-conversion to compile down to Javascript, we only need to perform the compilation once.
The problem then is the insertion of Haskell values: we need a hole for them. This can be done with variables known to the language. During the pre-conversion we first modify all Haskell insertions So #{a} is change to shakespeare_var_a Then we can place the Haskell values in a function wrapper that exposes those variables: (function(shakespeare_var_a){ ... shakespeare_var_a ...}) TypeScript can compile that, and then we tack an application of the Haskell values onto the result: (#{a})
preEscapeIgnoreBalanced is used to not insert backtacks for variable already inside strings or backticks.
coffeescript will happily ignore the interpolations, and backticks would not be treated as escaping in that context.
preEscapeIgnoreLine was added to ignore comments (which in Coffeescript begin with a #
)
Constructors
PreConvert | |
Fields
|
Instances
Lift PreConvert Source # | |
Defined in Text.Shakespeare Methods lift :: Quote m => PreConvert -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => PreConvert -> Code m PreConvert |
data WrapInsertion Source #
Constructors
WrapInsertion | |
Fields
|
Instances
Lift WrapInsertion Source # | |
Defined in Text.Shakespeare Methods lift :: Quote m => WrapInsertion -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => WrapInsertion -> Code m WrapInsertion |
data PreConversion Source #
Constructors
ReadProcess String [String] | |
Id |
Instances
Lift PreConversion Source # | |
Defined in Text.Shakespeare Methods lift :: Quote m => PreConversion -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => PreConversion -> Code m PreConversion |
shakespeare :: ShakespeareSettings -> QuasiQuoter Source #
shakespeareFile :: ShakespeareSettings -> FilePath -> Q Exp Source #
shakespeareFileReload :: ShakespeareSettings -> FilePath -> Q Exp Source #
low-level
shakespeareFromString :: ShakespeareSettings -> String -> Q Exp Source #
shakespeareUsedIdentifiers :: ShakespeareSettings -> String -> [(Deref, VarType)] Source #
Determine which identifiers are used by the given template, useful for creating systems like yesod devel.
Constructors
VTPlain | |
VTUrl | |
VTUrlParam | |
VTMixin |
Instances
Data VarType Source # | |
Defined in Text.Shakespeare Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarType -> c VarType gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarType dataTypeOf :: VarType -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VarType) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarType) gmapT :: (forall b. Data b => b -> b) -> VarType -> VarType gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarType -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarType -> r gmapQ :: (forall d. Data d => d -> u) -> VarType -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> VarType -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarType -> m VarType gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarType -> m VarType gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarType -> m VarType | |
Bounded VarType Source # | |
Defined in Text.Shakespeare | |
Enum VarType Source # | |
Defined in Text.Shakespeare | |
Generic VarType Source # | |
Show VarType Source # | |
Eq VarType Source # | |
Ord VarType Source # | |
type Rep VarType Source # | |
Defined in Text.Shakespeare type Rep VarType = D1 ('MetaData "VarType" "Text.Shakespeare" "shakespeare-2.1.0-HLkpr67uM7x6DVX5ul0JfU" 'False) ((C1 ('MetaCons "VTPlain" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VTUrl" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "VTUrlParam" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VTMixin" 'PrefixI 'False) (U1 :: Type -> Type))) |
Instances
Data Deref Source # | |
Defined in Text.Shakespeare.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Deref -> c Deref gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Deref dataTypeOf :: Deref -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Deref) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Deref) gmapT :: (forall b. Data b => b -> b) -> Deref -> Deref gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Deref -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Deref -> r gmapQ :: (forall d. Data d => d -> u) -> Deref -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Deref -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Deref -> m Deref gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Deref -> m Deref gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Deref -> m Deref | |
Read Deref Source # | |
Defined in Text.Shakespeare.Base | |
Show Deref Source # | |
Eq Deref Source # | |
Ord Deref Source # | |
Lift Deref Source # | |
Arguments
:: Maybe FilePath | for error reporting |
-> ShakespeareSettings | |
-> String | |
-> IO String |
Internal
shakespeareRuntime :: ShakespeareSettings -> FilePath -> [(Deref, VarExp url)] -> Shakespeare url Source #