nuttycom/aftok - Change SCXG6TJWYIPRUMT27KGKIIF6FYKTUTY74UNZ2FQTT63XZ6HIF3AAC

Make log reduction safer in presence of overlapping events.

Created by Kris Nuttycombe on April 22, 2015

SCXG6TJWYIPRUMT27KGKIIF6FYKTUTY74UNZ2FQTT63XZ6HIF3AAC

Dependencies

In channels

main

Change contents

Replacement in lib/Quixotic/Interval.hs at line 4 [5.1422]
∅:D[3.5263] → [4.3:44]
B:BD[5.1447] → [4.3:44]
```
  ( Interval, interval, start, end, ilen
```
[3.5263]
[6.3192]
```
  ( Interval(Interval), interval, start, end, ilen
```
Insertion in lib/Quixotic/Interval.hs at line 6 [5.1422]
[6.3228]
[5.1483]
```
  , containsInclusive
```
Replacement in lib/Quixotic/Interval.hs at line 21 [5.1422]
∅:D[7.635] → [5.1634:1681]
∅:D[8.1839] → [5.1634:1681]
B:BD[5.1634] → [5.1634:1681]
```
                         } deriving (Show, Eq)
```
[7.635]
[8.1840]
```
                         } deriving (Show, Eq, Ord)
```

Insertion in lib/Quixotic/Interval.hs at line 26 [5.1422]

[9.63]

[5.1744]


containsInclusive :: C.UTCTime -> Interval -> Bool
containsInclusive t (Interval s e) = t >= s && t <= e

Replacement in lib/Quixotic/TimeLog.hs at line 46 [10.846]

B:BD[2.124] → [2.124:192]

  compare StartWork StopWork = LT
  compare StopWork StartWork = GT

[2.124]

[2.192]

  compare StartWork StopWork = GT
  compare StopWork StartWork = LT

Insertion in lib/Quixotic/TimeLog.hs at line 68 [10.846]

[10.1407]

[11.540]

instance Ord WorkEvent where
  compare a b = 
    let cv x = (x ^. eventTime, x ^. eventType)
    in compare (cv a) (cv b)

Replacement in lib/Quixotic/TimeLog.hs at line 120 [10.846]
∅:D[2.492] → [12.378:434]
B:BD[13.88] → [12.378:434]
```
type RawIndex = Map BtcAddr ([LogEntry], [LogInterval])
```
[2.492]
[7.982]
```
type RawIndex = Map BtcAddr [Either WorkEvent Interval]
```

Replacement in lib/Quixotic/TimeLog.hs at line 160 [10.846]

B:BD[14.4420] → [2.653:778]

  let sortedEntries :: Heap LogEntry
      sortedEntries = F.foldr H.insert H.empty $ logEntries
      rawIndex :: RawIndex

[14.4420]

[2.778]

  let sortedEntries = F.foldr H.insert H.empty $ logEntries

Replacement in lib/Quixotic/TimeLog.hs at line 163 [10.846]

B:BD[2.845] → [2.845:945]

      accum k (_, l) m = case nonEmpty l of 
        Just l' -> MS.insert k (workInterval <$> l') m

[2.845]

[2.945]

      accum k l m = case nonEmpty (rights l) of 
        Just l' -> MS.insert k l' m

Replacement in lib/Quixotic/TimeLog.hs at line 170 [10.846]

B:BD[15.2117] → [14.4573:4654]

B:BD[14.4654] → [2.1026:1069]

appendLogEntry idx entry = 
  let acc = reduceToIntervals $ pushEntry entry idx 
  in  MS.insert (entry ^. btcAddr) acc idx

[15.2117]

[15.2252]

appendLogEntry idx (LogEntry k ev) = 
  let combine (WorkEvent StartWork t _) (WorkEvent StopWork t' _)  | t' > t = Right $ Interval t t'
      combine (e1 @ (WorkEvent StartWork _ _)) (e2 @ (WorkEvent StartWork _ _)) = Left $ max e1 e2
      combine (e1 @ (WorkEvent StopWork  _ _)) (e2 @ (WorkEvent StopWork  _ _)) = Left $ min e1 e2
      combine _ e2 = Left e2

Replacement in lib/Quixotic/TimeLog.hs at line 176 [10.846]

B:BD[15.2253] → [2.1070:1212]

∅:D[2.1212] → [15.2253:2318]

B:BD[15.2253] → [15.2253:2318]

B:BD[15.2318] → [14.4695:4779]

{-|
 - Find the set of accumulated log intervals and log entries
 - for a given BTC address, and concatenate the entry to the entry list.
 -}
pushEntry :: LogEntry -> RawIndex -> ([LogEntry], [LogInterval])
pushEntry entry = first (entry :) . MS.findWithDefault ([], []) (entry ^. btcAddr)

[15.2253]

[9.869]

      ivals = case MS.lookup k idx of
        Just (Left ev' : xs) -> combine ev' ev : xs
        Just xs -> Left ev : xs
        Nothing -> Left ev : []

Replacement in lib/Quixotic/TimeLog.hs at line 181 [10.846]

B:BD[9.870] → [4.692:772]

B:BD[4.772] → [16.4024:4147]

∅:D[16.4147] → [17.2859:2916]

∅:D[14.4899] → [17.2859:2916]

B:BD[17.2859] → [17.2859:2916]

∅:D[17.2916] → [11.1086:1131]

B:BD[15.2482] → [11.1086:1131]

reduceToIntervals :: ([LogEntry], [LogInterval]) -> ([LogEntry], [LogInterval])
reduceToIntervals ((LogEntry addr (WorkEvent StopWork end' _)) : (LogEntry _ (WorkEvent StartWork start' _)) : xs, acc) = 
  (xs, (LogInterval addr (interval start' end')) : acc) 
reduceToIntervals misaligned = 
  misaligned

[9.870]

[18.22]

  in  MS.insert k ivals idx

Replacement in test/Quixotic/TimeLogSpec.hs at line 33 [10.3665]

∅:D[2.1990] → [7.3566:3589]

B:BD[7.3566] → [7.3566:3589]

B:BD[7.3589] → [2.1991:2045]

    delta <- arbitrary
    pure $ I.interval startTime (startTime .+^ delta)

[2.1990]

[2.2045]

    delta <- arbitrary :: Gen (Positive T.NominalDiffTime)
    pure $ I.interval startTime (startTime .+^ getPositive delta)

Replacement in test/Quixotic/TimeLogSpec.hs at line 52 [10.3665]

B:BD[2.2516] → [2.2516:2568]

            , parseISO8601 "2014-02-12T00:12:00Z" ]

[2.2516]

[10.4253]

            , parseISO8601 "2014-01-01T00:12:00Z" ]

Replacement in test/Quixotic/TimeLogSpec.hs at line 56 [10.3665]

B:BD[2.2674] → [2.2674:2726]

∅:D[19.904] → [15.2686:2687]

∅:D[2.2726] → [15.2686:2687]

∅:D[7.3974] → [15.2686:2687]

B:BD[10.4380] → [15.2686:2687]

B:BD[15.2687] → [2.2727:2773]

∅:D[2.2773] → [19.944:1004]

B:BD[19.944] → [19.944:1004]

B:BD[19.1004] → [2.2774:2973]

            , parseISO8601 "2014-02-12T00:18:00Z" ]
          testLogEntries :: NonEmpty LogEntry
          testLogEntries = do
            addr <- testAddrs
            (start', end') <- L.zip starts ends
            L.fromList [ LogEntry addr (WorkEvent StartWork start' Nothing)
                       , LogEntry addr (WorkEvent StopWork end' Nothing) ]

[2.2674]

[20.417]

            , parseISO8601 "2014-01-01T00:18:00Z" ]

Replacement in test/Quixotic/TimeLogSpec.hs at line 59 [10.3665]
B:BD[2.3022] → [2.3022:3063]
```
          testIntervals = L.reverse $ do
```
[2.3022]
[19.1197]
```
          testIntervals = do
```

Insertion in test/Quixotic/TimeLogSpec.hs at line 63 [10.3665]

[2.3173]


          testLogEntries :: NonEmpty LogEntry
          testLogEntries = do
            (LogInterval addr (Interval start' end')) <- testIntervals
            L.fromList [ LogEntry addr (WorkEvent StartWork start' Nothing)
                       , LogEntry addr (WorkEvent StopWork end' Nothing) ]

Insertion in test/Quixotic/TimeLogSpec.hs at line 70 [10.3665]

[2.3174]

          expected' = fromListWith (<>) . L.toList $ (intervalBtcAddr &&& pure . workInterval) <$> testIntervals

Replacement in test/Quixotic/TimeLogSpec.hs at line 72 [10.3665]

B:BD[2.3206] → [2.3206:3330]

          expected = WorkIndex . fromListWith (<>) . L.toList $ (intervalBtcAddr &&& pure . workInterval) <$> testIntervals

[2.3206]

[15.2824]

          expected = WorkIndex $ fmap (L.reverse . L.sort) expected'

Replacement in test/Quixotic/TimeLogSpec.hs at line 77 [10.3665]
B:BD[2.3444] → [2.3444:3460]
```
      \widx -> 
```
[2.3444]
[2.3460]
```
      \(WorkIndex widx) -> 
```

Replacement in test/Quixotic/TimeLogSpec.hs at line 82 [10.3665]

B:BD[2.3717] → [2.3717:3832]

            logEntries = foldrWithKey acc [] (widx ^. _WorkIndex)
        in  workIndex logEntries `shouldBe` widx

[2.3717]

[7.3975]

            logEntries = foldrWithKey acc [] widx
        in  workIndex logEntries `shouldBe` (WorkIndex $ fmap (L.reverse . L.sort) widx)