Refactor parser code and test code

src/LinkedIn/UIElements/Parser.purs

@@ -129,19 +129,28 @@ stringWithoutMedianDotP :: Parser String String
 stringWithoutMedianDotP = takeWhile (\c -> c /= codePointFromChar '·' && c /= codePointFromChar '•')
 
 uiStringP :: Parser String UIString
-uiStringP = (try dotSeparatedP') <|> singleUiStringP where
-  dotSeparatedP' = do
-    subStr <- stringWithoutMedianDotP
-    _ <- medianDotP
-    _ <- space
-    sub2Str <- rest
-    case runParser subStr singleUiStringP of
-      Right sub -> case runParser sub2Str singleUiStringP of
-        Right sub2 -> pure $ UIStringDotSeparated sub sub2
-        Left _ -> fail "not a sub"
+uiStringP = (try uiStringdotSeparatedP) <|> uiStringSingleP
+
+uiStringdotSeparatedP ∷ Parser String UIString
+uiStringdotSeparatedP = do
+  subStr <- stringWithoutMedianDotP
+  _ <- medianDotP
+  _ <- space
+  sub2Str <- rest
+  case runParser subStr uiStringSingleP of
+    Right sub -> case runParser sub2Str uiStringSingleP of
+      Right sub2 -> pure $ UIStringDotSeparated sub sub2
       Left _ -> fail "not a sub"
+    Left _ -> fail "not a sub"
+
+uiStringSingleP ∷ Parser String UIString
+uiStringSingleP = (try uiStringDurationP) <|> (try uiStringTimeSpanP) <|> uiStringPlainP
+
+uiStringDurationP ∷ Parser String UIString
+uiStringDurationP = UIStringDuration <$> durationP
+
+uiStringTimeSpanP ∷ Parser String UIString
+uiStringTimeSpanP = UIStringTimeSpan <$> timeSpanP
 
-  singleUiStringP = (try durationP') <|> (try timeSpanP') <|> plainP'
-  durationP' = UIStringDuration <$> durationP
-  timeSpanP' = UIStringTimeSpan <$> timeSpanP
-  plainP' = UIStringPlain <$> rest
+uiStringPlainP ∷ Parser String UIString
+uiStringPlainP = UIStringPlain <$> rest

test/UIStringParser.purs

@@ -6,89 +6,87 @@ module Test.UIStringParser
 import Data.Date (Month(..))
 import Data.Either (Either(..))
 import Effect (Effect)
-import LinkedIn.UIElements.Parser (durationP, monthYearP, timeSpanP, uiStringP)
-import LinkedIn.UIElements.Types (Duration(..), MonthYear, TimeSpan(..), UIString(..))
-import Parsing (runParser, ParseError)
+import LinkedIn.UIElements.Parser (durationP, monthYearP, timeSpanP, uiStringDurationP, uiStringdotSeparatedP)
+import LinkedIn.UIElements.Types (Duration(..), TimeSpan(..), UIString(..))
+import Parsing (runParser)
 import Prelude (Unit, discard)
 import Test.Assert (assertEqual)
 import Test.Utils (toMonthYear')
 
-runMonthYear ∷ String → Either ParseError MonthYear
-runMonthYear s = runParser s monthYearP
-
-runTimeSpan ∷ String → Either ParseError TimeSpan
-runTimeSpan s = runParser s timeSpanP
-
-runDuration ∷ String → Either ParseError Duration
-runDuration s = runParser s durationP
-
-runUIString ∷ String → Either ParseError UIString
-runUIString s = runParser s uiStringP
-
 testMonthYearParser ∷ Effect Unit
 testMonthYearParser = do 
   assertEqual {
-    actual:  runMonthYear "fév. 2004",
+    actual:  run "fév. 2004",
     expected: Right(toMonthYear' February 2004)
   }
   assertEqual {
-    actual:  runMonthYear "juin 2012",
+    actual:  run "juin 2012",
     expected: Right(toMonthYear' June 2012)
   }
 
+  where run s = runParser s monthYearP
+
 testTimeSpanParser ∷ Effect Unit
 testTimeSpanParser = do 
   assertEqual {
-    actual:  runTimeSpan "juin 2012 - aujourd’hui",
+    actual:  run "juin 2012 - aujourd’hui",
     expected: Right(TimeSpanToToday (toMonthYear' June 2012))
   }
   assertEqual {
-    actual:  runTimeSpan "juin 2012 - mai 2021",
+    actual:  run "juin 2012 - mai 2021",
     expected: Right(TimeSpanBounded (toMonthYear' June 2012) (toMonthYear' May 2021))
   }
 
+  where run s = runParser s timeSpanP
+
 testDurationParser ∷ Effect Unit
 testDurationParser = do 
   assertEqual {
-    actual: runDuration "2 ans 3 mois",
+    actual: run "2 ans 3 mois",
     expected: Right(YearsMonth 2 3)
   }
   assertEqual {
-    actual: runDuration "1 an 3 mois",
+    actual: run "1 an 3 mois",
     expected: Right(YearsMonth 1 3)
   }
   assertEqual {
-    actual: runDuration "3 mois",
+    actual: run "3 mois",
     expected: Right(Months 3)
   }
   assertEqual {
-    actual: runDuration "3 ans",
+    actual: run "3 ans",
     expected: Right(Years 3)
   }
   assertEqual {
-    actual: runDuration "1 an",
+    actual: run "1 an",
     expected: Right(Years 1)
   }
 
+  where run s = runParser s durationP
+
 testUIParserDuration ∷ Effect Unit
 testUIParserDuration = do
   assertEqual {
-    actual: runUIString "2 ans 3 mois",
+    actual: run "2 ans 3 mois",
     expected: Right(UIStringDuration (YearsMonth 2 3))
   }
 
+  where run s = runParser s uiStringDurationP
+
 testUIParserDotSeparated ∷ Effect Unit
 testUIParserDotSeparated = do
   assertEqual {
-    actual: runUIString "2 ans 3 mois · some text",
+    actual: run "2 ans 3 mois · some text",
     expected: Right(UIStringDotSeparated (UIStringDuration (YearsMonth 2 3)) (UIStringPlain "some text"))
   }
 
   assertEqual {
-    actual: runUIString "· Boulogne-Billancourt, Île-de-France, France",
+    actual: run "· Boulogne-Billancourt, Île-de-France, France",
     expected: Right(UIStringDotSeparated (UIStringPlain "") (UIStringPlain "Boulogne-Billancourt, Île-de-France, France"))
   }
 
+  where run s = runParser s uiStringdotSeparatedP
+
 main :: Effect Unit
 main = do
   testMonthYearParser