@@ -2,7 +2,6 @@

 (ql:quickload :clack-middleware-postmodern)

 (ql:quickload :cl-markup)

-(ql:quickload :cl-oid-connect)

 (ql:quickload :colors)

 (ql:quickload :lquery)

 (ql:quickload :plump)

@@ -16,6 +15,8 @@

 (ql:quickload :jonathan)

 (ql:quickload :cl-actors)

 (ql:quickload :simple-tasks)

+(ql:quickload :cl-oid-connect)

+(ql:quickload :fwoar.lisputils)

 (declaim (optimize (speed 0) (safety 3) (debug 2)))

@@ -24,11 +25,9 @@

 (push (cons "text" "rss+xml") drakma:*text-content-types*)

 ;(load "utils.lisp")

+(load "package.lisp")

 (load "rss.lisp")

-(defpackage :whitespace

-  (:use #:cl #:anaphora #:whitespace.utils #:whitespace.feeds.rss #:whitespace.tables))

-

 (in-package plump-dom)

 (defmethod serialize-object :around ((node element))

@@ -1,32 +1,29 @@

 ;;;; package.lisp

+(in-package :cl-user)

+

+(defpackage :whitespace.tables

+  (:use #:cl #:alexandria #:postmodern #:annot.class #:iterate #:fwoar.lisputils))

+

+(defpackage :whitespace.feeds.autodiscovery

+  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

+        #:whitespace.tables #:iterate #:fwoar.lisputils)

+  (:import-from anaphora it)

+  (:export :discover-feeds))

+

+(defpackage :whitespace.feeds.opml

+  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

+        #:whitespace.tables #:iterate #:fwoar.lisputils)

+  (:import-from anaphora it))

+

+(defpackage :whitespace.feeds.rss

+  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

+        #:whitespace.tables #:iterate #:fwoar.lisputils #:whitespace.feeds.autodiscovery)

+  (:import-from anaphora it)

+  (:export :get-elements :get-elements-by-tagname :extract-text :xml-text-bind :upsert-feed :deserialize

+           :deserialize-feed :deserialize-items :deserialize-item :subscribe-to-feed :store-feed

+           :make-rss-feed :make-rss-item))

+

+(defpackage :whitespace

+  (:use #:cl #:anaphora #:fwoar.lisputils #:whitespace.feeds.rss #:whitespace.tables))

-(defpackage :cl-oid-connect

-  (:use

-    #:cl

-    #:alexandria

-    #:anaphora

-    #:clack

-    #:cl-json

-    #:cljwt

-    #:cl-who

-    #:drakma

-    ;#:lack-middleware-session

-    #:iterate

-    #:ningle

-    #:lquery

-    #:plump

-    #:sheeple

-    #:whitespace.utils

-    )

-  (:export

-    #:redirect-if-necessary

-    #:def-route

-    #:require-login

-    #:oauth2-login-middleware

-    #:with-session

-    #:assoc-cdr

-    #:session ; private!!

-    #:vars-to-symbol-macrolets

-    #:initialize-oid-connect

-    ))

@@ -1,6 +1,12 @@

+(declaim (optimize (safety 3) (speed 0) (debug 3)))

+

+(load "tables.lisp")

+

 (in-package :cl-user)

+(cl-annot.syntax:enable-annot-syntax)

+

+

 (use-package :lquery)

-(declaim (optimize (safety 3) (speed 0) (debug 3)))

 (define-lquery-list-function where-attr (els attr &key is)

   (remove-if-not (lambda (y) (string= (plump:attribute y attr) is))

@@ -18,12 +24,6 @@

-(load "tables.lisp")

-

-(defpackage :whitespace.feeds.autodiscovery

-  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

-        #:whitespace.tables #:iterate #:whitespace.utils)

-  (:import-from anaphora it))

 (in-package #:whitespace.feeds.autodiscovery)

 (defun discover-feeds (doc)

@@ -31,32 +31,16 @@

    Returns a vector "

   (coerce

     (lquery:$ (inline doc)

-            "link"

-            (where-attr "rel" :is "alternate")

-            (combine (attr "href")

-                     (attr "type")))

+              "link"

+              (where-attr "rel" :is "alternate")

+              (combine (attr "href")

+                       (attr "type")))

     'list))

-(export 'discover-feeds)

-(defpackage :whitespace.feeds.opml

-  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

-        #:whitespace.tables #:iterate #:whitespace.utils)

-  (:import-from anaphora it))

 (in-package #:whitespace.feeds.opml)

+(in-package #:whitespace.feeds.rss)

-

-(in-package :cl-user)

-(defpackage :whitespace.feeds.rss

-  (:use #:cl #:alexandria #:postmodern #:lquery #:cl-syntax #:cl-annot.syntax #:cl-annot.class

-        #:whitespace.tables #:iterate #:whitespace.utils #:whitespace.feeds.autodiscovery)

-  (:import-from anaphora it))

-

-

-(in-package :whitespace.feeds.rss)

-(cl-annot.syntax:enable-annot-syntax)

-

-@export

 (defmacro get-elements (feed &optional (filter nil))

   (let ((feed-sym (gensym))

         (filter-lis `(lambda (x) (and (plump-dom:element-p x) ,@(loop for x in filter

@@ -64,15 +48,12 @@

     `(let ((,feed-sym ,feed))

        (remove-if-not ,filter-lis (plump:children ,feed-sym)))))

-@export

 (defmacro get-elements-by-tagname (feed tagname)

   `(get-elements ,feed ((lambda (x) (string= ,tagname (plump:tag-name x))))))

-@export

 (defmacro extract-text (selector &optional (default ""))

   `(or (lquery:$ ,selector (text) (node)) ,default))

-@export

 (defmacro xml-text-bind (syms &body body)

   "Bind the symbols passed in the second arg to the text of the matching

    elements in the document lquery has been initialized with and then run the

@@ -101,7 +82,6 @@

   ((item :accessor rss-item-item  :initarg :item)

    (title :accessor rss-item-title :initarg :title)

    (link :accessor rss-item-link :initarg :link)

-   (description-raw :accessor rss-item-description-raw :initarg :description-raw)

    (description :accessor rss-item-description :initarg :description)

    (category :accessor rss-item-category :initarg :category)

    (comments :accessor rss-item-comments :initarg :comments)

@@ -110,7 +90,6 @@

    (pub-date :accessor rss-item-pub-date :initarg :pub-date)

    (source :accessor rss-item-source  :initarg :source)))

-@export

 (defun make-rss-item (item fallback-date)

   (lquery:initialize item)

   (flet ((dehtml (h) (plump:text (plump:parse h)))

@@ -125,24 +104,22 @@

            (description-element (default-when content-encoded (emptyp content-encoded)

                                   (lquery:$ (children "description"))))

-           (description-raw (normalize-html

-                              (default-when description-element (emptyp description-element)

-                                (extract-text "description")))))

-           ;(enclosure) --- TODO: implement comment / enclosure handling

+           (description (normalize-html

+                          (default-when description-element (emptyp description-element)

+                            (extract-text "description")))))

+      ;(enclosure) --- TODO: implement comment / enclosure handling

       (xml-text-bind (title link guid pubdate source comments)

         (when (string= pubdate "")

           (setf pubdate fallback-date))

         (make-instance-from-symbols 'rss-item

                                     item title link

-                                    description-raw

-                                    (description (dehtml description-raw))

+                                    description

                                     (category (get-category-names (lquery:$ "category")))

                                     guid (pub-date pubdate) source comments)))))

-      ;(setf (rss-item-enclosure result) enclosure)      -- TODO: comment/enclosure . . .

+;(setf (rss-item-enclosure result) enclosure)      -- TODO: comment/enclosure . . .

-@export

 (defun make-rss-feed (feed)

   (lquery:initialize feed)

   (let* ((channel (lquery:$ "channel" (node)))

@@ -156,10 +133,10 @@

          (fallback-date (if (string= pub-date "") "2015-01-01 0:0:0+00" pub-date)))

     (format t "fallback-date: ~a~%" fallback-date)

     (xml-text-bind (title description)

-      (make-instance-from-symbols 'rss-feed

-                                  feed title link description channel fetch-url

-                                  (items (iterate (for it in-sequence items)

-                                                  (collecting (make-rss-item it fallback-date))))))))

+                   (make-instance-from-symbols 'rss-feed

+                                               feed title link description channel fetch-url

+                                               (items (iterate (for it in-sequence items)

+                                                               (collecting (make-rss-item it fallback-date))))))))

 ; These are the interface I'm planning to remove as duplicate

 (defserializer (rss-feed)

@@ -168,7 +145,7 @@

                   (collect item))))

 (defserializer (rss-item)

-  title link (description description-raw :bind-from description-raw) guid pub-date source)

+  title link (description :bind-from description) guid pub-date source)

 (defmethod jonathan:%to-json ((obj rss-feed))

   (jonathan:%to-json (serialize obj #'alexandria:alist-hash-table #'%json-pair-transform)))

@@ -186,19 +163,19 @@

 ; NOTE: this won't make dao objects for the _items_ when called on the feed!

 ; also NOTE: this _prefers_ the passed object

 (defmethod get-dao-for ((obj rss-feed) &optional linked-objects)

- (declare (ignore linked-objects))

- (with-slots (title link description fetch-url) obj

-   (get-id-for-object (rss_feed_store link) link

-     (make-instance-from-symbols 'rss_feed_store id title link description fetch-url (fetch-defaults t))) ))

+  (declare (ignore linked-objects))

+  (with-slots (title link description fetch-url) obj

+    (get-id-for-object (rss_feed_store link) link

+                       (make-instance-from-symbols 'rss_feed_store id title link description fetch-url (fetch-defaults t))) ))

 (defmethod get-dao-for ((obj rss-item) &optional feed)

- (with-slots (title link description-raw guid pub-date source) obj

-   (get-id-for-object (rss_item_store guid) guid

-     (let ((result (make-instance-from-symbols 'rss_item_store title link (description description-raw)

-                                 guid pub-date source feed (fetch-defaults t))))

-       (unless (null id)

-         (setf (ris-id result) id))

-       result))))

+  (with-slots (title link description guid pub-date source) obj

+    (get-id-for-object (rss_item_store guid) guid

+                       (let ((result (make-instance-from-symbols 'rss_item_store title link description

+                                                                 guid pub-date source feed (fetch-defaults t))))

+                         (unless (null id)

+                           (setf (ris-id result) id))

+                         result))))

 (defun get-and-possibly-store-feed (rss-feed)

   "Given an rss-feed, return the db's feed-id, persisting it if it doesn't already exist."

@@ -207,14 +184,13 @@

       (car anaphora:it) ;; The postmodern query returns a nested list

       (store-feed-dao (serialize rss-feed)))))

-@export

 (defun store-feed (doc)

   (postmodern:with-transaction ()

     (let ((rss-feed (make-rss-feed doc)))

       (values rss-feed

               (get-and-possibly-store-feed rss-feed)))))

-@export ; TODO: this should eventually take a username/userobject rather than ids . . .

+; TODO: this should eventually take a username/userobject rather than ids . . .

 (defun subscribe-to-feed (uid feedid)

   (postmodern:query

     (:insert-into 'subscriptions :set 'uid uid 'feedid feedid)))

@@ -222,19 +198,17 @@

 #|

 (:documentation

   "Store a serialized rss object into rhe database: the basic idea here is

-   that the quasi-quoted expression generates a form that would insert the

-   item and then we eval it.")

+  that the quasi-quoted expression generates a form that would insert the

+  item and then we eval it.")

 |#

-@export

 (defun deserialize-item (item)

   (let ((result (make-instance 'rss-item)))

-    (copy-slots (title link (description description-raw) comments enclosure guid pub-date source)

+    (copy-slots (title link description comments enclosure guid pub-date source)

                 item

                 result)

     result))

-@export

 (defun deserialize-items (feed-id)

   (let ((items (postmodern:query-dao 'rss_item_store

                                      (:order-by

@@ -243,14 +217,12 @@

                                        (:desc 'pub-date)))))

     (loop for item in items collect (deserialize-item item))))

-@export

 (defun deserialize-feed (feed)

   (let ((result (make-instance 'rss-feed)))

     (copy-slots (title link description fetch-url) feed result)

     (setf (rss-feed-items result) (deserialize-items (rfs-id feed)))

     result))

-@export

 (defun deserialize (&optional user-info)

   (default-when #() (not (null user-info))

     (let ((feeds

@@ -271,7 +243,6 @@

                        (collect (get-dao-for item (slot-value feed-dao 'id)))))))))

-@export

 (defun upsert-feed (rss-feed)

   (postmodern:ensure-transaction

     (destructuring-bind (feed items) (get-feed-from-dao rss-feed)

@@ -1,6 +1,4 @@

 (in-package :cl-user)

-(defpackage :whitespace.tables

-  (:use #:cl #:alexandria #:postmodern #:annot.class #:iterate #:whitespace.utils))

 (in-package :whitespace.tables)

 (cl-annot.syntax:enable-annot-syntax)

@@ -1,6 +1,3 @@

-(defpackage whitespace.utils

-  (:use #:cl #:alexandria #:iterate))

-

 (in-package whitespace.utils)

 (defun ensure-mapping (list)