Merge branch 'app'.

The app objects both makes the whole program sort of behave like one
class in some object oriented languages, with an implicitly (actually
hiddenly explicitly) passed 'app' argument to all methods. Multiple
concurrent apps should be supported, but is of now untested.

The app is also configured to lazily bind all its fields, which means
that almost all loading is now lazy!

1 files changed, 3 insertions, 52 deletions

diff --git a/module/vcomponent/load.scm b/module/vcomponent/load.scm
index 37d57b56..09dcd3c8 100644
--- a/module/vcomponent/load.scm
+++ b/module/vcomponent/load.scm
@@ -1,59 +1,10 @@
 (define-module (vcomponent load)
   :export (load-calendars load-calendars*)
   :use-module (util)
-  :use-module (util time)
   :use-module (util config)
-  :use-module (srfi srfi-1)
-  :use-module (datetime)
-  :use-module (datetime util)
-  :use-module (srfi srfi-41)
-  :use-module (srfi srfi-41 util)
-  ;; :use-module (parameters)
-  ;; :use-module (vcomponent)
-  :use-module (vcomponent base)
-  :use-module ((vcomponent parse) :select (parse-cal-path))
-  :use-module ((vcomponent recurrence) :select (generate-recurrence-set repeating?))
-  :use-module ((vcomponent datetime) :select (ev-time<?)))
+  :use-module ((vcomponent parse) :select (parse-cal-path)))
 
 (define-config calendar-files '() "" list?)
 
-(define-public (calculate-recurrence-set regular repeating)
- (interleave-streams
-  ev-time<?
-  (cons (list->stream regular)
-        (map generate-recurrence-set repeating)
-        )))
-
-;; Reads all calendar files from disk, generate recurence-sets for all repeating events,
-;; and returns a list of calendars, and a stream of all events "ready" for display.
-(define* (load-calendars #:optional (calendar-files (get-config 'calendar-files)))
-  (report-time! "Parsing ~a calendars" (length calendar-files))
-  (let* ((calendars regular repeating (load-calendars* calendar-files)))
-    (report-time! "Calendars loaded, interleaving and reccurring")
-    (values
-     calendars
-     (calculate-recurrence-set regular repeating))))
-
-;; Basic version, loads calendrs, sorts the events, and returns
-;; regular and repeating events separated from each other.
-;; 
-;; (list string) → (list calendar), (list event), (list event)
-(define* (load-calendars* #:optional (calendar-files (get-config 'calendar-files)))
-
-  (define calendars (map parse-cal-path calendar-files))
-  (define events (concatenate
-                  ;; TODO does this drop events?
-                  (map (lambda (cal) (filter (lambda (o) (eq? 'VEVENT (type o)))
-                                        (children cal)))
-                       calendars)))
-
-  (report-time! "Parse done, partitioning...")
-  (let* ((repeating regular (partition repeating? events)))
-
-    (report-time! "Sorting")
-    ;; NOTE There might be instances where we don't care if the
-    ;; collection if sorted, but for the time beieng it's much
-    ;; easier to always sort it.
-    (values calendars
-            (sort*! regular   date/-time<? (extract 'DTSTART))
-            (sort*! repeating date/-time<? (extract 'DTSTART)))))
+(define* (load-calendars calendar-files)
+  (map parse-cal-path calendar-files))