{-# LANGUAGE FlexibleContexts #-}
module ShellCheck.Regex where
import Data.List
import Data.Maybe
import Control.Monad
import Text.Regex.TDFA
mkRegex :: String -> Regex
mkRegex :: [Char] -> Regex
mkRegex [Char]
str =
let make :: String -> Regex
make :: [Char] -> Regex
make = [Char] -> Regex
forall regex compOpt execOpt source.
RegexMaker regex compOpt execOpt source =>
source -> regex
makeRegex
in
[Char] -> Regex
make [Char]
str
matches :: String -> Regex -> Bool
matches :: [Char] -> Regex -> Bool
matches = (Regex -> [Char] -> Bool) -> [Char] -> Regex -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Regex -> [Char] -> Bool
forall regex source target.
RegexContext regex source target =>
regex -> source -> target
match
matchRegex :: Regex -> String -> Maybe [String]
matchRegex :: Regex -> [Char] -> Maybe [[Char]]
matchRegex Regex
re [Char]
str = do
(_, _, _, groups) <- Regex -> [Char] -> Maybe ([Char], [Char], [Char], [[Char]])
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
forall (m :: * -> *).
MonadFail m =>
Regex -> [Char] -> m ([Char], [Char], [Char], [[Char]])
matchM Regex
re [Char]
str :: Maybe (String,String,String,[String])
return groups
matchAllStrings :: Regex -> String -> [String]
matchAllStrings :: Regex -> [Char] -> [[Char]]
matchAllStrings Regex
re = ([Char] -> Maybe ([Char], [Char])) -> [Char] -> [[Char]]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr [Char] -> Maybe ([Char], [Char])
f
where
f :: String -> Maybe (String, String)
f :: [Char] -> Maybe ([Char], [Char])
f [Char]
str = do
(_, match, rest, _) <- Regex -> [Char] -> Maybe ([Char], [Char], [Char], [[Char]])
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
forall (m :: * -> *).
MonadFail m =>
Regex -> [Char] -> m ([Char], [Char], [Char], [[Char]])
matchM Regex
re [Char]
str :: Maybe (String, String, String, [String])
return (match, rest)
matchAllSubgroups :: Regex -> String -> [[String]]
matchAllSubgroups :: Regex -> [Char] -> [[[Char]]]
matchAllSubgroups Regex
re = ([Char] -> Maybe ([[Char]], [Char])) -> [Char] -> [[[Char]]]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr [Char] -> Maybe ([[Char]], [Char])
f
where
f :: String -> Maybe ([String], String)
f :: [Char] -> Maybe ([[Char]], [Char])
f [Char]
str = do
(_, _, rest, groups) <- Regex -> [Char] -> Maybe ([Char], [Char], [Char], [[Char]])
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
forall (m :: * -> *).
MonadFail m =>
Regex -> [Char] -> m ([Char], [Char], [Char], [[Char]])
matchM Regex
re [Char]
str :: Maybe (String, String, String, [String])
return (groups, rest)
subRegex :: Regex -> String -> String -> String
subRegex :: Regex -> [Char] -> [Char] -> [Char]
subRegex Regex
re [Char]
input [Char]
replacement = [Char] -> [Char]
f [Char]
input
where
f :: [Char] -> [Char]
f [Char]
str = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
str (Maybe [Char] -> [Char]) -> Maybe [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ do
(before, match, after) <- Regex -> [Char] -> Maybe ([Char], [Char], [Char])
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
forall (m :: * -> *).
MonadFail m =>
Regex -> [Char] -> m ([Char], [Char], [Char])
matchM Regex
re [Char]
str :: Maybe (String, String, String)
when (null match) $ error ("Internal error: substituted empty in " ++ str)
return $ before ++ replacement ++ f after
splitOn :: String -> Regex -> [String]
splitOn :: [Char] -> Regex -> [[Char]]
splitOn [Char]
input Regex
re =
case Regex -> [Char] -> Maybe ([Char], [Char], [Char])
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
forall (m :: * -> *).
MonadFail m =>
Regex -> [Char] -> m ([Char], [Char], [Char])
matchM Regex
re [Char]
input :: Maybe (String, String, String) of
Just ([Char]
before, [Char]
match, [Char]
after) -> [Char]
before [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [Char]
after [Char] -> Regex -> [[Char]]
`splitOn` Regex
re
Maybe ([Char], [Char], [Char])
Nothing -> [[Char]
input]