diff --git a/CHANGELOG b/CHANGELOG --- a/CHANGELOG +++ b/CHANGELOG @@ -6,6 +6,9 @@ read default language from $LANG (hFlush!) daemon? +0.7.4.1 2011.08.01 + fixed cabal (thanks Simon Hengel) + 0.7.4 2011.04.26 added Italian (thanks erm67) diff --git a/INSTALL b/INSTALL --- a/INSTALL +++ b/INSTALL @@ -1,4 +1,4 @@ -fuzzytime 0.7.4 (2011.04.26) +fuzzytime 0.7.4.1 (2011.08.01) A clock and timer that tell the time in a more human way (the 'ten past six'-style) diff --git a/README b/README --- a/README +++ b/README @@ -15,7 +15,7 @@ ### --help A clock and timer that tell the time in a more human way. -v0.7.4, 2011.04.26, *antispam*, GPL3+ +v0.7.4.1, 2011.08.01, *antispam*, GPL3+ fuzzytime [COMMAND] ... [OPTIONS] diff --git a/fuzzytime.cabal b/fuzzytime.cabal --- a/fuzzytime.cabal +++ b/fuzzytime.cabal @@ -1,7 +1,7 @@ name: fuzzytime -version: 0.7.4 -description: A clock and timer that tell the time in a more human way -synopsis: A clock and timer that tell the time in a more human way +version: 0.7.4.1 +description: A clock and timer that tell the time in a more human way (the 'ten past six' style) +synopsis: A 'ten past six' style clock category: Utils license: GPL license-file: LICENSE @@ -17,14 +17,28 @@ library buildable: True build-depends: base >= 4 && < 5 - exposed-modules: FuzzyTime + exposed-modules: FuzzyTime, + FuzzyTime.Danish, + FuzzyTime.Dutch, + FuzzyTime.English, + FuzzyTime.German, + FuzzyTime.Greek, + FuzzyTime.Italian, + FuzzyTime.French, + FuzzyTime.Norwegian, + FuzzyTime.Polish, + FuzzyTime.Spanish, + FuzzyTime.Swedish, + FuzzyTime.Turkish hs-source-dirs: src - -- ghc-options: -O2 executable fuzzytime buildable: True main-is: fuzzytime.hs build-depends: base >= 4 && < 5, cmdargs, haskell98, old-time, process hs-source-dirs: src - -- ghc-options: -Wall -O2 - -- ghc-options: -O2 + +source-repository this + type: git + location: https://github.com/caminoix/fuzzytime + tag: 0.7.4.1 diff --git a/src/FuzzyTime/Danish.hs b/src/FuzzyTime/Danish.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Danish.hs @@ -0,0 +1,57 @@ +-- Danish (thanks M_ller from bbs.archlinux.org) ---------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Danish (showFuzzyTimeDa) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeDa ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeDa :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeDa fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeDaHlp fc) +showFuzzyTimeDa ft@(FuzzyTimer _ _) = showFuzzyTimeDaHlp ft + +showFuzzyTimeDaHlp :: FuzzyTime -> String +showFuzzyTimeDaHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = getHour hour + | min < 30 = getMin min ++ " over " ++ getHour hour + | min == 30 = "halv " ++ getHour (nextFTHour fc) + | min > 30 = getMin (60-min) ++ " i " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then + numeralDa clock + else + if min /=30 then "midnat" else numeralDa clock + | otherwise = numeralDa h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "kvart" + | otherwise = numeralDa m + +-- FuzzyTimer + +showFuzzyTimeDaHlp (FuzzyTimer _ _) = "Danish is not yet available in the timer mode.\nIf you can provide a translation, please contact kamil.stachowski@gmail.com." + + +-- numeralDa ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralDa :: Int -> String +numeralDa n + | n < 20 = numeralDaHelper1 n + | n `mod` 10 == 0 = numeralDaHelper10 (n `div` 10) + | otherwise = numeralDaHelper1 (n `mod` 10) ++ "og" ++ numeralDaHelper10 (n `div` 10) + where + numeralDaHelper1 :: Int -> String + numeralDaHelper1 i = ["en", "to", "tre", "fire", "fem", "seks", "syv", "otte", "ni", "ti", "elleve", "tolv", "tretten", "fjorten", "femten", "seksten", "sytten", "atten", "nitten"] !! (i-1) + numeralDaHelper10 :: Int -> String + numeralDaHelper10 i = ["tyve", "tredive", "fyrre", "halvtreds"] !! (i-2) diff --git a/src/FuzzyTime/Dutch.hs b/src/FuzzyTime/Dutch.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Dutch.hs @@ -0,0 +1,85 @@ +-- Dutch (thanks Boris from forums.gentoo.org and litemotiv from bbs.archlinux.org) ----------------------------------------------------------------------------------------------- + + +module FuzzyTime.Dutch (showFuzzyTimeNl) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeNl ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeNl :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeNl fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeNlHlp fc) +showFuzzyTimeNl ft@(FuzzyTimer _ _) = showFuzzyTimeNlHlp ft + +showFuzzyTimeNlHlp :: FuzzyTime -> String +showFuzzyTimeNlHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = if getHour hour == "middernacht" then getHour hour else getHour hour ++ " uur" + | min `elem` [20..29] + && style == 2 = getMin (30-min) ++ " voor half " ++ getHour (nextFTHour fc) + | min < 30 = getMin min ++ " over " ++ getHour hour + | min `elem` [31..40] + && style == 2 = getMin (min-30) ++ " over half " ++ getHour (nextFTHour fc) + | min == 30 = "half " ++ getHour (nextFTHour fc) + | min > 30 = getMin (60-min) ++ " voor " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then + numeralNl clock + else + if min /= 30 then "middernacht" else numeralNl clock + | otherwise = numeralNl h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "kwart" + | otherwise = numeralNl m + +-- FuzzyTimer + +showFuzzyTimeNlHlp (FuzzyTimer _ mins) + | mins > 0 = "over " ++ showHelper + | mins == 0 = "nu!" + | mins < 0 = "! " ++ showHelper ++ " geleden !" + where + showHelper :: String + showHelper + | mm > 90 = numeralNl hours ++ (if half then " en een half" else "") ++ " uur" + | mm == 90 = "anderhalf uur" + | mm == 75 = "vijf kwartier" + | mm == 60 = "een uur" + | mm == 45 = "drie kwartier" + | mm == 30 = "een half uur" + | mm == 15 = "een kwartier" + | mm > 1 = numeralNl mm ++ " minuten" + | mm == 1 = "een minuut" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralNl ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralNl :: Int -> String +numeralNl n + | n < 20 = numeralNlHelper1 n + | n `mod` 10 == 0 = numeralNlHelper10 (n `div` 10) + | otherwise = numeralNlHelper1 (n `mod` 10) ++ + (if (n `mod` 10) `elem` [2, 3] then "ën" else "en") ++ + numeralNlHelper10 (n `div` 10) + where + numeralNlHelper1 :: Int -> String + numeralNlHelper1 i = ["een", "twee", "drie", "vier", "vijf", "zes", "zeven", "acht", "negen", "tien", "elf", "twaalf", "dertien", "veertien", "vijftien", "zestien", "zeventien", "achttien", "negentien"] !! (i-1) + numeralNlHelper10 :: Int -> String + numeralNlHelper10 i = ["twintig", "dertig", "veertig", "vijftig"] !! (i-2) diff --git a/src/FuzzyTime/English.hs b/src/FuzzyTime/English.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/English.hs @@ -0,0 +1,82 @@ +-- English ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + + +module FuzzyTime.English (showFuzzyTimeEn) where + +import {-# SOURCE #-} FuzzyTime +import Data.Char (toLower, toUpper) +import Data.List (intersperse) +import Prelude hiding (min) + + +-- showFuzzyTimeEn ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeEn :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeEn fc@(FuzzyClock _ caps clock hour _ min style) + | min == 0 = capsize $ if getHour hour `elem` ["midnight", "noon"] then getHour hour else getHour hour ++ " o’clock" + | min <= 30 = capsize $ getMin min ++ " past " ++ getHour hour + | min > 30 = capsize $ getMin (60-min) ++ " to " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + capsize :: String -> String + capsize s + | caps == 0 = map toLower s + | caps == 1 = concat . intersperse " " $ map (\w -> if w `elem` ["o’clock","past","to"] then w else toUpper (head w) : tail w) (words s) + | caps == 2 = concat . intersperse " " $ map (\w -> toUpper (head w) : tail w) (words s) + | caps == 3 = map toUpper s + | otherwise = "Oops, looks like caps = " ++ show caps ++ "." + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then numeralEn clock else "midnight" + | h == 12 = if style==1 then numeralEn 12 else "noon" + | otherwise = numeralEn h + getMin :: Int -> String + getMin m + | m == 30 = "half" + | m `elem` [15, 45] = "quarter" + | otherwise = numeralEn m + +-- FuzzyTimer + +showFuzzyTimeEn (FuzzyTimer _ mins) + | mins > 0 = "in " ++ showHelper + | mins == 0 = "now!" + | mins < 0 = "! " ++ showHelper ++ " ago !" + where + showHelper :: String + showHelper + | mm > 90 = numeralEn hours ++ (if half then " and a half" else "") ++ " hours" + | mm == 90 = "an hour and a half" + | mm == 75 = "an hour and a quarter" + | mm == 60 = "an hour" + | mm == 45 = "three quarters" + | mm == 30 = "half an hour" + | mm == 15 = "a quarter" + | mm > 1 = numeralEn mm ++ " minutes" + | mm == 1 = "a minute" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralEn ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralEn :: Int -> String +numeralEn n + | n < 20 = numeralEnHelper1 n + | n `mod` 10 == 0 = numeralEnHelper10 (n `div` 10) + | otherwise = numeralEnHelper10 (n `div` 10) ++ "-" ++ numeralEnHelper1 (n `mod` 10) + where + numeralEnHelper1 :: Int -> String + numeralEnHelper1 i = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"] !! (i-1) + numeralEnHelper10 :: Int -> String + numeralEnHelper10 i = ["twenty", "thirty", "forty", "fifty"] !! (i-2) diff --git a/src/FuzzyTime/French.hs b/src/FuzzyTime/French.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/French.hs @@ -0,0 +1,81 @@ +-- French ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.French (showFuzzyTimeFr) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeFr ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeFr :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeFr fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeFrHlp fc) +showFuzzyTimeFr ft@(FuzzyTimer _ _) = showFuzzyTimeFrHlp ft + +showFuzzyTimeFrHlp :: FuzzyTime -> String +showFuzzyTimeFrHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = getHour hour + | min <= 30 = getHour hour ++ " " ++ getMin min + | min > 30 = getHour (nextFTHour fc) ++ " moins " ++ getMin (60-min) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then numeralFr clock ++ getHourWord clock else "minuit" + | h == 12 = if style==1 then numeralFr 12 else "midi" + | otherwise = numeralFr h ++ getHourWord h + getHourWord :: Int -> String + getHourWord h = if h==1 then " heure" else " heures" + getMin :: Int -> String + getMin m + | min == 15 = "et quart" + | min == 30 = "et demie" + | min == 45 = "le quart" + | otherwise = numeralFr m + +-- FuzzyTimer + +showFuzzyTimeFrHlp (FuzzyTimer _ mins) + | mins > 0 = "dans " ++ showHelper + | mins == 0 = "maintenant!" + | mins < 0 = "! il y a " ++ showHelper ++ " !" + where + showHelper :: String + showHelper + | mm > 90 = numeralFr hours ++ " heures " ++ (if half then " et demie" else "") + | mm == 90 = "une heure et demie" + | mm == 75 = "une heure et quart" + | mm == 60 = "une heure" + | mm == 45 = "trois quarts d’heure" + | mm == 30 = "une demie d’heure" + | mm == 15 = "un quart d’heure" + | mm > 1 = numeralFr mm ++ " minutes" + | mm == 1 = "une minute" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralFr ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralFr :: Int -> String +numeralFr n + | n < 20 = numeralFrHelper1 n + | n `mod` 10 == 0 = numeralFrHelper10 (n `div` 10) + | otherwise = numeralFrHelper10 (n `div` 10) ++ "-" ++ numeralFrHelper1 (n `mod` 10) + where + numeralFrHelper1 :: Int -> String + numeralFrHelper1 i = ["une", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf"] !! (i-1) + numeralFrHelper10 :: Int -> String + numeralFrHelper10 i = ["vingt", "trente", "quarante", "cinquante"] !! (i-2) + diff --git a/src/FuzzyTime/German.hs b/src/FuzzyTime/German.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/German.hs @@ -0,0 +1,86 @@ +-- German (thanks Clad in the sky, ichbinsisyphos and marens from forums.gentoo.org) ---------------------------------------------------------------------------------------------- + + +module FuzzyTime.German (showFuzzyTimeDe) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeDe ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeDe :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeDe fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeDeHlp fc) +showFuzzyTimeDe ft@(FuzzyTimer _ _) = showFuzzyTimeDeHlp ft + +showFuzzyTimeDeHlp :: FuzzyTime -> String +showFuzzyTimeDeHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = if getHour hour `elem` ["Mitternacht", "Mittag"] then getHour hour else getHour hour ++ " Uhr" + | min == 15 + && style == 3 = "Viertel " ++ getHour (nextFTHour fc) + | min `elem` [23..29] + && style >= 2 = getMin (30-min) ++ " vor halb " ++ getHour (nextFTHour fc) + | min < 30 = getMin min ++ " nach " ++ getHour hour + | min `elem` [31..37] + && style >= 2 = getMin (min-30) ++ " nach halb " ++ getHour (nextFTHour fc) + | min == 30 = "halb " ++ getHour (nextFTHour fc) + | min == 45 + && style == 3 = "Dreiviertel " ++ getHour (nextFTHour fc) + | min > 30 = getMin (60-min) ++ " vor " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then + numeralDe clock + else + if min /=30 then "Mitternacht" else numeralDe clock + | otherwise = numeralDe h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "Viertel" + | otherwise = numeralDe m + +-- FuzzyTimer + +showFuzzyTimeDeHlp (FuzzyTimer _ mins) + | mins > 0 = "in " ++ showHelper + | mins == 0 = "jetzt!" + | mins < 0 = "! vor " ++ showHelper ++ " !" + where + showHelper :: String + showHelper + | mm >= 90 = numeralDe hours ++ (if half then "einhalb" else "") ++ " Stunden" + | mm == 75 = "einer Stunde und fünfzehn Minuten" + | mm == 60 = "einer Stunde" + | mm == 45 = "einer Dreiviertelstunde" + | mm == 30 = "eine halbe Stunde" + | mm == 15 = "einer ViertelStunde" + | mm > 1 = numeralDe mm ++ " Minuten" + | mm == 1 = "einer Minute" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralDe ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralDe :: Int -> String +numeralDe n + | n < 20 = numeralDeHelper1 n + | n `mod` 10 == 0 = numeralDeHelper10 (n `div` 10) + | otherwise = numeralDeHelper1 (n `mod` 10) ++ "und" ++ numeralDeHelper10 (n `div` 10) + where + numeralDeHelper1 :: Int -> String + numeralDeHelper1 i = ["ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwőlf", "dreizehn", "vierzehn", "fünfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"] !! (i-1) + numeralDeHelper10 :: Int -> String + numeralDeHelper10 i = ["zwanzig", "dreissig", "vierzig", "fünfzig"] !! (i-2) diff --git a/src/FuzzyTime/Greek.hs b/src/FuzzyTime/Greek.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Greek.hs @@ -0,0 +1,54 @@ +-- Greek (thanks Gbak from bbs.archlinux.org) ------------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Greek (showFuzzyTimeEl) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeEl ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeEl :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeEl fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeElHlp fc) +showFuzzyTimeEl ft@(FuzzyTimer _ _) = showFuzzyTimeElHlp ft + +showFuzzyTimeElHlp :: FuzzyTime -> String +showFuzzyTimeElHlp fc@(FuzzyClock _ _ clock hour _ min _) + | min == 0 = getHour hour + | min <= 30 = getHour hour ++ " και " ++ getMin min + | min > 30 = getHour (nextFTHour fc) ++ " παρά " ++ getMin (60-min) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `mod` 12 == 0 = if clock==12 then numeralEl 12 else numeralEl h + | otherwise = numeralEl h + getMin :: Int -> String + getMin m + | m == 30 = "μισή" + | m `elem` [15, 45] = "τέταρτο" + | otherwise = numeralEl m + +-- FuzzyTimer + +showFuzzyTimeElHlp (FuzzyTimer _ _) = "Greek is not yet available in the timer mode.\nIf you can provide a translation, please contact kamil.stachowski@gmail.com." + + +-- numeralEl ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralEl :: Int -> String +numeralEl n + | n < 20 = numeralElHelper1 n + | n `mod` 10 == 0 = numeralElHelper10 (n `div` 10) + | otherwise = numeralElHelper10 (n `div` 10) ++ " " ++ numeralElHelper1 (n `mod` 10) + where + numeralElHelper1 :: Int -> String + numeralElHelper1 i = ["ένας", "δυο", "τρεις", "τέσσερις", "πέντε", "έξι", "εφτά", "οχτώ", "εννιά", "δέκα", "έντεκα", "δώδεκα", "δεκατρείς", "δεκατέσσερις", "δεκαπέντε", "δεκάξι", "δεκαεφτά", "δεκαοχτώ", "δεκαεννιά"] !! (i-1) + numeralElHelper10 :: Int -> String + numeralElHelper10 i = ["είκοσι", "τριάντα", "σαράντα", "πενήντα"] !! (i-2) diff --git a/src/FuzzyTime/Italian.hs b/src/FuzzyTime/Italian.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Italian.hs @@ -0,0 +1,70 @@ +-- Italian (thanks erm67 from forums.gentoo.org) ---------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Italian (showFuzzyTimeIt) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeIt ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeIt :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeIt fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeItHlp fc) +showFuzzyTimeIt ft@(FuzzyTimer _ _) = showFuzzyTimeItHlp ft + +showFuzzyTimeItHlp :: FuzzyTime -> String +showFuzzyTimeItHlp fc@(FuzzyClock am _ clock hour _ min style) + | min == 0 = if getHour hour `elem` ["mezzanotte", "mezzogiorno"] then getHour hour else getHour hour ++ getAm hour + | min <= 30 = getHour hour ++ " e " ++ getMin min ++ getAm hour + | min > 30 = getHour (nextFTHour fc) ++ " meno " ++ getMin (60-min) ++ getAm (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getAm :: Int -> String + getAm h = + if style==2 && (getHour h) `notElem` ["mezzanotte", "mezzogiorno"] then + if hh < 5 then " di notte" else + if hh < 13 then " del mattino" else + if hh < 19 then " del pomeriggio" else " di sera" + else "" + where + hh :: Int + hh = if clock==12 && h < 12 && not am then h+12 else h + getHour :: Int -> String + getHour h + | h `mod` clock == 1= "l’una" + | h `elem` [0, 24] = if style==1 then "le " ++ numeralIt clock else "mezzanotte" + | h == 12 = if style==1 then "le " ++ numeralIt clock else "mezzogiorno" + | otherwise = "le " ++ numeralIt h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "un quarto" + | m == 30 = "mezzo" + | otherwise = numeralIt m + +-- FuzzyTimer + +showFuzzyTimeItHlp (FuzzyTimer _ _) = "Italian is not yet available in the timer mode.\nIf you can provide a translation, please contact kamil.stachowski@gmail.com." + + +-- numeralEs ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralIt :: Int -> String +numeralIt n + | n < 20 = numeralItHelper1 n + | n `mod` 10 == 0 = numeralItHelper10 (n `div` 10) + | otherwise = if (n `mod` 10) `elem` [1, 3, 8] + then if (n `mod` 10) `elem` [1, 8] + then init (numeralItHelper10 (n `div` 10)) ++ numeralItHelper1 (n `mod` 10) + else numeralItHelper10 (n `div` 10) ++ "tré" + else numeralItHelper10 (n `div` 10) ++ numeralItHelper1 (n `mod` 10) + where + numeralItHelper1 :: Int -> String + numeralItHelper1 i = ["uno", "due", "tre", "quattro", "cinque", "sei", "sette", "otto", "nove", "dieci", "undici", "dodici", "tredici", "quattordici", "quindici", "sedici", "diciasette", "diciotto", "diciannove"] !! (i-1) + numeralItHelper10 :: Int -> String + numeralItHelper10 i = ["venti", "trenta", "quaranta", "cinquanta"] !! (i-2) diff --git a/src/FuzzyTime/Norwegian.hs b/src/FuzzyTime/Norwegian.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Norwegian.hs @@ -0,0 +1,78 @@ +-- Norwegian (Bokmål) (thanks arnvidr from forums.gentoo.org) --------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Norwegian (showFuzzyTimeNb) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeNb ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeNb :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeNb fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeNbHlp fc) +showFuzzyTimeNb ft@(FuzzyTimer _ _) = showFuzzyTimeNbHlp ft + +showFuzzyTimeNbHlp :: FuzzyTime -> String +showFuzzyTimeNbHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = getHour hour + | min `elem` [20..29] = getMin (30-min) ++ " på halv " ++ getHour (nextFTHour fc) + | min < 30 = getMin min ++ " over " ++ getHour hour + | min `elem` [31..40] = getMin (min-30) ++ " over halv " ++ getHour (nextFTHour fc) + | min == 30 = "halv " ++ getHour (nextFTHour fc) + | min > 30 = getMin (60-min) ++ " på " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then numeralNb clock else "midnatt" + | otherwise = numeralNb h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "kvart" + | otherwise = numeralNb m + +-- FuzzyTimer + +showFuzzyTimeNbHlp (FuzzyTimer _ mins) + | mins > 0 = "om " ++ showHelper + | mins == 0 = "nå!" + | mins < 0 = "! for " ++ showHelper ++ " siden !" + where + showHelper :: String + showHelper + | mm > 90 = numeralNb hours ++ (if half then " og en halv" else "") ++ " time" + | mm == 90 = "halvannen time" + | mm == 75 = "en time og ett kvarter" + | mm == 60 = "en time" + | mm == 45 = "tre kvarter" + | mm == 30 = "halv time" + | mm == 15 = "en kvarter" + | mm > 1 = numeralNb mm ++ " minutter" + | mm == 1 = "en minutt" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralDa ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralNb :: Int -> String +numeralNb n + | n < 20 = numeralNbHelper1 n + | n `mod` 10 == 0 = numeralNbHelper10 (n `div` 10) + | otherwise = numeralNbHelper10 (n `div` 10) ++ " " ++ numeralNbHelper1 (n `mod` 10) + where + numeralNbHelper1 :: Int -> String + numeralNbHelper1 i = ["en", "to", "tre", "fire", "fem", "seks", "sju", "åtte", "ni", "ti", "elleve", "tolv", "tretten", "fjorten", "femten", "seksten", "sytten", "atten", "nitten"] !! (i-1) + numeralNbHelper10 :: Int -> String + numeralNbHelper10 i = ["tjue", "tretti", "førti", "femti"] !! (i-2) diff --git a/src/FuzzyTime/Polish.hs b/src/FuzzyTime/Polish.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Polish.hs @@ -0,0 +1,110 @@ +-- Polish ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Polish (showFuzzyTimePl) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimePl ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimePl :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimePl fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimePlHlp fc) +showFuzzyTimePl ft@(FuzzyTimer _ _) = showFuzzyTimePlHlp ft + +showFuzzyTimePlHlp :: FuzzyTime -> String +showFuzzyTimePlHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = getHourEven hour + | min `elem` [23..29] + && style == 2 = "za " ++ getMin (30-min) ++ " w pół do " ++ getHourOdd (nextFTHour fc) + | min < 30 = getMin min ++ " po " ++ getHourOdd hour + | min == 30 = "w pół do " ++ getHourOdd (nextFTHour fc) + | min `elem` [31..37] + && style == 2 = getMin (min-30) ++ " po w pół do " ++ getHourOdd (nextFTHour fc) + | min > 30 = "za " ++ getMin (60-min) ++ " " ++ getHourEven (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHourEven :: Int -> String + getHourEven h + | h `elem` [0, 24] = if style==1 then numeralPlOrd Nom clock else "północ" + | otherwise = numeralPlOrd Nom h + getHourOdd :: Int -> String + getHourOdd h + | h `elem` [0, 24] = if style==1 then + numeralPlOrd Praep clock + else + if min < 30 then "północy" else numeralPlOrd Praep clock + | otherwise = numeralPlOrd Praep h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "kwadrans" + | otherwise = numeralPlCard m + +-- FuzzyTimer + +showFuzzyTimePlHlp (FuzzyTimer _ mins) + | mins > 0 = "za " ++ showHelper + | mins == 0 = "teraz!" + | mins < 0 = "! " ++ showHelper ++ " temu !" + where + showHelper :: String + showHelper + | mm == 1320 = "dwadzieścia dwie godziny" + | mm > 1260 = numeralPlCard hours ++ " godziny" + | mm > 270 = numeralPlCard hours ++ " godzin" + | mm == 150 = "dwie i pół godziny" + | mm == 120 = "dwie godziny" + | mm > 90 = numeralPlCard hours ++ (if half then " i pół" else "") ++ " godziny" + | mm == 90 = "półtorej godziny" + | mm == 75 = "godzinę piętnaście" + | mm == 60 = "godzinę" + | mm == 45 = "trzy kwadranse" + | mm == 30 = "pół godziny" + | mm == 15 = "kwadrans" + | mm > 4 = numeralPlCard mm ++ " minut" + | mm > 1 = numeralPlCard mm ++ " minuty" + | mm == 1 = "minutę" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralPl ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +data Case = Nom | Praep + + +numeralPlCard :: Int -> String +numeralPlCard n + | n < 20 = numeralPlCardHelper1 n + | n `mod` 10 == 0 = numeralPlCardHelper10 (n `div` 10) + | otherwise = numeralPlCardHelper10 (n `div` 10) ++ " " ++ numeralPlCardHelper1 (n `mod` 10) + where + numeralPlCardHelper1 :: Int -> String + numeralPlCardHelper1 i = ["jeden", "dwa", "trzy", "cztery", "pięć", "sześć", "siedem", "osiem", "dziewięć", "dziesięć", "jedenaście", "dwanaście", "trzynaście", "czternaście", "kwadrans", "szesnaście", "siedemnaście", "osiemnaście", "dziewiętnaście"] !! (i-1) + numeralPlCardHelper10 :: Int -> String + numeralPlCardHelper10 i = ["dwadzieścia", "trzydzieści", "czterdzieści", "pięćdziesiąt"] !! (i-2) + + +numeralPlOrd :: Case -> Int -> String +numeralPlOrd c num + | num <= 20 = numeralPlOrdHelper1 c num + | otherwise = numeralPlOrdHelper10 c ++ " " ++ numeralPlOrdHelper1 c (num `mod` 10) + where + numeralPlOrdHelper1 :: Case -> Int -> String + numeralPlOrdHelper1 Nom n = ["pierwsza", "druga", "trzecia", "czwarta", "piąta", "szósta", "siódma", "ósma", "dziewiąta", "dziesiąta", "jedenasta", "dwunasta", "trzynasta", "czternasta", "piętnasta", "szesnasta", "siedemnasta", "osiemnasta", "dziewiętnasta", "dwudziesta"] !! (n-1) + numeralPlOrdHelper1 Praep n = ["pierwszej", "drugiej", "trzeciej", "czwartej", "piątej", "szóstej", "siódmej", "ósmej", "dziewiątej", "dziesiątej", "jedenastej", "dwunastej", "trzynastej", "czternastej", "piętnastej", "szesnastej", "siedemnastej", "osiemnastej", "dziewiętnastej", "dwudziestej"] !! (n-1) + numeralPlOrdHelper10 :: Case -> String + numeralPlOrdHelper10 Nom = "dwudziesta" + numeralPlOrdHelper10 Praep = "dwudziestej" + diff --git a/src/FuzzyTime/Spanish.hs b/src/FuzzyTime/Spanish.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Spanish.hs @@ -0,0 +1,71 @@ +-- Spanish (thanks xenofungus and itsbrad212 from bbs.archlinux.org) -------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Spanish (showFuzzyTimeEs) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeEs ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeEs :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeEs fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeEsHlp fc) +showFuzzyTimeEs ft@(FuzzyTimer _ _) = showFuzzyTimeEsHlp ft + +showFuzzyTimeEsHlp :: FuzzyTime -> String +showFuzzyTimeEsHlp fc@(FuzzyClock am _ clock hour _ min style) + | min == 0 = if getHour hour == "la medianoche" then getHour hour else getHour hour ++ getAm hour + | min <= 30 = getHour hour ++ " y " ++ getMin min ++ getAm hour + | min > 30 = getHour (nextFTHour fc) ++ " menos " ++ getMin (60-min) ++ getAm (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getAm :: Int -> String + getAm h = + if style==3 && getHour h /= "la medianoche" then + if hh < 13 then " de la mañana" else + if hh < 21 then " de la tarde" else " de la noche" + else "" + where + hh :: Int + hh = if clock==12 && h < 12 && not am then h+12 else h + getHour :: Int -> String + getHour h + | h `mod` clock == 1= "la una" + | h `elem` [0, 24] = if style==1 then "las " ++ numeralEs clock else "la medianoche" + | otherwise = "las " ++ numeralEs h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "cuarto" + | m == 30 = "media" + | otherwise = numeralEs m + +-- FuzzyTimer + +showFuzzyTimeEsHlp (FuzzyTimer _ _) = "Spanish is not yet available in the timer mode.\nIf you can provide a translation, please contact kamil.stachowski@gmail.com." + + +-- numeralEs ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralEs :: Int -> String +numeralEs n + | n < 20 = numeralEsHelper1 n + | n == 20 = "veinte" + | n == 21 = "veintiuno" + | n == 22 = "veintidós" + | n == 23 = "veintitrés" + | n == 26 = "veintiséis" + | n < 30 = "veinti" ++ numeralEsHelper1 (n `mod` 10) + | n `mod` 10 == 0 = numeralEsHelper10 (n `div` 10) + | otherwise = numeralEsHelper10 (n `div` 10) ++ " y " ++ numeralEsHelper1 (n `mod` 10) + where + numeralEsHelper1 :: Int -> String + numeralEsHelper1 i = ["una", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez", "once", "doce", "trece", "catorce", "quince", "dieciséis", "diecisiete", "dieciocho", "diecinueve"] !! (i-1) + numeralEsHelper10 :: Int -> String + numeralEsHelper10 i = ["treinta", "cuarenta", "cincuenta"] !! (i-3) + diff --git a/src/FuzzyTime/Swedish.hs b/src/FuzzyTime/Swedish.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Swedish.hs @@ -0,0 +1,78 @@ +-- Swedish (thanks Closey from forums.gentoo.org) --------------------------------------------------------------------------------------------------------------------------------- + + +module FuzzyTime.Swedish (showFuzzyTimeSe) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeSe ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeSe :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeSe fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeSeHlp fc) +showFuzzyTimeSe ft@(FuzzyTimer _ _) = showFuzzyTimeSeHlp ft + +showFuzzyTimeSeHlp :: FuzzyTime -> String +showFuzzyTimeSeHlp fc@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = getHour hour + | min `elem` [23..29] = getMin (30-min) ++ " i halv " ++ getHour (nextFTHour fc) + | min < 30 = getMin min ++ " över " ++ getHour hour + | min `elem` [31..37] = getMin (min-30) ++ " över halv " ++ getHour (nextFTHour fc) + | min == 30 = "halv " ++ getHour (nextFTHour fc) + | min > 30 = getMin (60-min) ++ " i " ++ getHour (nextFTHour fc) + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Int -> String + getHour h + | h `elem` [0, 24] = if style==1 then numeralSe clock else "midnatt" + | otherwise = numeralSe h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "kvart" + | otherwise = numeralSe m + +-- FuzzyTimer + +showFuzzyTimeSeHlp (FuzzyTimer _ mins) + | mins > 0 = "om " ++ showHelper + | mins == 0 = "nu!" + | mins < 0 = "! för " ++ showHelper ++ " sedan !" + where + showHelper :: String + showHelper + | mm > 90 = numeralSe hours ++ (if half then " och en halv" else "") ++ " timmar" + | mm == 90 = "en och en halv timme" + | mm == 75 = "en timme och en kvart" + | mm == 60 = "en timme" + | mm == 45 = "fyrtiofem minuter" + | mm == 30 = "halv timme" + | mm == 15 = "en kvart" + | mm > 1 = numeralSe mm ++ " minuter" + | mm == 1 = "en minut" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralSe ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +numeralSe :: Int -> String +numeralSe n + | n < 20 = numeralSeHelper1 n + | n `mod` 10 == 0 = numeralSeHelper10 (n `div` 10) + | otherwise = numeralSeHelper10 (n `div` 10) ++ numeralSeHelper1 (n `mod` 10) + where + numeralSeHelper1 :: Int -> String + numeralSeHelper1 i = ["ett", "två", "tre", "fyra", "fem", "sex", "sju", "åtta", "nio", "tio", "elva", "tolv", "tretton", "fjorton", "femton", "sexton", "sjutton", "arton", "nitton"] !! (i-1) + numeralSeHelper10 :: Int -> String + numeralSeHelper10 i = ["tjugo", "trettio", "fyrtio", "femtio"] !! (i-2) diff --git a/src/FuzzyTime/Turkish.hs b/src/FuzzyTime/Turkish.hs new file mode 100644 --- /dev/null +++ b/src/FuzzyTime/Turkish.hs @@ -0,0 +1,85 @@ +-- Turkish ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + + +module FuzzyTime.Turkish (showFuzzyTimeTr) where + +import {-# SOURCE #-} FuzzyTime +import Prelude hiding (min) + + +-- showFuzzyTimeTr ---------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +showFuzzyTimeTr :: FuzzyTime -> String + +-- FuzzyClock + +showFuzzyTimeTr fc@(FuzzyClock _ caps _ _ _ _ _) = capsizeDef caps (showFuzzyTimeTrHlp fc) +showFuzzyTimeTr ft@(FuzzyTimer _ _) = showFuzzyTimeTrHlp ft + +showFuzzyTimeTrHlp :: FuzzyTime -> String +showFuzzyTimeTrHlp ft@(FuzzyClock _ _ clock hour _ min style) + | min == 0 = "saat " ++ getHour Nom hour + | min `elem` [20..29] + && style == 2 = getHour Nom hour ++ " buçuğa " ++ getMin (30-min) ++ " var" + | min < 30 = getHour Acc hour ++ " " ++ getMin min ++ " geçiyor" + | min == 30 = if hour `mod` 12 == 0 then "saat yarım" else getHour Nom hour ++ " buçuk" + | min `elem` [31..40] + && style == 2 = getHour Nom hour ++ " buçuğu " ++ getMin (min-30) ++ " geçiyor" + | min > 30 = getHour Dat (nextFTHour ft) ++ " " ++ getMin (60-min) ++ " var" + | otherwise = "Oops, looks like it's " ++ show hour ++ ":" ++ show min ++ "." + where + getHour :: Case -> Int -> String + getHour c h + | h `mod` 12 == 0 = if clock==12 then numeralTr c 12 else numeralTr c h + | otherwise = numeralTr c h + getMin :: Int -> String + getMin m + | m `elem` [15, 45] = "çeyrek" + | otherwise = numeralTr Nom m + +-- FuzzyTimer + +showFuzzyTimeTrHlp (FuzzyTimer _ mins) + | mins > 0 = showHelper ++ " sonra" + | mins == 0 = "şimdi!" + | mins < 0 = "! " ++ showHelper ++ " önce !" + where + showHelper :: String + showHelper + | mm > 75 = numeralTr Nom hours ++ (if half then " buçuk" else "") ++ " saat" + | mm == 75 = "bir saat çeyrek" + | mm == 60 = "bir saat" + | mm == 45 = "üç çeyrek" + | mm == 30 = "yarım saat" + | mm == 15 = "bir çeyrek" + | mm >= 1 = numeralTr Nom mm ++ " dakika" + | otherwise = "Oops, it looks like there's " ++ show mins ++ " left." + hours :: Int + hours = round $ (fromIntegral mm :: Float) / 60 + mm :: Int + mm = abs mins + half :: Bool + half = mm `mod` 60 == 30 + + +-- numeralTr ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +data Case = Nom | Dat | Acc + + +numeralTr :: Case -> Int -> String +numeralTr c n + | n < 10 = numeralTrHelper1 c n + | n `mod` 10 == 0 = numeralTrHelper10 c (n `div` 10) + | otherwise = numeralTrHelper10 Nom (n `div` 10) ++ " " ++ numeralTrHelper1 c (n `mod` 10) + where + numeralTrHelper1 :: Case -> Int -> String + numeralTrHelper1 Nom i = ["bir", "iki", "üç", "dört", "beş", "altı", "yedi", "sekiz", "dokuz"] !! (i-1) + numeralTrHelper1 Dat i = ["bire", "ikiye", "üçe", "dörde", "beşe", "altıya", "yediye", "sekize", "dokuza"] !! (i-1) + numeralTrHelper1 Acc i = ["biri", "ikiyi", "üçü", "dördü", "beşi", "altıyı", "yediyi", "sekizi", "dokuzu"] !! (i-1) + numeralTrHelper10 :: Case -> Int -> String + numeralTrHelper10 Nom i = ["on", "yirmi", "otuz", "kırk", "elli"] !! (i-1) + numeralTrHelper10 Dat i = ["ona", "yirmiye", "otuza", "kırka", "elliye"] !! (i-1) + numeralTrHelper10 Acc i = ["onu", "yirmiyi", "otuzu", "kırkı", "elliyi"] !! (i-1) diff --git a/src/fuzzytime.1 b/src/fuzzytime.1 --- a/src/fuzzytime.1 +++ b/src/fuzzytime.1 @@ -1,4 +1,4 @@ -.TH fuzzytime 1 "April 26, 2011" "version 0.7.4" "A fuzzy clock and timer" +.TH fuzzytime 1 "April 26, 2011" "version 0.7.4.1" "A fuzzy clock and timer" .\" ------------------------------------------------------------------------------------- diff --git a/src/fuzzytime.hs b/src/fuzzytime.hs --- a/src/fuzzytime.hs +++ b/src/fuzzytime.hs @@ -161,7 +161,7 @@ -- | \[config] Help message for --time. confHelpClockTime :: String -confHelpClockTime = "Time to fuzzify as HH:MM; default current time." +confHelpClockTime = "Time to fuzzify as HH:MM; default current time." -- | \[config] Help message for --style. confHelpClockStyle :: String @@ -179,7 +179,7 @@ -- | \[config] Help message for summary confHelpSummary :: String -confHelpSummary = "A clock and timer that tell the time in a more human way.\nv0.7.4, 2011.04.26, kamil.stachowski@gmail.com, GPL3+" +confHelpSummary = "A clock and timer that tell the time in a more human way.\nv0.7.4.1, 2011.04.26, kamil.stachowski@gmail.com, GPL3+" -- check --------------------------------------------------------------------------------------------------------------------------------------------------------------------------