Duration

Summary: Duration dimension for Croatian.

Reviewed By: niteria

Differential Revision: D4947983

fbshipit-source-id: 8e55a7e

Duckling/Dimensions/HR.hs

@@ -14,6 +14,7 @@ import Duckling.Dimensions.Types
 
 allDimensions :: [Some Dimension]
 allDimensions =
-  [ This Numeral
+  [ This Duration
+  , This Numeral
   , This Ordinal
   ]

Duckling/Duration/HR/Rules.hs

@@ -0,0 +1,156 @@
+-- Copyright (c) 2016-present, Facebook, Inc.
+-- All rights reserved.
+--
+-- This source code is licensed under the BSD-style license found in the
+-- LICENSE file in the root directory of this source tree. An additional grant
+-- of patent rights can be found in the PATENTS file in the same directory.
+
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Duckling.Duration.HR.Rules
+  ( rules ) where
+
+import Control.Monad (join)
+import Data.Maybe
+import Data.String
+import Data.Text (Text)
+import Prelude
+import qualified Data.Text as Text
+
+import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers
+import Duckling.Duration.Types (DurationData (..))
+import Duckling.Numeral.Helpers (parseInt)
+import Duckling.Numeral.Types (NumeralData(..))
+import Duckling.Regex.Types
+import Duckling.Types
+import qualified Duckling.Duration.Types as TDuration
+import qualified Duckling.Numeral.Types as TNumeral
+import qualified Duckling.TimeGrain.Types as TG
+
+ruleExactlyDuration :: Rule
+ruleExactlyDuration = Rule
+  { name = "exactly <duration>"
+  , pattern =
+    [ regex "to(c|\x010d)no"
+    , dimension Duration
+    ]
+  , prod = \tokens -> case tokens of
+      (_:token:_) -> Just token
+      _ -> Nothing
+  }
+
+ruleIntegerAndAnHalfHours :: Rule
+ruleIntegerAndAnHalfHours = Rule
+  { name = "<integer> and an half hours"
+  , pattern =
+    [ Predicate isNatural
+    , regex "i pol?a?"
+    ]
+  , prod = \tokens -> case tokens of
+      (Token Numeral (NumeralData {TNumeral.value = v}):_) ->
+        Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v
+      _ -> Nothing
+  }
+
+ruleIntegerMoreUnitofduration :: Rule
+ruleIntegerMoreUnitofduration = Rule
+  { name = "<integer> more <unit-of-duration>"
+  , pattern =
+    [ Predicate isNatural
+    , regex "vi(s|\x0161)e|manje"
+    , dimension TimeGrain
+    ]
+  , prod = \tokens -> case tokens of
+      (Token Numeral (NumeralData {TNumeral.value = v}):
+       _:
+       Token TimeGrain grain:_) ->
+         Just . Token Duration . duration grain $ floor v
+      _ -> Nothing
+  }
+
+ruleQuarterOfAnHour :: Rule
+ruleQuarterOfAnHour = Rule
+  { name = "quarter of an hour"
+  , pattern =
+    [ regex "((1/4|frtalj|kvarat|(c|\x010d)etvrt)\\s?(h|sata)?)"
+    ]
+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 15
+  }
+
+ruleAboutDuration :: Rule
+ruleAboutDuration = Rule
+  { name = "about <duration>"
+  , pattern =
+    [ regex "(oko|otprilike|odokativno)"
+    , dimension Duration
+    ]
+  , prod = \tokens -> case tokens of
+      (_:token:_) -> Just token
+      _ -> Nothing
+  }
+
+ruleNumbernumberHours :: Rule
+ruleNumbernumberHours = Rule
+  { name = "number.number hours"
+  , pattern =
+    [ regex "(\\d+)\\.(\\d+)"
+    , regex "sat(i|a)?"
+    ]
+  , prod = \tokens -> case tokens of
+      (Token RegexMatch (GroupMatch (h:d:_)):_) -> do
+        hh <- parseInt h
+        dec <- parseInt d
+        let divisor = floor $ (fromIntegral (10 :: Integer) :: Float) **
+                        fromIntegral (Text.length d - 1)
+            numerator = fromIntegral $ 6 * dec
+        Just . Token Duration . duration TG.Minute $
+          60 * hh + quot numerator divisor
+      _ -> Nothing
+  }
+
+ruleIntegerUnitofduration :: Rule
+ruleIntegerUnitofduration = Rule
+  { name = "<integer> <unit-of-duration>"
+  , pattern =
+    [ Predicate isNatural
+    , dimension TimeGrain
+    ]
+  , prod = \tokens -> case tokens of
+      (Token Numeral (NumeralData {TNumeral.value = v}):
+       Token TimeGrain grain:
+       _) -> Just . Token Duration . duration grain $ floor v
+      _ -> Nothing
+  }
+
+ruleThreequartersOfAnHour :: Rule
+ruleThreequartersOfAnHour = Rule
+  { name = "three-quarters of an hour"
+  , pattern =
+    [ regex "((3/4|tri-?frtalja|tri-?kvarat|tri-?(c|\x010d)etvrt(ine)?)\\s?(h|sata)?)"
+    ]
+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 45
+  }
+
+ruleHalfAnHour :: Rule
+ruleHalfAnHour = Rule
+  { name = "half an hour"
+  , pattern =
+    [ regex "(1/2\\s?(h|sata)?|pol?a? sata)"
+    ]
+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 30
+  }
+
+rules :: [Rule]
+rules =
+  [ ruleAboutDuration
+  , ruleExactlyDuration
+  , ruleHalfAnHour
+  , ruleIntegerAndAnHalfHours
+  , ruleIntegerMoreUnitofduration
+  , ruleIntegerUnitofduration
+  , ruleNumbernumberHours
+  , ruleQuarterOfAnHour
+  , ruleThreequartersOfAnHour
+  ]

Duckling/Rules/HR.hs

@@ -16,13 +16,14 @@ module Duckling.Rules.HR
 import Duckling.Dimensions.Types
 import Duckling.Types
 import qualified Duckling.AmountOfMoney.HR.Rules as AmountOfMoney
+import qualified Duckling.Duration.HR.Rules as Duration
 import qualified Duckling.Numeral.HR.Rules as Numeral
 import qualified Duckling.Ordinal.HR.Rules as Ordinal
 import qualified Duckling.TimeGrain.HR.Rules as TimeGrain
 
 rules :: Some Dimension -> [Rule]
 rules (This Distance) = []
-rules (This Duration) = []
+rules (This Duration) = Duration.rules
 rules (This Numeral) = Numeral.rules
 rules (This Email) = []
 rules (This AmountOfMoney) = AmountOfMoney.rules

duckling.cabal

@@ -189,6 +189,7 @@ library
                      , Duckling.Duration.GA.Corpus
                      , Duckling.Duration.GA.Rules
                      , Duckling.Duration.HE.Rules
+                     , Duckling.Duration.HR.Rules
                      , Duckling.Duration.IT.Rules
                      , Duckling.Duration.JA.Corpus
                      , Duckling.Duration.KO.Corpus