Merge pull request #8 from dgendill/master

hh, MM, and YY < 10 show leading zero

Author: garyb

.gitignore

@@ -4,3 +4,4 @@
 /output/
 /.psci*
 /src/.webpack.js
+.psc-ide-port

bower.json

@@ -7,17 +7,14 @@
     "output"
   ],
   "dependencies": {
-    "purescript-console": "^2.0.0",
-    "purescript-arrays": "^3.0.0",
-    "purescript-tuples": "^3.0.0",
-    "purescript-maybe": "^2.0.1",
-    "purescript-either": "^2.0.0",
+    "purescript-prelude": "^2.1.0",
     "purescript-parsing": "^3.0.0",
     "purescript-fixed-points": "^2.0.0",
-    "purescript-const": "^2.0.0",
     "purescript-datetime": "^2.0.0"
   },
   "devDependencies": {
+    "purescript-aff": "^2.0.2",
+    "purescript-console": "^2.0.0",
     "purescript-psci-support": "^2.0.0",
     "purescript-debug": "^2.0.0"
   }

src/Data/Formatter/DateTime.purs

@@ -9,12 +9,13 @@ module Data.Formatter.DateTime
   , unformatDateTime
   ) where
 
-import Prelude
-
-import Control.Lazy as Lazy
+import Prelude
+
+import Control.Lazy as Lazy
 import Control.Monad.State (State, runState, put, modify)
 import Control.Monad.Trans.Class (lift)
 
+import Data.Ord (abs)
 import Data.Array (some)
 import Data.Array as Arr
 import Data.Bifunctor (lmap)
@@ -31,13 +32,14 @@ import Data.String as Str
 import Data.Time as T
 import Data.Time.Duration as Dur
 import Data.Tuple (Tuple(..))
-
+import Data.Foldable (foldr)
 import Data.Formatter.Internal (digit, foldDigits)
 
 import Text.Parsing.Parser as P
 import Text.Parsing.Parser.Combinators as PC
 import Text.Parsing.Parser.String as PS
 
+
 data FormatterF a
   = YearFull a
   | YearTwoDigits a
@@ -109,6 +111,18 @@ parseFormatString ∷ String → Either String Formatter
 parseFormatString s =
   lmap P.parseErrorMessage $ P.runParser s formatParser
 
+-- | Formatting function that accepts a number that is a year,
+-- | and strips away the non-significant digits, leaving only the
+-- | ones and tens positions.
+formatYearTwoDigits :: Int -> String
+formatYearTwoDigits i = case dateLength of
+  1 -> "0" <> dateString
+  2 -> dateString
+  _ -> Str.drop (dateLength - 2) dateString
+  where
+    dateString = show $ abs i
+    dateLength = Str.length $ dateString
+
 
 placeholderContent ∷ P.Parser String String
 placeholderContent =
@@ -155,24 +169,18 @@ formatF
 formatF cb dt@(DT.DateTime d t) = case _ of
   YearFull a →
     (show $ fromEnum $ D.year d) <> cb a
-  YearTwoDigits a →
-    let
-      y = fromEnum $ D.year d
-      adjustedYear
-        | y > 2000 = y - 2000
-        | y > 1900 = y - 1900
-      -- A bit strange situation when user wants to format year from not 20th or 21st centuries as
-      -- two digits.
-        | otherwise = y
-    in show y <> cb a
+  YearTwoDigits a ->
+    let y = (fromEnum $ D.year d)
+    in (formatYearTwoDigits y) <> cb a
   YearAbsolute a →
     show (fromEnum $ D.year d) <> cb a
   MonthFull a →
     show (D.month d) <> cb a
   MonthShort a →
     printShortMonth (D.month d) <> cb a
   MonthTwoDigits a →
-    show (fromEnum $ D.month d) <> cb a
+    let month = fromEnum $ D.month d
+    in (padSingleDigit month) <> cb a
   DayOfMonth a →
     show (fromEnum $ D.day d) <> cb a
   UnixTimestamp a →
@@ -183,7 +191,7 @@ formatF cb dt@(DT.DateTime d t) = case _ of
     show (fromEnum $ T.hour t) <> cb a
   Hours12 a →
     let fix12 h = if h == 0 then 12 else h
-    in show (fix12 $ (fromEnum $ T.hour t) `mod` 12) <> cb a
+    in (padSingleDigit $ fix12 $ (fromEnum $ T.hour t) `mod` 12) <> cb a
   Meridiem a →
     (if (fromEnum $ T.hour t) >= 12 then "PM" else "AM") <> cb a
   Minutes a →
@@ -196,6 +204,10 @@ formatF cb dt@(DT.DateTime d t) = case _ of
     s <> cb a
   End → ""
 
+padSingleDigit :: Int -> String
+padSingleDigit i
+  | i < 10    = "0" <> (show i)
+  | otherwise = show i
 
 format ∷ Formatter → DT.DateTime → String
 format f dt = formatF (flip format dt) dt $ unroll f

test/src/Main.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.exit = function(int) {
+  process.exit(int);
+}

test/src/Main.purs

@@ -1,20 +1,42 @@
 module Test.Main where
 
 import Prelude
+import Control.Monad.Aff.Console as AffC
+import Data.Date as D
+import Data.DateTime as DTi
+import Data.Formatter.DateTime as FDT
+import Data.Formatter.Number as FN
+import Data.Time as T
+import Debug.Trace as DT
+import Control.Monad.Aff (Aff, Canceler, runAff)
+import Control.Monad.Aff.Class (liftAff)
 import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
-
+import Control.Monad.Eff.Console (CONSOLE)
+import Control.Monad.Eff.Exception (EXCEPTION, error)
+import Control.Monad.Error.Class (throwError)
+import Control.Monad.State (StateT, put, get, execStateT)
+import Data.DateTime (DateTime)
+import Data.Either (Either(..), either)
+import Data.Enum (toEnum)
 import Data.Functor.Mu (roll)
-import Data.Formatter.Number as FN
-import Data.Formatter.DateTime as FDT
 import Data.Maybe (fromMaybe)
-import Data.Either (Either(..))
-import Data.Enum (toEnum)
 
-import Data.DateTime as DTi
-import Data.Date as D
-import Data.Time as T
-import Debug.Trace as DT
+type Tests e a = StateT Boolean (Aff (exception :: EXCEPTION, console :: CONSOLE | e)) a
+
+
+execTests :: forall a e c.
+  StateT a (Aff ( process :: PROCESS | e)) c ->
+  a ->
+  Eff (process :: PROCESS | e) (Canceler ( process :: PROCESS | e ))
+execTests fn state = runAff (\s -> exit 1) (\s -> exit 0) (execStateT fn state)
+
+
+log :: forall e. String -> Tests e Unit
+log message = liftAff $ AffC.log message
+
+
+foreign import data PROCESS :: !
+foreign import exit :: Int -> forall e. Eff (process :: PROCESS | e) Unit
 
 
 fnOne ∷ FN.Formatter
@@ -36,6 +58,7 @@ fnTwo =
   , sign: true
   }
 
+
 fnThree ∷ FN.Formatter
 fnThree =
  { comma: false
@@ -46,9 +69,18 @@ fnThree =
  }
 
 
-numeral ∷ ∀ e. Eff (console ∷ CONSOLE |e) Unit
-numeral = do
-  log $ "NUMERAL TESTS\n\n"
+fdtOne ∷ FDT.Formatter
+fdtOne =
+  roll $ FDT.Placeholder "format string is "
+  $ roll $ FDT.YearFull
+  $ roll $ FDT.Placeholder "-"
+  $ roll $ FDT.MonthShort
+  $ roll FDT.End
+
+
+numeralTests :: forall e. Tests e Unit
+numeralTests = do
+  log $ "\nNUMERAL TESTS\n"
 
   log $ "\nPRINT FORMATTER"
   log $ FN.printFormatter fnOne
@@ -84,31 +116,84 @@ numeral = do
   log $ "\n UNFORMAT NUMBER"
   DT.traceAnyA $ FN.unformatNumber "0.00" "12.00"
 
-fdtOne ∷ FDT.Formatter
-fdtOne =
-  roll $ FDT.Placeholder "format string is "
-  $ roll $ FDT.YearFull
-  $ roll $ FDT.Placeholder "-"
-  $ roll $ FDT.MonthShort
-  $ roll FDT.End
 
-testDateTime ∷ DTi.DateTime
-testDateTime =
+-- April 12th 2017 at 11:34:34:234
+-- 4/12/2017
+makeDateTime ∷ Int -> DTi.DateTime
+makeDateTime year =
   DTi.DateTime
-    (D.canonicalDate (fromMaybe bottom $ toEnum 1234) D.April (fromMaybe bottom $ toEnum 12))
+    (D.canonicalDate (fromMaybe bottom $ toEnum year) D.April (fromMaybe bottom $ toEnum 12))
     (T.Time
        (fromMaybe bottom $ toEnum 11)
        (fromMaybe bottom $ toEnum 34)
        (fromMaybe bottom $ toEnum 34)
        (fromMaybe bottom $ toEnum 234))
 
-timeTest ∷ ∀ e. Eff (console ∷ CONSOLE |e) Unit
-timeTest = do
-  log $ "\n\n DATETIME FORMATTER"
-  log "\nPRINT FORMATTER"
-  log $ FDT.printFormatter fdtOne
+testDateTime :: DTi.DateTime
+testDateTime = makeDateTime 2017
+
+
+assert :: forall e. String -> String -> Boolean -> Tests e Unit
+assert _           success true = log $ "  ✓ - Passed - " <> success
+assert fail _              false = do
+  log $ "  ☠ - Failed because " <> fail
+  put false
+
+
+failTest :: forall e. String -> Tests e Unit
+failTest message = do
+  log message
+  put false
 
+
+assertFormatting :: forall e. String -> String -> DateTime -> Tests e Unit
+assertFormatting target' format dateTime = do
+  let result = FDT.formatDateTime format dateTime
+  let target = Right target'
+  assert
+    ((show result) <> " does not equal " <> (show target))
+    ((show result) <> " equals " <> (show target))
+    (result == target)
+
+
+timeTest :: forall e. Tests e Unit
+timeTest = do
+  log "- Data.Formatter.DateTime.formatDateTime"
+
+  -- var a = moment(
+  --   'April 12th 2017 at 11:34:34:234',
+  --   'MMMM Do YYYY [at] HH:mm:ss:SSS'
+  -- );
+  -- a.format('MMMM Do YYYY [at] HH:mm:ss:SSS')
+  -- testDateTime = April 12th 2017 at 11:34:34:234
+  assertFormatting "04/12/2017"      "MM/DD/YYYY" testDateTime
+  assertFormatting "April"           "MMMM" testDateTime
+  assertFormatting "2017-12-04"      "YYYY-DD-MM" testDateTime
+  assertFormatting "2017-Apr"        "YYYY-MMM" testDateTime
+
+  -- This should probably be am (lowercase), if the desired
+  -- functionality of the library is to mirror momentjs
+  assertFormatting "11:34:34:234 AM" "hh:mm:ss:SSS a"  testDateTime
+  assertFormatting "17"            "YY"  testDateTime
+  log "  --- Format 20017 with YY"
+  assertFormatting "17"            "YY"  (makeDateTime 20017)
+  log "  --- Format 0 with YY"
+  assertFormatting "00"            "YY"  (makeDateTime 0)
+  log "  --- Format -1 with YY"
+  assertFormatting "01"            "YY"  (makeDateTime (-1))
+
+  log "- Data.Formatter.DateTime.unformatDateTime "
+
+  let dt = FDT.unformatDateTime "YYYY-DD-MM SSS" "2017-12-04 234"
+  either
+    (const $ failTest "Could not parse 017-12-04 234")
+    (assertFormatting "2017-12-04 234" "YYYY-DD-MM SSS")
+    dt
+
+formattingTests :: forall e. Tests e Unit
+formattingTests = do
   log $ "\nPARSE FORMAT STRING"
+
   DT.traceAnyA $ FDT.parseFormatString "YYYY-MM-DD"
   DT.traceAnyA $ FDT.parseFormatString "YY-Q-dddd HH:mm Z"
 
@@ -123,8 +208,15 @@ timeTest = do
   log $ "\nUNFORMATDATETIME"
   DT.traceAnyA $ FDT.unformatDateTime "YYYY-DD-MM SSS" "3456-09-10 333"
 
-
-main ∷ forall e. Eff (console ∷ CONSOLE | e) Unit
-main = do
-  timeTest
-  numeral
+main :: forall e.
+  Eff ( process :: PROCESS, exception :: EXCEPTION, console :: CONSOLE | e)
+    (Canceler ( process :: PROCESS, exception :: EXCEPTION, console :: CONSOLE | e))
+main = execTests tests true
+  where
+  tests = do
+    log "Testing time functions..."
+    timeTest
+    passed <- get
+    when (passed /= true) (throwError (error "Tests did not pass."))
+    --numeralTests
+    --formattingTests