Added some shortcuts for commonly used flags (purescript#67)

* Added a monoid instance and helper functions to regex flags

* Refactored the regex flags code

Author: Risto-Stevcev

src/Data/String/Regex.js

@@ -25,7 +25,7 @@ exports.source = function (r) {
   return r.source;
 };
 
-exports.flags = function (r) {
+exports["flags'"] = function (r) {
   return {
     multiline: r.multiline,
     ignoreCase: r.ignoreCase,

src/Data/String/Regex.purs

@@ -3,7 +3,6 @@
 -- | For details of the underlying implementation, see [RegExp Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp).
 module Data.String.Regex
   ( Regex(..)
-  , RegexFlags(..)
   , regex
   , source
   , flags
@@ -15,14 +14,14 @@ module Data.String.Regex
   , replace'
   , search
   , split
-  , noFlags
   ) where
 
 import Prelude
 
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..))
 import Data.String (contains)
+import Data.String.Regex.Flags (RegexFlags(..), RegexFlagsRec)
 
 -- | Wraps Javascript `RegExp` objects.
 foreign import data Regex :: *
@@ -32,23 +31,6 @@ foreign import showRegex' :: Regex -> String
 instance showRegex :: Show Regex where
   show = showRegex'
 
--- | Flags that control matching.
-type RegexFlags =
-  { global :: Boolean
-  , ignoreCase :: Boolean
-  , multiline :: Boolean
-  , sticky :: Boolean
-  , unicode :: Boolean
-  }
-
--- | All flags set to false.
-noFlags :: RegexFlags
-noFlags = { global     : false
-          , ignoreCase : false
-          , multiline  : false
-          , sticky     : false
-          , unicode    : false }
-
 foreign import regex' :: (String -> Either String Regex)
                       -> (Regex -> Either String Regex)
                       -> String
@@ -64,11 +46,15 @@ regex s f = regex' Left Right s $ renderFlags f
 foreign import source :: Regex -> String
 
 -- | Returns the `RegexFlags` used to construct the given `Regex`.
-foreign import flags :: Regex -> RegexFlags
+flags :: Regex -> RegexFlags
+flags = RegexFlags <<< flags'
+
+-- | Returns the `RegexFlags` inner record used to construct the given `Regex`.
+foreign import flags' :: Regex -> RegexFlagsRec
 
 -- | Returns the string representation of the given `RegexFlags`.
 renderFlags :: RegexFlags -> String
-renderFlags f =
+renderFlags (RegexFlags f) =
   (if f.global then "g" else "") <>
   (if f.ignoreCase then "i" else "") <>
   (if f.multiline then "m" else "") <>
@@ -77,7 +63,7 @@ renderFlags f =
 
 -- | Parses the string representation of `RegexFlags`.
 parseFlags :: String -> RegexFlags
-parseFlags s =
+parseFlags s = RegexFlags
   { global: contains "g" s
   , ignoreCase: contains "i" s
   , multiline: contains "m" s

src/Data/String/Regex/Flags.purs

@@ -0,0 +1,87 @@
+module Data.String.Regex.Flags where
+
+import Prelude (class Semigroup, (||))
+import Data.Monoid (class Monoid)
+
+type RegexFlagsRec =
+  { global :: Boolean
+  , ignoreCase :: Boolean
+  , multiline :: Boolean
+  , sticky :: Boolean
+  , unicode :: Boolean
+  }
+
+-- | Flags that control matching.
+data RegexFlags = RegexFlags RegexFlagsRec
+
+-- | All flags set to false.
+noFlags :: RegexFlags
+noFlags = RegexFlags
+  { global: false
+  , ignoreCase: false
+  , multiline: false
+  , sticky: false
+  , unicode: false
+  }
+
+-- | Only global flag set to true
+global :: RegexFlags
+global = RegexFlags
+  { global: true
+  , ignoreCase: false
+  , multiline: false
+  , sticky: false
+  , unicode: false
+  }
+
+-- | Only ignoreCase flag set to true
+ignoreCase :: RegexFlags
+ignoreCase = RegexFlags
+  { global: false
+  , ignoreCase: true
+  , multiline: false
+  , sticky: false
+  , unicode: false
+  }
+
+-- | Only multiline flag set to true
+multiline :: RegexFlags
+multiline = RegexFlags
+  { global: false
+  , ignoreCase: false
+  , multiline: true
+  , sticky: false
+  , unicode: false
+  }
+
+-- | Only sticky flag set to true
+sticky :: RegexFlags
+sticky = RegexFlags
+  { global: false
+  , ignoreCase: false
+  , multiline: false
+  , sticky: true
+  , unicode: false
+  }
+
+-- | Only unicode flag set to true
+unicode :: RegexFlags
+unicode = RegexFlags
+  { global: false
+  , ignoreCase: false
+  , multiline: false
+  , sticky: false
+  , unicode: true
+  }
+
+instance semigroupRegexFlags :: Semigroup RegexFlags where
+  append (RegexFlags x) (RegexFlags y) = RegexFlags
+    { global: x.global || y.global
+    , ignoreCase: x.ignoreCase || y.ignoreCase
+    , multiline: x.multiline || y.multiline
+    , sticky: x.sticky || y.sticky
+    , unicode: x.unicode || y.unicode
+    }
+
+instance monoidRegexFlags :: Monoid RegexFlags where
+  mempty = noFlags

test/Test/Data/String/Regex.purs

@@ -1,13 +1,14 @@
 module Test.Data.String.Regex (testStringRegex) where
 
-import Prelude (Unit, ($), bind, (==), not)
+import Prelude (Unit, ($), (<>), bind, (==), not)
 
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, log)
 
 import Data.Either (isLeft, fromRight)
 import Data.Maybe (Maybe(..))
 import Data.String.Regex
+import Data.String.Regex.Flags (RegexFlags, global, ignoreCase, noFlags)
 
 import Partial.Unsafe (unsafePartial)
 
@@ -24,6 +25,11 @@ testStringRegex = do
   assert $ not (test (regex' "^b" noFlags) "abc")
   assert $ isLeft (regex "+" noFlags)
 
+  log "flags"
+  assert $ "quxbarfoobaz" == replace (regex' "foo" noFlags) "qux" "foobarfoobaz"
+  assert $ "quxbarquxbaz" == replace (regex' "foo" global) "qux" "foobarfoobaz"
+  assert $ "quxbarquxbaz" == replace (regex' "foo" (global <> ignoreCase)) "qux" "foobarFOObaz"
+
   log "match"
   assert $ match (regex' "^abc$" noFlags) "abc" == Just [Just "abc"]