diff --git a/README.markdown b/README.markdown --- a/README.markdown +++ b/README.markdown @@ -12,7 +12,7 @@ * regular expression macros including: + a number of useful RE macros; + a test bench for testing and documenting new macro environments; - * built-in support for the TDFA and PCRE backends; + * built-in support for the TDFA and PCRE back ends; * comprehensive documentation, tutorials and copious examples. @@ -78,7 +78,7 @@     ☒  2017-04-04 v0.14.0.0 [Move IsOption, rename Find functions](https://github.com/iconnect/regex/milestone/18) -    ☐  2017-04-10 v1.0.0.0 [First stable release](https://github.com/iconnect/regex/milestone/3) +    ☒  2017-04-10 v1.0.0.0 [First stable release](https://github.com/iconnect/regex/milestone/3)     ☐  2017-08-31 v2.0.0.0 [Fast text replacement with benchmarks](https://github.com/iconnect/regex/milestone/4) diff --git a/Text/RE.hs b/Text/RE.hs --- a/Text/RE.hs +++ b/Text/RE.hs @@ -17,36 +17,8 @@ -- * Further Use -- $further - - -- * The regex Foundational Types - -- ** Matches - Matches - , matchesSource - , allMatches - , anyMatches - , countMatches - , matches - -- ** Match - , Match - , matchSource - , matched - , matchedText - - -- * IsRegex - -- $isregex - , IsRegex(..) - , searchReplaceAll - , searchReplaceFirst - -- * IsRegex Instances - -- $instances - , module Text.RE.TDFA ) where -import Text.RE.TDFA() -import Text.RE.ZeInternals.Types.IsRegex -import Text.RE.ZeInternals.Types.Match -import Text.RE.ZeInternals.Types.Matches - -- $tutorial -- -- We have a regex tutorial at . @@ -91,17 +63,7 @@ -- For more specialist applications we have the following: -- -- * "Text.RE.REOptions" for specifying back-end specific options; --- * "Text.RE.Replace" for the full replace toolkit; +-- * "Text.RE.Replace" for the full text-replacement toolkit; -- * "Text.RE.TestBench" for building up, testing and doumenting; -- macro environments for use in REs; -- * "Text.RE.Tools" for an AWK-like text-processing toolkit. - --- $isregex --- Class @IsRegex re t@ provides methods for matching the @t@ type for --- the @re@ back end as well as compiling REs from @t@ to @re@ and --- getting the source @t@ back again. The 'Replace' superclass of --- @IsRegex@ contains a useful toolkit for converting between @t@ and --- 'String' abd @Text@. - --- $instances --- This module import just imports the @IsRegex TDFA s@ instances. diff --git a/Text/RE/REOptions.lhs b/Text/RE/REOptions.lhs --- a/Text/RE/REOptions.lhs +++ b/Text/RE/REOptions.lhs @@ -12,8 +12,12 @@ module Text.RE.REOptions ( - -- * RE Options + -- * The Options Tutorial + -- $tutorial + + -- * 'SimpleREOptions' SimpleREOptions(..) + -- * 'REOptions_' , REOptions_(..) -- * The Macro Tables , Macros @@ -60,7 +64,7 @@ -- and its @CompOption@ and @ExecOption@ types (the compile-time and -- execution time options, respectively); each back end will define an -- @REOptions@ type that fills out these three type parameters with the --- apropriate types (see, for example, "Text.RE.ZeInternals.TDFA") +-- apropriate types (see, for example, "Text.RE.TDFA") data REOptions_ r c e = REOptions { optionsMacs :: !(Macros r) -- ^ the available TestBench RE macros @@ -75,7 +79,7 @@ ---------------- \begin{code} --- | our macro tables are parameterised over the backend @RE@ type and +-- | our macro tables are parameterised over the back end @RE@ type and -- and just associate each @MacroID@ with an @RE@ (which may in turn -- contain macros to be expanded) type Macros r = HM.HashMap MacroID r @@ -99,4 +103,13 @@ -- | a macro table containing no entries emptyMacros :: Macros r emptyMacros = HM.empty +\end{code} + + +\begin{code} +-- $tutorial +-- This API module provides the generic types used to specify the options +-- when compiling REs for each of the backl ends. +-- +-- See the tutorials at http://re-tutorial-options.regex.uk \end{code} diff --git a/Text/RE/Replace.hs b/Text/RE/Replace.hs --- a/Text/RE/Replace.hs +++ b/Text/RE/Replace.hs @@ -1,11 +1,10 @@ module Text.RE.Replace ( - -- * REContext and RELocation - REContext(..) - , RELocation(..) - , isTopLocation + -- * The Replacing Tutorial + -- $tutorial + -- * replaceAll - , replaceAll + replaceAll , replaceAllCaptures , replaceAllCaptures_ , replaceAllCapturesM @@ -14,10 +13,10 @@ , replaceCaptures , replaceCaptures_ , replaceCapturesM - -- * Replace and ReplaceMethods - , Replace(..) - , ReplaceMethods(..) - , replaceMethods + -- * REContext and RELocation + , REContext(..) + , RELocation(..) + , isTopLocation -- * Matches , Matches(..) , anyMatches @@ -53,6 +52,10 @@ , CaptureName(..) , CaptureOrdinal(..) , findCaptureID + -- * Replace and ReplaceMethods + , Replace(..) + , ReplaceMethods(..) + , replaceMethods ) where import Text.RE.ZeInternals.Replace @@ -60,3 +63,11 @@ import Text.RE.ZeInternals.Types.CaptureID import Text.RE.ZeInternals.Types.Match import Text.RE.ZeInternals.Types.Matches + +-- $tutorial +-- This API module covers the specialised regex tools for doing general +-- editing on text, including the internal details of the 'Matches' and +-- 'Match' types and the associated functions for extracting captures +-- and applying functions to them to transform the subject text. +-- +-- See the tutorials at http://re-tutorial-replacing.regex.uk diff --git a/Text/RE/Summa.hs b/Text/RE/Summa.hs --- a/Text/RE/Summa.hs +++ b/Text/RE/Summa.hs @@ -14,7 +14,7 @@ -- $collection -- -- This module collects together all of the generic regex APIs not --- exported by the back-end-specific API modules. The regex --- API is modular with only the most common types and functions being --- exported by these modules but the remaining modules may be imported --- en masse by importing this module. +-- exported by the principal API modules, specialised for each back end +-- and text type. The regex API is modular with only the most common types +-- and functions being exported by these modules but the remaining modules +-- may be imported en masse by importing this module. diff --git a/Text/RE/TDFA.hs b/Text/RE/TDFA.hs --- a/Text/RE/TDFA.hs +++ b/Text/RE/TDFA.hs @@ -14,50 +14,96 @@ -- * About this Module -- $about - -- * The Match Operators + -- * The 'Matches' and 'Match' Operators (*=~) , (?=~) - -- * The SearchReplace Operators + -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE + , regexType + , reOptions , reSource + , reCaptureNames + , reRegex -- * Options -- $options , SimpleREOptions(..) + , IsOption(..) + , REOptions + , defaultREOptions + , noPreludeREOptions + , unpackSimpleREOptions -- * Compiling and Escaping REs , SearchReplace(..) , compileRegex , compileRegexWith + , compileRegexWithOptions , compileSearchReplace , compileSearchReplaceWith + , compileSearchReplaceWithOptions , escape , escapeWith + , escapeWithOptions , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA - -- * The Operator Instances + , ed + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * RE Macros Standard Environment + -- $prelude + , prelude + , preludeEnv + , preludeTestsFailing + , preludeTable + , preludeSummary + , preludeSources + , preludeSource + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex + -- * The IsRegex Instances -- $instances , module Text.RE.TDFA.ByteString , module Text.RE.TDFA.ByteString.Lazy @@ -68,18 +114,18 @@ ) where import Text.RE.REOptions +import Text.RE.Replace import Text.RE.TDFA.ByteString() import Text.RE.TDFA.ByteString.Lazy() import Text.RE.TDFA.Sequence() import Text.RE.TDFA.String() import Text.RE.TDFA.Text() import Text.RE.TDFA.Text.Lazy() -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex -import Text.RE.ZeInternals.Types.Match -import Text.RE.ZeInternals.Types.Matches import qualified Text.Regex.Base as B import qualified Text.Regex.TDFA as TDFA @@ -144,26 +190,64 @@ -- $about -- This module provides access to the back end through polymorphic functions -- that operate over all of the String\/Text\/ByteString types supported by the --- back end. If you don't need this generality then you might want to consider --- using one of the modules that have been specialised for each of these types: +-- back end. The module also provides all of the specialised back-end functionality +-- that will not be needed by most regex clientts. If you don't need this generality +-- then you might want to consider using one of the simpler modules that have been +-- specialised for each of these types: -- -- * "Text.RE.TDFA.ByteString" -- * "Text.RE.TDFA.ByteString.Lazy" --- * "Text.RE.ZeInternals.TDFA" -- * "Text.RE.TDFA.Sequence" -- * "Text.RE.TDFA.String" -- * "Text.RE.TDFA.Text" -- * "Text.RE.TDFA.Text.Lazy" +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + +-- $options +-- You can specify different compilation options by appending a +-- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter +-- to select the corresponding compilation option. For example, the +-- section, +-- +-- @(?=~/ [edBlockInsensitive|foo$\/\/\/bar|])@ +-- +-- will replace a @foo@ suffix of the argument text, of any +-- capitalisation, with a (lower case) @bar@. If you need to specify the +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ +-- quasi quoters, which generate functions that take an 'IsOption' option +-- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' +-- as apropriate. For example if you have a 'SimpleReOptions' value in +-- @sro@ then +-- +-- @(?=~/ [ed_|foo$\/\/\/bar|] sro)@ +-- +-- will compile the @foo$@ RE according to the value of @sro@. For more +-- on specifying RE options see "Text.RE.REOptions". + -- $re -- The @[re|.*|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"), and the -- specialised back-end types and functions. -- $ed --- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different --- options to the RE compiler (see "Text.RE.REOptions"). +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. + -- $instances -- --- These modules merely provide the 'IsRegex' instances. +-- These module exports merely provide the 'IsRegex' instances. diff --git a/Text/RE/TDFA/ByteString.hs b/Text/RE/TDFA/ByteString.hs --- a/Text/RE/TDFA/ByteString.hs +++ b/Text/RE/TDFA/ByteString.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where import qualified Data.ByteString as B @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.ByteString import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: B.ByteString -> SearchReplace RE B.ByteString -> B.ByteString (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex B.ByteString a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => B.ByteString -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex B.ByteString a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => B.ByteString -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TDFA/ByteString/Lazy.hs b/Text/RE/TDFA/ByteString/Lazy.hs --- a/Text/RE/TDFA/ByteString/Lazy.hs +++ b/Text/RE/TDFA/ByteString/Lazy.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where import qualified Data.ByteString.Lazy.Char8 as LBS @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: LBS.ByteString -> SearchReplace RE LBS.ByteString -> LBS.ByteString (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex LBS.ByteString a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => LBS.ByteString -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex LBS.ByteString a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => LBS.ByteString -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TDFA/Sequence.hs b/Text/RE/TDFA/Sequence.hs --- a/Text/RE/TDFA/Sequence.hs +++ b/Text/RE/TDFA/Sequence.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.Sequence + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where import qualified Data.Sequence as S @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.Sequence import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char) (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex (S.Seq Char) a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => (S.Seq Char) -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex (S.Seq Char) a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => (S.Seq Char) -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TDFA/String.hs b/Text/RE/TDFA/String.hs --- a/Text/RE/TDFA/String.hs +++ b/Text/RE/TDFA/String.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.String + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.String import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: String -> SearchReplace RE String -> String (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex String a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => String -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex String a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => String -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TDFA/Text.hs b/Text/RE/TDFA/Text.hs --- a/Text/RE/TDFA/Text.hs +++ b/Text/RE/TDFA/Text.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.Text + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where import qualified Data.Text as T @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.Text import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: T.Text -> SearchReplace RE T.Text -> T.Text (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex T.Text a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => T.Text -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex T.Text a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => T.Text -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TDFA/Text/Lazy.hs b/Text/RE/TDFA/Text/Lazy.hs --- a/Text/RE/TDFA/Text/Lazy.hs +++ b/Text/RE/TDFA/Text/Lazy.hs @@ -20,18 +20,21 @@ -- * The 'SearchReplace' Operators , (*=~/) , (?=~/) - -- * Matches + -- * The 'Matches' Type , Matches , matchesSource , allMatches , anyMatches , countMatches , matches - -- * Match + -- * The 'Match' Type , Match , matchSource , matched , matchedText + -- * The Macros and Parsers + -- $macros + , module Text.RE.TestBench.Parsers -- * The 'RE' Type , RE , reSource @@ -47,16 +50,38 @@ , escape , escapeWith , escapeREString - -- * The Classic rexex-base Match Operators + -- * The Classic regex-base Match Operators , (=~) , (=~~) - -- * IsRegex - , IsRegex(..) - -- * The Quasi Quoters and Minor Functions + -- * The re Quasi Quoters -- $re - , module Text.RE.ZeInternals.TDFA + , re + , reMultilineSensitive + , reMultilineInsensitive + , reBlockSensitive + , reBlockInsensitive + , reMS + , reMI + , reBS + , reBI + , re_ + -- * The Ed Quasi Quoters -- $ed - , module Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed + , edMS + , edMI + , edBS + , edBI + , ed_ + -- * The cp Quasi Quoters + , cp + -- * IsRegex + -- $isregex + , module Text.RE.Tools.IsRegex ) where import qualified Data.Text.Lazy as TL @@ -64,10 +89,11 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.TestBench.Parsers +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex import Text.Regex.Base import qualified Text.Regex.TDFA as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll -- | search and replace the first occurrence only (if any) in the input text --- e.g., to prefix the first string of four hex digits in the imput text, +-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- -- @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@ @@ -110,22 +136,20 @@ (?=~/) :: TL.Text -> SearchReplace RE TL.Text -> TL.Text (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator +-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a , RegexContext TDFA.Regex TL.Text a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => TL.Text -> RE -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator +-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m , Functor m , Typeable a , RegexContext TDFA.Regex TL.Text a - , RegexMaker TDFA.Regex TDFA.CompOption TDFA.ExecOption String ) => TL.Text -> RE @@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at . +-- $macros +-- There are a number of RE macros and corresponding Haskell parsers +-- for parsing the matched text into appropriate Haskell types. See +-- the [Macros Tables](http://regex.uk/macros) for details. + -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter @@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the --- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@ +-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in @@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"). + +-- $ed +-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example, +-- +-- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ +-- +-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date +-- into a DD\/MM\/YYYY format date. +-- +-- The only difference betweem these quasi quoters is the RE options that are set, +-- using the same conventions as the @[re| ... |]@ quasi quoters. + +-- $isregex +-- The 'IsRegex' class is used to abstact over the different regex back ends and +-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details. diff --git a/Text/RE/TestBench.hs b/Text/RE/TestBench.hs --- a/Text/RE/TestBench.hs +++ b/Text/RE/TestBench.hs @@ -3,6 +3,9 @@ module Text.RE.TestBench ( + -- * The Test Bench Tutorial + -- $tutorial + -- * The Test Bench MacroEnv , MacroDescriptor(..) @@ -19,34 +22,23 @@ , formatMacroSummary , formatMacroSources , formatMacroSource + , mdRegexSource -- ** Formatting Macros , testMacroEnv , runTests , runTests' - -- * Parsing - , parseInteger - , parseHex - , parseDouble - , parseString - , parseSimpleString - , parseDate - , parseSlashesDate - , parseTimeOfDay - , parseTimeZone - , parseDateTime - , parseDateTime8601 - , parseDateTimeCLF - , parseShortMonth - , shortMonthArray - , IPV4Address - , parseIPv4Address - , Severity(..) - , parseSeverity - , severityKeywords - -- * Text.RE - , module Text.RE + -- * The Parsers + , module Text.RE.TestBench.Parsers + -- * The Match Type + , Match ) where -import Text.RE +import Text.RE.TestBench.Parsers import Text.RE.ZeInternals.TestBench -import Text.RE.ZeInternals.TestBench.Parsers +import Text.RE.ZeInternals.Types.Match + +-- $tutorial +-- This API module provides a test bench for developing, documenting and +-- testing regex RE macros. +-- +-- See the tutorials at http://re-tutorial-testbench.regex.uk diff --git a/Text/RE/TestBench/Parsers.hs b/Text/RE/TestBench/Parsers.hs new file mode 100644 --- /dev/null +++ b/Text/RE/TestBench/Parsers.hs @@ -0,0 +1,23 @@ +module Text.RE.TestBench.Parsers + ( parseInteger + , parseHex + , parseDouble + , parseString + , parseSimpleString + , parseDate + , parseSlashesDate + , parseTimeOfDay + , parseTimeZone + , parseDateTime + , parseDateTime8601 + , parseDateTimeCLF + , parseShortMonth + , shortMonthArray + , IPV4Address + , parseIPv4Address + , Severity(..) + , parseSeverity + , severityKeywords + ) where + +import Text.RE.ZeInternals.TestBench.Parsers diff --git a/Text/RE/Tools.hs b/Text/RE/Tools.hs --- a/Text/RE/Tools.hs +++ b/Text/RE/Tools.hs @@ -1,7 +1,9 @@ +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} + module Text.RE.Tools ( - -- * The Tools - -- $tools + -- * The Tools Tutorial + -- $tutorial -- * Sed sed @@ -25,6 +27,9 @@ , findMatches_' -- * IsRegex , IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst -- * Edit , Edits(..) , Edit(..) @@ -37,13 +42,19 @@ , firstLine , getLineNo , lineNo - -- * Text.RE - , module Text.RE + -- * Replace + , module Text.RE.Replace ) where -import Text.RE +import Text.RE.Replace import Text.RE.Tools.Edit import Text.RE.Tools.Find import Text.RE.Tools.Grep import Text.RE.Tools.Lex import Text.RE.Tools.Sed + +-- $tutorial +-- This API module provides some familiar RE tools on top of the core +-- package functions and types. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk diff --git a/Text/RE/Tools/Edit.lhs b/Text/RE/Tools/Edit.lhs --- a/Text/RE/Tools/Edit.lhs +++ b/Text/RE/Tools/Edit.lhs @@ -10,52 +10,63 @@ module Text.RE.Tools.Edit ( -- * Editing + -- $tutorial Edits(..) , Edit(..) - , SearchReplace(..) , LineEdit(..) , applyEdits , applyEdit , applyLineEdit + -- * IsRegex + , IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst -- * LineNo , LineNo(..) , firstLine , getLineNo , lineNo - -- * Text.RE - , module Text.RE + -- * Replace + , module Text.RE.Replace ) where import Data.Maybe import Prelude.Compat -import Text.RE import Text.RE.Replace -import Text.RE.ZeInternals.Types.IsRegex +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.Types.LineNo +\end{code} +\begin{code} -- | an 'Edits' script will, for each line in the file, either perform -- the action selected by the first RE in the list, or perform all of the -- actions on line, arranged as a pipeline data Edits m re s - = Select ![Edit m re s] - | Pipe ![Edit m re s] + = Select ![Edit m re s] -- ^ for each line select the first @Edit@ to match each line and edit the line with it + | Pipe ![Edit m re s] -- ^ for each line apply every edit that matches in turn to the line -- | each Edit action specifies how the match should be processed data Edit m re s = Template !(SearchReplace re s) + -- ^ replace the match with this template text, substituting ${capture} as apropriate | Function !re REContext !(LineNo->Match s->RELocation->Capture s->m (Maybe s)) + -- ^ use this function to replace the 'REContext' specified captures in each line matched | LineEdit !re !(LineNo->Matches s->m (LineEdit s)) + -- ^ use this function to edit each line matched -- | a LineEdit is the most general action thar can be performed on a line -- and is the only means of deleting a line data LineEdit s - = NoEdit - | ReplaceWith !s - | Delete + = NoEdit -- ^ do not edit this line but leave as is + | ReplaceWith !s -- ^ replace the line with this text (terminating newline should not be included) + | Delete -- ^ delete the this line altogether deriving (Functor,Show) +\end{code} +\begin{code} -- | apply an 'Edit' script to a single line applyEdits :: (IsRegex re s,Monad m,Functor m) => LineNo @@ -122,4 +133,12 @@ f edit act = do s <- act fromMaybe s <$> applyEdit id lno edit s +\end{code} + +\begin{code} +-- $tutorial +-- The Edit toolkit looks for REs that match a text and runs the +-- associated actions. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code} diff --git a/Text/RE/Tools/Find.lhs b/Text/RE/Tools/Find.lhs --- a/Text/RE/Tools/Find.lhs +++ b/Text/RE/Tools/Find.lhs @@ -7,19 +7,29 @@ #endif module Text.RE.Tools.Find - ( FindMethods(..) + ( + -- * Find + -- $tutorial + FindMethods(..) , findMatches_ , findMatches_' - -- * Text.RE - , module Text.RE + -- * IsRegex + , IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst + -- * Replace + , module Text.RE.Replace ) where import qualified Data.List as L import Prelude.Compat -import Text.RE import Text.RE.Replace +import Text.RE.Tools.IsRegex +\end{code} +\begin{code} -- | as we don't want the @directory@ and FilePath dependencies -- we will abstract the three calls we need into this record type data FindMethods s = @@ -31,8 +41,10 @@ -- System.Directory , combineDM :: s -> s -> s -- ^ from System.FilePath } +\end{code} +\begin{code} -- | recursively list all files whose filename matches given RE, -- sorting the list into ascending order; if the argument path has a -- trailing '/' then it will be removed @@ -68,4 +80,12 @@ where abs_path fn_ = fp `combineDM` fn_ ordinary fn_ = not $ fn_ `elem` [packR ".",packR ".."] +\end{code} + +\begin{code} +-- $tutorial +-- The Find toolkit traverses directory trees invoking actions for each +-- file that matches a RE. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code} diff --git a/Text/RE/Tools/Grep.lhs b/Text/RE/Tools/Grep.lhs --- a/Text/RE/Tools/Grep.lhs +++ b/Text/RE/Tools/Grep.lhs @@ -5,7 +5,10 @@ {-# LANGUAGE CPP #-} module Text.RE.Tools.Grep - ( grep + ( + -- Grep + -- $tutorial + grep , Verbosity(..) , Line(..) , grepLines @@ -16,33 +19,42 @@ , linesMatched -- * IsRegex , IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst -- * LineNo , LineNo(..) , firstLine , getLineNo , lineNo - -- * Text.RE - , module Text.RE + -- * Replace + , module Text.RE.Replace ) where import qualified Data.ByteString.Lazy.Char8 as LBS import Prelude.Compat import Text.Printf -import Text.RE -import Text.RE.ZeInternals.Replace +import Text.RE.Replace +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.Types.LineNo +\end{code} +\begin{code} -- | operates a bit like classic @grep@ printing out the lines matched grep :: IsRegex re LBS.ByteString => Verbosity -> re -> FilePath -> IO () grep v rex fp = grepLines rex fp >>= putStr . report v +\end{code} +\begin{code} -- | specifies whether to return the linss matched or missed data Verbosity = LinesMatched | LinesNotMatched deriving (Show,Eq,Ord) +\end{code} +\begin{code} -- | 'grepLines' returns a 'Line' for each line in the file, listing all -- of the 'Matches' for that line data Line s = @@ -51,7 +63,9 @@ , getLineMatches :: Matches s -- ^ all the 'Matches' of the RE on this line } deriving (Show) +\end{code} +\begin{code} -- | returns a 'Line' for each line in the file, enumerating all of the -- matches for that line grepLines :: IsRegex re LBS.ByteString @@ -59,14 +73,18 @@ -> FilePath -> IO [Line LBS.ByteString] grepLines rex fp = grepFilter rex <$> LBS.readFile fp +\end{code} +\begin{code} -- | returns a 'Line' for each line in the argument text, enumerating -- all of the matches for that line grepFilter :: IsRegex re s => re -> s -> [Line s] grepFilter rex = grepWithScript [(rex,mk)] . linesR where mk i mtchs = Just $ Line i mtchs +\end{code} +\begin{code} -- | a GrepScript lists RE-action associations, with the first RE to match -- a line selecting the action to be executed on each line in the file type GrepScript re s t = [(re,LineNo -> Matches s -> Maybe t)] @@ -99,4 +117,11 @@ f = case v of LinesMatched -> id LinesNotMatched -> not +\end{code} + +\begin{code} +-- $tutorial +-- The Grep toolkit matches REs againt each line of a text. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code} diff --git a/Text/RE/Tools/IsRegex.hs b/Text/RE/Tools/IsRegex.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Tools/IsRegex.hs @@ -0,0 +1,17 @@ +module Text.RE.Tools.IsRegex + ( + -- * IsRegex + -- $tutorial + IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst + ) where + +import Text.RE.ZeInternals.Types.IsRegex + +-- $tutorial +-- The @IsRegex@ class abstracts over each regex back end and the +-- text types they support allowing general regex tools to constructed. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk diff --git a/Text/RE/Tools/Lex.hs b/Text/RE/Tools/Lex.hs --- a/Text/RE/Tools/Lex.hs +++ b/Text/RE/Tools/Lex.hs @@ -1,11 +1,24 @@ module Text.RE.Tools.Lex - ( alex + ( + -- * Find + -- $tutorial + alex , alex' -- * IsRegex , IsRegex(..) - -- * Text.RE - , module Text.RE + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst + -- * Replace + , module Text.RE.Replace ) where -import Text.RE +import Text.RE.Replace +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.Tools.Lex + +-- $tutorial +-- The Lex toolkit uses REs to identify tokens in a file, returning a +-- list of tokens. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk diff --git a/Text/RE/Tools/Sed.lhs b/Text/RE/Tools/Sed.lhs --- a/Text/RE/Tools/Sed.lhs +++ b/Text/RE/Tools/Sed.lhs @@ -8,10 +8,11 @@ #endif module Text.RE.Tools.Sed - ( sed + ( + -- * Sed + -- $tutorial + sed , sed' - -- * IsRegex - , IsRegex(..) -- * Edit , Edits(..) , Edit(..) @@ -19,22 +20,28 @@ , applyEdits , applyEdit , applyLineEdit + -- * IsRegex + , IsRegex(..) + , SearchReplace(..) + , searchReplaceAll + , searchReplaceFirst -- * LineNo , LineNo(..) , firstLine , getLineNo , lineNo - -- * Text.RE - , module Text.RE + -- * Replace + , module Text.RE.Replace ) where import qualified Data.ByteString.Lazy.Char8 as LBS import Prelude.Compat -import Text.RE import Text.RE.Replace import Text.RE.Tools.Edit +\end{code} +\begin{code} -- | read a file, apply an 'Edits' script to each line it and -- write the file out again; "-" is used to indicate standard input -- standard output as appropriate @@ -43,25 +50,31 @@ -> FilePath -> FilePath -> IO () -sed as i_fp o_fp = do +sed escr i_fp o_fp = do lns <- LBS.lines <$> read_file i_fp lns' <- sequence - [ applyEdits lno as s + [ applyEdits lno escr s | (lno,s)<-zip [firstLine..] lns ] write_file o_fp $ LBS.concat lns' +\end{code} + +\begin{code} -- | apply an 'Edits' script to each line of the argument text sed' :: (IsRegex re a,Monad m,Functor m) => Edits m re a -> a -> m a -sed' as t = do +sed' escr t = do mconcat <$> sequence - [ applyEdits lno as s + [ applyEdits lno escr s | (lno,s)<-zip [firstLine..] $ linesR t ] +\end{code} + +\begin{code} read_file :: FilePath -> IO LBS.ByteString read_file "-" = LBS.getContents read_file fp = LBS.readFile fp @@ -69,4 +82,14 @@ write_file :: FilePath -> LBS.ByteString ->IO () write_file "-" = LBS.putStr write_file fp = LBS.writeFile fp +\end{code} + + +\begin{code} +-- $tutorial +-- The Sed toolkit applyies @Edits@ scripts to each line +-- of a text, running the actions and adjusting each line +-- accordingly. +-- +-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code} diff --git a/Text/RE/ZeInternals.hs b/Text/RE/ZeInternals.hs --- a/Text/RE/ZeInternals.hs +++ b/Text/RE/ZeInternals.hs @@ -2,14 +2,57 @@ ( -- * The regex Internal Modules -- $internals + + -- * Text.RE.ZeInternals.AddCaptureNames + addCaptureNames + , addCaptureNamesToMatches + , addCaptureNamesToMatch + -- * Text.RE.ZeInternals.EscapeREString + , escapeREString + -- * Text.RE.ZeInternals.NamedCaptures + , cp + , extractNamedCaptures + , idFormatTokenREOptions + , Token + , validToken + , formatTokens + , formatTokens' + , formatTokens0 + , scan + -- * Text.RE.ZeInternals.Replace + , expandMacros + -- * Text.RE.ZeInternals.PreludeMacros + , PreludeMacro(..) + , presentPreludeMacro + , preludeMacros + , preludeMacroTable + , preludeMacroSummary + , preludeMacroSources + , preludeMacroSource + , preludeMacroEnv + -- * Text.RE.ZeInternals.SearchReplace + , unsafeCompileSearchReplace_ + , compileSearchReplace_ + , compileSearchAndReplace_ + -- * Text.RE.ZeInternals.QQ + , QQFailure(..) + , qq0 + -- * Text.RE.ZeInternals.TestBench + , mkTDFA + , mkPCRE + , badMacros ) where +import Text.RE.ZeInternals.AddCaptureNames +import Text.RE.ZeInternals.EscapeREString +import Text.RE.ZeInternals.NamedCaptures +import Text.RE.ZeInternals.PreludeMacros +import Text.RE.ZeInternals.QQ +import Text.RE.ZeInternals.Replace +import Text.RE.ZeInternals.SearchReplace +import Text.RE.ZeInternals.TestBench + -- $internals --- The modules under 'ZeInternals' do not belong to the /official/ regex --- API, though their contents will so belong if they are listed in the outside --- `Text.RE` modules. This doesn't mean that they cannot be used but be aware --- that they may not be as stable or as well documented as the official API --- modules. --- --- If you do notice anything in here that you think we have missed that --- should be listed in the official API then please drop us a line. +-- This module contains just what the test suite (re-tests) in regex-examples +-- needs from the package internals to do its job and the ZeInternals +-- types and functions needed by the regex-with-pcre package diff --git a/Text/RE/ZeInternals/NamedCaptures.lhs b/Text/RE/ZeInternals/NamedCaptures.lhs --- a/Text/RE/ZeInternals/NamedCaptures.lhs +++ b/Text/RE/ZeInternals/NamedCaptures.lhs @@ -36,7 +36,9 @@ import Text.Regex.TDFA --- | quasi quoter for CaptureID ([cp|0|],[cp|y|], etc.) +-- | quasi quoter for CaptureID: @[cp|0|]@, @[cp|0|]@, etc., +-- indexing captures by classic positional numbers, and @[cp|foo|]@, +-- etc., referencing a named capture @[re| ... ${foo}( ... ) ... |]@. cp :: QuasiQuoter cp = (qq0 "cp") @@ -115,7 +117,7 @@ \begin{code} -- | scan a RE string into a list of RE Token scan :: String -> [Token] -scan = alex' match al oops +scan = alex' match al $ oops "top" where al :: [(Regex,Match String->Maybe Token)] al = @@ -131,11 +133,11 @@ x_1 = captureText $ IsCaptureOrdinal $ CaptureOrdinal 1 s2c [c] = c - s2c _ = error "scan:s2c:internal error" + s2c _ = oops "s2c" mk s f = (either error id $ makeRegexM s,Just . f) - oops = error "reScanner" + oops m = error $ "NamedCaptures.scan: " ++ m \end{code} diff --git a/Text/RE/ZeInternals/PreludeMacros.hs b/Text/RE/ZeInternals/PreludeMacros.hs --- a/Text/RE/ZeInternals/PreludeMacros.hs +++ b/Text/RE/ZeInternals/PreludeMacros.hs @@ -242,7 +242,7 @@ , macroCounterSamples = counter_samples , macroTestResults = [] , macroParser = Just "parseInteger" - , macroDescription = "a decimal integer" + , macroDescription = "a decimal natural number" } where samples :: [(String,Double)] @@ -315,7 +315,7 @@ , macroCounterSamples = counter_samples , macroTestResults = [] , macroParser = Just "parseSimpleString" - , macroDescription = "a decimal integer" + , macroDescription = "a simple quoted string" } where samples :: [(String,String)] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE B.ByteString|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE B.ByteString|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE B.ByteString|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString/Lazy.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString/Lazy.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString/Lazy.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/ByteString/Lazy.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE LBS.ByteString|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE LBS.ByteString|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE LBS.ByteString|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/Sequence.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/Sequence.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/Sequence.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/Sequence.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.Sequence - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE (S.Seq Char)|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE (S.Seq Char)|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE (S.Seq Char)|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/String.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/String.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/String.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/String.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.String - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE String|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE String|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE String|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/Text.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/Text.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/Text.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/Text.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.Text - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE T.Text|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE T.Text|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE T.Text|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFA/Text/Lazy.hs b/Text/RE/ZeInternals/SearchReplace/TDFA/Text/Lazy.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFA/Text/Lazy.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFA/Text/Lazy.hs @@ -7,17 +7,15 @@ #endif module Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy - ( -- * The ed Quasi Quoters - -- $qq - ed - , edMS - , edMI - , edBS - , edBI + ( ed , edMultilineSensitive , edMultilineInsensitive , edBlockSensitive , edBlockInsensitive + , edMS + , edMI + , edBS + , edBI , ed_ ) where @@ -25,47 +23,61 @@ import Language.Haskell.TH import Language.Haskell.TH.Quote import Text.RE.REOptions +import Text.RE.Tools.IsRegex import Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@, +-- compiling a case-sensitive, multi-line 'SearchReplace' +ed :: QuasiQuoter +ed = ed' sr_cast $ Just minBound -ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter +-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template +edMultilineSensitive :: QuasiQuoter +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -ed = ed' sr_cast $ Just minBound +-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template +edMultilineInsensitive :: QuasiQuoter +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive + +-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template +edBlockSensitive :: QuasiQuoter +edBlockSensitive = ed' sr_cast $ Just BlockSensitive + +-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template +edBlockInsensitive :: QuasiQuoter +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@ +edMS :: QuasiQuoter edMS = edMultilineSensitive + +-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@ +edMI :: QuasiQuoter edMI = edMultilineInsensitive + +-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@ +edBS :: QuasiQuoter edBS = edBlockSensitive + +-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@ +edBI :: QuasiQuoter edBI = edBlockInsensitive -edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive -edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive -edBlockSensitive = ed' sr_cast $ Just BlockSensitive -edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive + +-- | @[ed_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that +-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- 'SearchReplace' template compiled with those options. For example, +-- +-- @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@ +-- +-- prefixes the hexadecimal digit strings in s with @0x@, allowing for +-- upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@). +ed_ :: QuasiQuoter ed_ = ed' fn_cast Nothing sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE TL.Text|] fn_cast :: Q Exp -fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE TL.Text|] - --- $qq --- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple, --- --- @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@ --- --- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date --- into a DD\/MM\/YYYY format date. --- --- The only difference betweem these quasi quoters is the RE options that are set: --- see the "Text.RE.REOptions" documentation for details. --- +fn_cast = [|\f x -> f x :: SearchReplace RE TL.Text|] diff --git a/Text/RE/ZeInternals/SearchReplace/TDFAEdPrime.hs b/Text/RE/ZeInternals/SearchReplace/TDFAEdPrime.hs --- a/Text/RE/ZeInternals/SearchReplace/TDFAEdPrime.hs +++ b/Text/RE/ZeInternals/SearchReplace/TDFAEdPrime.hs @@ -18,10 +18,9 @@ import Prelude.Compat import Text.RE.REOptions import Text.RE.Replace -import Text.RE.ZeInternals.QQ -import Text.RE.ZeInternals.SearchReplace +import Text.RE.Tools.IsRegex +import Text.RE.ZeInternals import Text.RE.ZeInternals.TDFA -import Text.RE.ZeInternals.Types.IsRegex -- | construct a quasi quoter from a casting function and @Just sro@ diff --git a/Text/RE/ZeInternals/TDFA.hs b/Text/RE/ZeInternals/TDFA.hs --- a/Text/RE/ZeInternals/TDFA.hs +++ b/Text/RE/ZeInternals/TDFA.hs @@ -30,6 +30,7 @@ , REOptions , defaultREOptions , noPreludeREOptions + , unpackSimpleREOptions -- * Compiling Regular Expressions , compileRegex , compileRegexWith @@ -37,7 +38,7 @@ -- * Compiling Search-Replace Templates , compileSearchReplace , compileSearchReplaceWith - , compileSearchReplaceWithREOptions + , compileSearchReplaceWithOptions -- * Escaping String , escape , escapeWith @@ -51,7 +52,6 @@ , preludeSummary , preludeSources , preludeSource - , unpackSimpleREOptions -- * The Quasi Quoters , re , reMS @@ -71,15 +71,10 @@ import Language.Haskell.TH.Quote import Prelude.Compat import Text.RE.REOptions -import Text.RE.ZeInternals.EscapeREString -import Text.RE.ZeInternals.NamedCaptures -import Text.RE.ZeInternals.PreludeMacros -import Text.RE.ZeInternals.QQ -import Text.RE.ZeInternals.Replace -import Text.RE.ZeInternals.SearchReplace -import Text.RE.ZeInternals.TestBench -import Text.RE.ZeInternals.Types.CaptureID -import Text.RE.ZeInternals.Types.IsRegex +import Text.RE.Replace +import Text.RE.TestBench +import Text.RE.Tools +import Text.RE.ZeInternals import Text.Regex.TDFA @@ -95,7 +90,7 @@ -- | some functions in the "Text.RE.TestBench" need the back end to -- be passed dynamically as a 'RegexType' parameters: use 'regexType' --- fpr this backend +-- for this regexType :: RegexType regexType = mkTDFA $ \txt env md -> txt =~ mdRegexSource regexType ExclCaptures env md @@ -227,12 +222,12 @@ -- | compile a SearchReplace template, with general options, generating -- errors if the RE or the template are not well formed, all capture -- references being checked -compileSearchReplaceWithREOptions :: (Monad m,Functor m,IsRegex RE s) - => REOptions - -> String - -> String - -> m (SearchReplace RE s) -compileSearchReplaceWithREOptions os = compileSearchAndReplace_ packR $ compileRegexWithOptions os +compileSearchReplaceWithOptions :: (Monad m,Functor m,IsRegex RE s) + => REOptions + -> String + -> String + -> m (SearchReplace RE s) +compileSearchReplaceWithOptions os = compileSearchAndReplace_ packR $ compileRegexWithOptions os ------------------------------------------------------------------------ @@ -312,37 +307,53 @@ -- Quasi Quoters ------------------------------------------------------------------------ --- | the @[re| ... |]@ and @[ed| ... /// ... |]@ quasi quoters -re - , reMS - , reMI - , reBS - , reBI - , reMultilineSensitive - , reMultilineInsensitive - , reBlockSensitive - , reBlockInsensitive - , re_ :: QuasiQuoter - -- , ed - -- , edMS - -- , edMI - -- , edBS - -- , edBI - -- , edMultilineSensitive - -- , edMultilineInsensitive - -- , edBlockSensitive - -- , edBlockInsensitive - -- , ed_ :: QuasiQuoter - +-- | @[re| ... |]@, is equivalent to @[reMultilineSensitive| ... |]@, +-- compiling a case-sensitive, multi-line RE +re :: QuasiQuoter re = re' $ Just minBound -reMS = reMultilineSensitive -reMI = reMultilineInsensitive -reBS = reBlockSensitive -reBI = reBlockInsensitive + +-- | @[reMultilineSensitive| ... |]@, compiles a case-sensitive, multi-line RE +reMultilineSensitive :: QuasiQuoter reMultilineSensitive = re' $ Just MultilineSensitive + +-- | @[reMultilineInsensitive| ... |]@, compiles a case-insensitive, multi-line RE +reMultilineInsensitive :: QuasiQuoter reMultilineInsensitive = re' $ Just MultilineInsensitive + +-- | @[reMultilineInsensitive| ... |]@, compiles a case-sensitive, non-multi-line RE +reBlockSensitive :: QuasiQuoter reBlockSensitive = re' $ Just BlockSensitive + +-- | @[reMultilineInsensitive| ... |]@, compiles a case-insensitive, non-multi-line RE +reBlockInsensitive :: QuasiQuoter reBlockInsensitive = re' $ Just BlockInsensitive + +-- | @[reMS| ... |]@ is a shorthand for @[reMultilineSensitive| ... |]@ +reMS :: QuasiQuoter +reMS = reMultilineSensitive + +-- | @[reMI| ... |]@ is a shorthand for @[reMultilineInsensitive| ... |]@ +reMI :: QuasiQuoter +reMI = reMultilineInsensitive + +-- | @[reBS| ... |]@ is a shorthand for @[reBlockSensitive| ... |]@ +reBS :: QuasiQuoter +reBS = reBlockSensitive + +-- | @[reBI| ... |]@ is a shorthand for @[reBlockInsensitive| ... |]@ +reBI :: QuasiQuoter +reBI = reBlockInsensitive + +-- | @[re_| ... |]@ compiles a RE to produce a function that takes +-- the RE options (e.g., a 'SimpleREOptions' value) and yields the +-- RE compiled with those options. For example, +-- +-- @countMatches $ s *=~ [re_|[0-9a-f]+|] MultilineInsensitive@ +-- +-- counts the number of hexadecimal digit strings in 's', allowing +-- for upper- or lower-case hex didgits (which is entirely equivalent +-- in this example to just using @[reMultilineInsensitive|[0-9a-f]+|]@). +re_ :: QuasiQuoter re_ = re' Nothing diff --git a/Text/RE/ZeInternals/Tools/Lex.lhs b/Text/RE/ZeInternals/Tools/Lex.lhs --- a/Text/RE/ZeInternals/Tools/Lex.lhs +++ b/Text/RE/ZeInternals/Tools/Lex.lhs @@ -9,8 +9,10 @@ import Prelude.Compat import Text.RE.Replace import Text.RE.ZeInternals.Types.IsRegex +\end{code} +\begin{code} -- | a simple regex-based scanner interpretter for prototyping -- scanners alex :: IsRegex re s => [(re,Match s->Maybe t)] -> t -> s -> [t] diff --git a/Text/RE/ZeInternals/Types/CaptureID.hs b/Text/RE/ZeInternals/Types/CaptureID.hs --- a/Text/RE/ZeInternals/Types/CaptureID.hs +++ b/Text/RE/ZeInternals/Types/CaptureID.hs @@ -37,14 +37,10 @@ deriving (Show,Ord,Eq,Enum,Ix,Num) -- | look up a 'CaptureID' in the 'CaptureNames' dictionary -unsafeFindCaptureID :: CaptureID -> CaptureNames -> Int -unsafeFindCaptureID cid = either error id . findCaptureID cid - --- | look up a 'CaptureID' in the 'CaptureNames' dictionary -findCaptureID :: CaptureID -> CaptureNames -> Either String Int -findCaptureID (IsCaptureOrdinal o) _ = Right $ getCaptureOrdinal o +findCaptureID :: CaptureID -> CaptureNames -> Either String CaptureOrdinal +findCaptureID (IsCaptureOrdinal o) _ = Right o findCaptureID (IsCaptureName n) hms = - maybe oops (Right . getCaptureOrdinal) $ HMS.lookup n hms + maybe oops Right $ HMS.lookup n hms where oops = Left $ unlines $ ("lookupCaptureID: " ++ T.unpack t ++ " not found in:") : diff --git a/Text/RE/ZeInternals/Types/IsRegex.lhs b/Text/RE/ZeInternals/Types/IsRegex.lhs --- a/Text/RE/ZeInternals/Types/IsRegex.lhs +++ b/Text/RE/ZeInternals/Types/IsRegex.lhs @@ -47,7 +47,9 @@ makeSearchReplace = makeSearchReplaceWith minBound makeEscaped = makeEscapedWith minBound makeEscapedWith o f = makeRegexWith o . f . packR . escapeREString . unpackR +\end{code} +\begin{code} -- | search and replace all matches in the argument text; e.g., this function -- will convert every YYYY-MM-DD format date in its argument text into a -- DD\/MM\/YYYY date: diff --git a/Text/RE/ZeInternals/Types/Match.lhs b/Text/RE/ZeInternals/Types/Match.lhs --- a/Text/RE/ZeInternals/Types/Match.lhs +++ b/Text/RE/ZeInternals/Types/Match.lhs @@ -39,10 +39,8 @@ \end{code} \begin{code} --- | the result of matching a RE to a text once, listing the text that --- was matched and the named captures in the RE and all of the substrings --- matched, with the text captured by the whole RE; a complete failure --- to match will be represented with an empty array (with bounds (0,-1)) +-- | the result of matching a RE to a text once (with @?=~@), retaining +-- the text that was matched against data Match a = Match { matchSource :: !a -- ^ the whole source text @@ -81,7 +79,7 @@ matched :: Match a -> Bool matched = isJust . matchCapture --- | tests whether the RE matched the source text at all +-- | yields the text matched by the RE, Nothing if no match matchedText :: Match a -> Maybe a matchedText = fmap capturedText . matchCapture @@ -90,8 +88,8 @@ matchCapture :: Match a -> Maybe (Capture a) matchCapture = fmap fst . matchCaptures --- | the top-level capture and the sub captures if the text matched --- the RE, Nothing otherwise +-- | the main top-level capture (capture \'0'') and the sub captures +-- if the text matched the RE, @Nothing@ otherwise matchCaptures :: Match a -> Maybe (Capture a,[Capture a]) matchCaptures Match{..} = case rangeSize (bounds matchArray) == 0 of True -> Nothing @@ -143,14 +141,14 @@ captureMaybe :: CaptureID -> Match a -> Maybe (Capture a) captureMaybe cid mtch@Match{..} = do i <- lookupCaptureID cid mtch - cap <- case bounds matchArray `inRange` CaptureOrdinal i of - True -> Just $ matchArray ! CaptureOrdinal i + cap <- case bounds matchArray `inRange` i of + True -> Just $ matchArray ! i False -> Nothing case hasCaptured cap of True -> Just cap False -> Nothing -lookupCaptureID :: CaptureID -> Match a -> Maybe Int +lookupCaptureID :: CaptureID -> Match a -> Maybe CaptureOrdinal lookupCaptureID cid Match{..} = either (const Nothing) Just $ findCaptureID cid captureNames \end{code} diff --git a/Text/RE/ZeInternals/Types/Matches.lhs b/Text/RE/ZeInternals/Types/Matches.lhs --- a/Text/RE/ZeInternals/Types/Matches.lhs +++ b/Text/RE/ZeInternals/Types/Matches.lhs @@ -26,8 +26,8 @@ \begin{code} --- | the result type to use when every match is needed, not just the --- first match of the RE against the source +-- | the result of matching a RE against a text (with @*=~@), retaining +-- the text that was matched against data Matches a = Matches { matchesSource :: !a -- ^ the source text being matched @@ -54,7 +54,7 @@ countMatches :: Matches a -> Int countMatches = length . allMatches --- | list the Matches +-- | list the texts that Matched matches :: Matches a -> [a] matches = map capturedText . mainCaptures diff --git a/Text/RE/ZeInternals/Types/SearchReplace.hs b/Text/RE/ZeInternals/Types/SearchReplace.hs deleted file mode 100644 --- a/Text/RE/ZeInternals/Types/SearchReplace.hs +++ /dev/null @@ -1,15 +0,0 @@ - -module Text.RE.ZeInternals.Types.SearchReplace - ( SearchReplace(..) - ) where - --- | contains a compiled RE and replacement template -data SearchReplace re s = - SearchReplace - { getSearch :: !re -- ^ the RE - , getTemplate :: !s -- ^ the replacement template - } - deriving (Show) - -instance Functor (SearchReplace re) where - fmap f (SearchReplace re x) = SearchReplace re (f x) diff --git a/Text/RE/ZeInternals/Types/SearchReplace.lhs b/Text/RE/ZeInternals/Types/SearchReplace.lhs new file mode 100644 --- /dev/null +++ b/Text/RE/ZeInternals/Types/SearchReplace.lhs @@ -0,0 +1,23 @@ +\begin{code} +module Text.RE.ZeInternals.Types.SearchReplace + ( SearchReplace(..) + ) where +\end{code} + +\begin{code} +-- | contains a compiled RE and replacement template +data SearchReplace re s = + SearchReplace + { getSearch :: !re -- ^ the RE to match a string to replace + , getTemplate :: !s -- ^ the replacement template with ${cap} + -- used to identify a capture (by number or + -- name if one was given) and '$$' being + -- used to escape a single '$' + } + deriving (Show) +\end{code} + +\begin{code} +instance Functor (SearchReplace re) where + fmap f (SearchReplace re x) = SearchReplace re (f x) +\end{code} diff --git a/changelog b/changelog --- a/changelog +++ b/changelog @@ -1,5 +1,17 @@ -*-change-log-*- +1.0.0.0 Chris Dornan 2017-04-10 + * Rewrite tutorials (#113) + * Add Text.RE.Tools.IsRegex (#122) + * Include Macro Parsers in Core API (#123) + * Adjust type of lookupCaptureID and friends (#124) + * re-prep to handle cast example expressions (#125) + * Rename compileSearchReplaceWithOptions (#126) + * Hide ZeInternals, Evacuate Text.RE (#127) + * Proper Haddocks for the quasi quoters (#128) + * ed_ quasi quoters are being restricted to SimpleREOptions (#129) + * regex dependeny on pcre-builtin (#130) + 0.14.0.0 Chris Dornan 2017-04-05 * Move IsOption into the back ends (#115) * Rename Find functions (#116) @@ -71,7 +83,7 @@ * Fix .travis.yml release-stack script (#67) 0.6.0.0 Chris Dornan 2017-03-13 - * Split out rexex-with-pcre package (#65) + * Split out regex-with-pcre package (#65) 0.5.0.0 Chris Dornan 2017-03-05 * Fix inter-operation of =~ & =~~ and named captures (#55) diff --git a/regex.cabal b/regex.cabal --- a/regex.cabal +++ b/regex.cabal @@ -1,5 +1,5 @@ Name: regex -Version: 0.14.0.0 +Version: 1.0.0.0 Synopsis: Toolkit for regex-base Description: A regular expression toolkit for regex-base with compile-time checking of RE syntax, data types for @@ -32,7 +32,7 @@ Source-Repository this Type: git Location: https://github.com/iconnect/regex.git - Tag: 0.14.0.0 + Tag: 1.0.0.0 @@ -51,13 +51,17 @@ Text.RE.TDFA.Text Text.RE.TDFA.Text.Lazy Text.RE.TestBench + Text.RE.TestBench.Parsers Text.RE.Tools Text.RE.Tools.Edit Text.RE.Tools.Find Text.RE.Tools.Grep + Text.RE.Tools.IsRegex Text.RE.Tools.Lex Text.RE.Tools.Sed Text.RE.ZeInternals + + Other-Modules: Text.RE.ZeInternals.AddCaptureNames Text.RE.ZeInternals.EscapeREString Text.RE.ZeInternals.NamedCaptures @@ -85,6 +89,7 @@ Text.RE.ZeInternals.Types.Matches Text.RE.ZeInternals.Types.SearchReplace + Default-Language: Haskell2010 Other-Extensions: @@ -125,7 +130,6 @@ , containers >= 0.4 , hashable >= 1.2.3.3 , regex-base >= 0.93.2 - , regex-pcre-builtin >= 0.94.4.8.8.35 , regex-tdfa >= 1.2.0 , regex-tdfa-text >= 1.0.0.3 , template-haskell >= 2.7