Text.RE.Tools.Edit

Editing

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

data Edits m re s

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

Constructors

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

data Edit m re s

each Edit action specifies how the match should be processed

Constructors

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

data LineEdit s

a LineEdit is the most general action thar can be performed on a line and is the only means of deleting a line

Constructors

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

Instances

Functor LineEdit

Defined in Text.RE.Tools.Edit

Methods

fmap :: (a -> b) -> LineEdit a -> LineEdit b

(<$) :: a -> LineEdit b -> LineEdit a

Show s => Show (LineEdit s)

Defined in Text.RE.Tools.Edit

Methods

showsPrec :: Int -> LineEdit s -> ShowS

show :: LineEdit s -> String

showList :: [LineEdit s] -> ShowS

applyEdits :: (IsRegex re s, Monad m, Functor m) => LineNo -> Edits m re s -> s -> m s

apply an Edit script to a single line

applyEdit :: (IsRegex re s, Monad m, Functor m) => (s -> s) -> LineNo -> Edit m re s -> s -> m (Maybe s)

apply a single edit action to a line, the function in the first argument being used to add a new line onto the end of the line where appropriate; the function returns Nothing if no edit is to be performed on the line, Just mempty to delete the line

applyLineEdit :: Monoid s => (s -> s) -> LineEdit s -> Maybe s

apply a LineEdit to a line, using the function in the first argument to append a new line to the result; Nothing should be returned if no edit is to be performed, Just mempty to delete the line

IsRegex

class Replace s => IsRegex re s where

the IsRegex class allows polymorhic tools to be written that will work with a variety of regex back ends and text types

Minimal complete definition

matchOnce, matchMany, makeRegexWith, makeSearchReplaceWith, regexSource

Methods

matchOnce :: re -> s -> Match s

finding the first match

matchMany :: re -> s -> Matches s

finding all matches

makeRegex :: (Functor m, Monad m, MonadFail m) => s -> m re

compiling an RE, failing if the RE is not well formed

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> s -> m re

comiling an RE, specifying the SimpleREOptions

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex re s) => s -> s -> m (SearchReplace re s)

compiling a SearchReplace template from the RE text and the template Text, failing if they are not well formed

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex re s) => SimpleREOptions -> s -> s -> m (SearchReplace re s)

compiling a SearchReplace template specifing the SimpleREOptions for the RE

makeEscaped :: (Functor m, Monad m, MonadFail m) => (s -> s) -> s -> m re

incorporate an escaped string into a compiled RE with the default options

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (s -> s) -> s -> m re

incorporate an escaped string into a compiled RE with the specified SimpleREOptions

regexSource :: re -> s

extract the text of the RE from the RE

Instances

IsRegex RE String

Defined in Text.RE.TDFA.String

Methods

matchOnce :: RE -> String -> Match String

matchMany :: RE -> String -> Matches String

makeRegex :: (Functor m, Monad m, MonadFail m) => String -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> String -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE String) => String -> String -> m (SearchReplace RE String)

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE String) => SimpleREOptions -> String -> String -> m (SearchReplace RE String)

makeEscaped :: (Functor m, Monad m, MonadFail m) => (String -> String) -> String -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (String -> String) -> String -> m RE

regexSource :: RE -> String

IsRegex RE ByteString

Defined in Text.RE.TDFA.ByteString.Lazy

Methods

matchOnce :: RE -> ByteString -> Match ByteString

matchMany :: RE -> ByteString -> Matches ByteString

makeRegex :: (Functor m, Monad m, MonadFail m) => ByteString -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> ByteString -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE ByteString) => ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE ByteString) => SimpleREOptions -> ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeEscaped :: (Functor m, Monad m, MonadFail m) => (ByteString -> ByteString) -> ByteString -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (ByteString -> ByteString) -> ByteString -> m RE

regexSource :: RE -> ByteString

IsRegex RE ByteString

Defined in Text.RE.TDFA.ByteString

Methods

matchOnce :: RE -> ByteString -> Match ByteString

matchMany :: RE -> ByteString -> Matches ByteString

makeRegex :: (Functor m, Monad m, MonadFail m) => ByteString -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> ByteString -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE ByteString) => ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE ByteString) => SimpleREOptions -> ByteString -> ByteString -> m (SearchReplace RE ByteString)

makeEscaped :: (Functor m, Monad m, MonadFail m) => (ByteString -> ByteString) -> ByteString -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (ByteString -> ByteString) -> ByteString -> m RE

regexSource :: RE -> ByteString

IsRegex RE Text

Defined in Text.RE.TDFA.Text.Lazy

Methods

matchOnce :: RE -> Text -> Match Text

matchMany :: RE -> Text -> Matches Text

makeRegex :: (Functor m, Monad m, MonadFail m) => Text -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> Text -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE Text) => Text -> Text -> m (SearchReplace RE Text)

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE Text) => SimpleREOptions -> Text -> Text -> m (SearchReplace RE Text)

makeEscaped :: (Functor m, Monad m, MonadFail m) => (Text -> Text) -> Text -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (Text -> Text) -> Text -> m RE

regexSource :: RE -> Text

IsRegex RE Text

Defined in Text.RE.TDFA.Text

Methods

matchOnce :: RE -> Text -> Match Text

matchMany :: RE -> Text -> Matches Text

makeRegex :: (Functor m, Monad m, MonadFail m) => Text -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> Text -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE Text) => Text -> Text -> m (SearchReplace RE Text)

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE Text) => SimpleREOptions -> Text -> Text -> m (SearchReplace RE Text)

makeEscaped :: (Functor m, Monad m, MonadFail m) => (Text -> Text) -> Text -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (Text -> Text) -> Text -> m RE

regexSource :: RE -> Text

IsRegex RE (Seq Char)

Defined in Text.RE.TDFA.Sequence

Methods

matchOnce :: RE -> Seq Char -> Match (Seq Char)

matchMany :: RE -> Seq Char -> Matches (Seq Char)

makeRegex :: (Functor m, Monad m, MonadFail m) => Seq Char -> m RE

makeRegexWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> Seq Char -> m RE

makeSearchReplace :: (Functor m, Monad m, MonadFail m, IsRegex RE (Seq Char)) => Seq Char -> Seq Char -> m (SearchReplace RE (Seq Char))

makeSearchReplaceWith :: (Functor m, Monad m, MonadFail m, IsRegex RE (Seq Char)) => SimpleREOptions -> Seq Char -> Seq Char -> m (SearchReplace RE (Seq Char))

makeEscaped :: (Functor m, Monad m, MonadFail m) => (Seq Char -> Seq Char) -> Seq Char -> m RE

makeEscapedWith :: (Functor m, Monad m, MonadFail m) => SimpleREOptions -> (Seq Char -> Seq Char) -> Seq Char -> m RE

regexSource :: RE -> Seq Char

data SearchReplace re s

contains a compiled RE and replacement template

Constructors

SearchReplace

Fields

• 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 $

Instances

Functor (SearchReplace re)

Defined in Text.RE.ZeInternals.Types.SearchReplace

Methods

fmap :: (a -> b) -> SearchReplace re a -> SearchReplace re b

(<$) :: a -> SearchReplace re b -> SearchReplace re a

(Show re, Show s) => Show (SearchReplace re s)

Defined in Text.RE.ZeInternals.Types.SearchReplace

Methods

showsPrec :: Int -> SearchReplace re s -> ShowS

show :: SearchReplace re s -> String

showList :: [SearchReplace re s] -> ShowS

searchReplaceAll :: IsRegex re s => SearchReplace re s -> s -> s

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:

searchReplaceAll [ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})///${d}/${m}/${y}|]

searchReplaceFirst :: IsRegex re s => SearchReplace re s -> s -> s

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, if any, with 0x:

searchReplaceFirst [ed|[0-9A-Fa-f]{4}///0x$0|]

LineNo

newtype LineNo

our line numbers are of the proper zero-based kind

Constructors

ZeroBasedLineNo

Fields

• getZeroBasedLineNo :: Int

Instances

Enum LineNo

Defined in Text.RE.ZeInternals.Types.LineNo

Methods

succ :: LineNo -> LineNo

pred :: LineNo -> LineNo

toEnum :: Int -> LineNo

fromEnum :: LineNo -> Int

enumFrom :: LineNo -> [LineNo]

enumFromThen :: LineNo -> LineNo -> [LineNo]

enumFromTo :: LineNo -> LineNo -> [LineNo]

enumFromThenTo :: LineNo -> LineNo -> LineNo -> [LineNo]

Show LineNo

Defined in Text.RE.ZeInternals.Types.LineNo

Methods

showsPrec :: Int -> LineNo -> ShowS

show :: LineNo -> String

showList :: [LineNo] -> ShowS

firstLine :: LineNo

the first line in a file

getLineNo :: LineNo -> Int

extract a conventional 1-based line number

lineNo :: Int -> LineNo

inject a conventional 1-based line number

Replace

module Text.RE.Replace