new file mode 100644

@@ -0,0 +1 @@

+This is the stub README.txt for the "whitespace.rss" project.

new file mode 100644

@@ -0,0 +1,78 @@

+(ql:quickload :parenscript)

+

+(defpackage :angular

+  (:use :parenscript :cl)

+  (:export main))

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

+

+(in-package :angular)

+

+(defpsmacro macros (&body body)

+  `(lisp (progn

+           ,@(loop for form in body

+                   collect `(defpsmacro ,@form))

+           "")))

+

+

+(defmacro+ps scope-vars (&rest bindings)

+  `(progn ,@(loop for (n v) in bindings collect `(scope-var ,n ,v))))

+

+(defmacro+ps scope-var (name value)

+  `(setf ($s ,name) ,value))

+

+(defmacro+ps resource (name url params &body body)

+  `(var ,name

+        ($resource ,url ,(cons 'create params)

+                   ,@(loop for (name form) in body

+                           collect (list 'create name (cons 'create form))))))

+

+(defmacro+ps scope-function (name arguments &body body)

+  `(scope-var ,name (lambda ,arguments

+                      ,@body)))

+

+(defmacro+ps $s (&rest values) `(chain $scope ,@values))

+

+(defun build-lambda (dependencies body)

+  `(list ,@(mapcar #'symbol-to-js-string dependencies)

+         (lambda ,(loop for x in dependencies

+                        collect x)

+           ,@body

+           nil)))

+

+

+; This is just for slimv's sake

+(defmacro defcontroller (name dependencies &body body)

+  (declare (ignore name dependencies body)))

+

+(defpsmacro def-module (module-name dependencies &body body)

+  `(macrolet ((defcontroller (name dependencies &body body)

+                (let ((dependencies (cons '$scope dependencies)))

+                  (list 'chain ',module-name `(controller ,(symbol-to-js-string name)

+                                                          ,(build-lambda dependencies body))))))

+     (progn (var ,module-name ((@ angular module) ,(symbol-to-js-string module-name) ,dependencies))

+            ,@body)))

+

+(defmacro+ps select-> (selector)

+  `(chain document (query-selector ,selector)))

+

+(defmacro+ps select->element (selector)

+  `(chain angular (element (select-> ,selector))))

+

+

+(defmacro+ps ng-ajax (mthd endpoint data resultS &body callback)

+  `(chain $http

+          (,mthd ,endpoint ,data)

+          (success (lambda (,resultS)

+                     ,@callback))))

+

+(defun translate-file (infile outfile)

+  (let ((*JS-TARGET-VERSION* 1.9))

+    (with-open-file (o outfile :direction :output :if-exists :supersede)

+      (with-open-file (i infile :direction :input)

+        (write-line (ps-compile-file i) o)))))

+

+(defun main (args)

+  (in-package :angular)

+  (apply #'translate-file (cdr args)))

+

+

@@ -16,7 +16,8 @@

                 :lass

                 :lquery

                 :plump

-                :cl-who)

+                :cl-who

+                :postmodern)

   :serial t

   :components ((:file "package")

                (:file "cl-oid-connect")))

@@ -93,7 +93,7 @@

                            :parameters `(("access_token" . ,access-token))))))

 (defmacro string-assoc (key alist) `(assoc ,key ,alist :test #'equal))

-(defmacro assoc-cdr (key alist) `(cdr (assoc ,key ,alist)))

+(defmacro assoc-cdr (key alist &optional (test '#'eql)) `(cdr (assoc ,key ,alist :test ,test)))

 (defun discover-endpoints (schema discovery-doc-url &key (gat nil gat-p) (gui nil gui-p))

   (let ((discovery-document (cl-json:decode-json-from-string (drakma:http-request discovery-doc-url))))

@@ -145,12 +145,20 @@

          ,then

          ,else))))

-(defmacro require-login (&body body)

+(defmacro check-login (&body body)

   (alexandria:with-gensyms (session)

     `(let ((,session (context :session)))

        (if (not (eql nil (gethash :userinfo ,session)))

+         (progn ,@body)

          (progn

-           ,@body)

+           (setf (gethash :next-page ,session) (lack.request:request-path-info *request*))

+           '(401 () "Unauthorized"))))))

+

+(defmacro require-login (&body body)

+  (alexandria:with-gensyms (session)

+    `(let ((,session (context :session)))

+       (if (not (eql nil (gethash :userinfo ,session)))

+         (progn ,@body)

          (progn

            (setf (gethash :next-page ,session) (lack.request:request-path-info *request*))

            '(302 (:location "/login")))))))

@@ -205,24 +213,23 @@

                            ))))

-(defun oauth2-login-middleware (&key google-info facebook-info)

-  (let ((clack-env nil))

-    (lambda (app)

-      (in-package :cl-oid-connect)

-      (load-facebook-info facebook-info)

-      (load-goog-endpoint-schema)

-      (load-google-info google-info)

+(defun oauth2-login-middleware (&key google-info facebook-info (login-callback #'identity))

+  (lambda (app)

+    ;(in-package :cl-oid-connect)

+    (load-facebook-info facebook-info)

+    (load-goog-endpoint-schema)

+    (load-google-info google-info)

-      (def-route ("/login/google" (params) :app app)

-        (with-context-variables (session)

-          (let ((state (gen-state 36)))

-            (setf (gethash :state session) state)

-            (with-endpoints *goog-endpoint-schema*

-              (setf (gethash :endpoint-schema session) *goog-endpoint-schema*)

-              (multiple-value-bind (content rcode headers) (do-auth-request *goog-endpoint-schema* state)

-                (if (< rcode 400)

-                  `(302 (:location ,(cdr (assoc :location headers))))

-                  content))))))

+    (def-route ("/login/google" (params) :app app)

+      (with-context-variables (session)

+        (let ((state (gen-state 36)))

+          (setf (gethash :state session) state)

+          (with-endpoints *goog-endpoint-schema*

+            (setf (gethash :endpoint-schema session) *goog-endpoint-schema*)

+            (multiple-value-bind (content rcode headers) (do-auth-request *goog-endpoint-schema* state)

+              (if (< rcode 400)

+                `(302 (:location ,(cdr (assoc :location headers))))

+                content))))))

     (def-route ("/login/facebook" (params) :app app)

@@ -246,10 +253,13 @@

                          (let* ((a-t (get-access-token *goog-endpoint-schema* code))

                                 (access-token (assoc-cdr :access--token a-t)) ;; Argh

                                 (id-token (assoc-cdr :id--token a-t))

-                                (decoded (cljwt:decode id-token :fail-if-unsupported nil)))

-                           (setf (gethash :idtoken session) (get-user-info *goog-endpoint-schema* id-token))

-                           (setf (gethash :accesstoken session) (get-user-info *goog-endpoint-schema* access-token))

-                           (setf (gethash :userinfo session) (get-user-info *goog-endpoint-schema* access-token))

+                                (decoded (cljwt:decode id-token :fail-if-unsupported nil))

+                                (user-info (get-user-info *goog-endpoint-schema* access-token)))

+                           (setf (gethash :idtoken session) id-token)

+                           (setf (gethash :accesstoken session) access-token)

+                           (setf (gethash :userinfo session) user-info)

+                           (setf (gethash :app-user session)

+                                 (funcall login-callback user-info decoded access-token))

                            '(302 (:location "/"))

                            )))

                      '(403 '() "Out, vile imposter!"))))

@@ -262,8 +272,13 @@

           (check-state received-state

                        (with-context-variables (session)

                          (let* ((a-t (get-access-token *fbook-endpoint-schema* code))

-                                (id-token (assoc-cdr :access--token a-t)))

-                           (setf (gethash :userinfo session) (get-user-info *fbook-endpoint-schema* id-token))

+                                (id-token (assoc-cdr :access--token a-t))

+                                (user-info (get-user-info *fbook-endpoint-schema* id-token)))

+                           (setf (gethash :accesstoken session) a-t)

+                           (setf (gethash :userinfo session) user-info)

+                           (setf (gethash :idtoken session) id-token)

+                           (setf (gethash :app-user session) (funcall login-callback user-info id-token a-t))

+

                            '(302 (:location "/"))))

                        '(403 '() "Out, vile imposter!")))))

@@ -278,7 +293,7 @@

         (setf (gethash :userinfo session) nil)

         '(302 (:location "/"))))

-    app)))

+    app))

 (defmacro redirect-if-necessary (sessionvar &body body)

@@ -1 +1 @@

-Subproject commit b203d4f1b4abdc5c72582d6e6465e7eebe5fec0e

+Subproject commit 15a9ca8dd67e8033bd62b559ffee86606fc67e9d

@@ -5,128 +5,51 @@

 (ql:quickload :lquery)

 (ql:quickload :plump)

 (ql:quickload :postmodern)

+(ql:quickload :sxql)

+(ql:quickload :clack-middleware-postmodern)

+(ql:quickload :dexador)

+(ql:quickload :spinneret)

+(ql:quickload :ubiquitous)

+(ql:quickload :iterate)

+(ql:quickload :jonathan)

+

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

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

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

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

-(lquery:define-lquery-list-function tag-name (nodes &rest tags)

-  "Manipulate elements on the basis of there tag-name.

-   With no arguments, return their names else return

-   the corresponding tags."

-  (if (null tags)

-    (map 'vector #'plump:tag-name nodes)

-    (apply #'vector

-           (loop for node across nodes

-                 if (find (plump:tag-name node) tags :test #'string=)

-                 collect node))))

+(defpackage whitespace.utils

+  (:use #:cl))

+(load "utils.lisp")

-(defparameter *app* (make-instance 'ningle:<app>))

+(defpackage :whitespace.tables

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

+(load "tables.lisp")

+

+(defpackage :whitespace.rss

+  (:shadow "to-json")

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

+        #:whitespace.tables #:iterate))

+(load "rss.lisp")

+

+(defpackage :whitespace

+  (:use #:cl #:whitespace.utils #:whitespace.rss #:whitespace.tables))

+

+(in-package plump-dom)

-(defclass rss-feed ()

-  ((feed :accessor rss-feed-feed :initarg :feed)

-   (channel :accessor rss-feed-channel)

-   (title :accessor rss-feed-title)

-   (link :accessor rss-feed-link)

-   (description :accessor rss-feed-description)

-   (items :accessor rss-feed-items)))

-

-(defgeneric serialize (cls))

-

-

-(defclass rss-item ()

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

-   (title :accessor rss-item-title)

-   (link :accessor rss-item-link)

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

-   (description :accessor rss-item-description)

-   (category :accessor rss-item-category)

-   (comments :accessor rss-item-comments)

-   (enclosure :accessor rss-item-enclosure)

-   (guid :accessor rss-item-guid)

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

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

-

-(defmethod serialize ((obj rss-feed))

-  (postmodern:make-dao 'rss)

-  )

-

-(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

-                                                                      collect `(funcall ,x x))))))

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

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

-

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

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

-

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

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

-

-(defun make-rss-item (item)

-  (lquery:initialize item)

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

-         (get-category-names (it) ;;; TODO: simplify this---Ask Shinmera on IRC

-           (if (not (equalp #() it))

-             (map 'vector

-                  (lambda (x) (plump:text (elt (plump:children x) 0)))

-                  it)

-             #())))

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

-           (title (extract-text "title"))

-           (link (extract-text "link"))

-           (content-encoded (lquery:$ (children) (tag-name "content:encoded")))

-

-           (description-element (if (= 0 (length content-encoded))

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

-                                  content-encoded))

-

-           (description-raw (let ((plump:*html-tags*)

-                                  (ss (make-string-output-stream)))

-                              (if (= 0 (length description-element))

-                                ""

-                                (progn

-                                  (plump:serialize (plump:parse (plump:text (elt description-element 0))) ss)

-                                  (get-output-stream-string ss)))))

-

-           (description-munged (dehtml (extract-text "description")))

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

-           ;(comments)

-           ;(enclosure)

-           (guid (extract-text "aaguid"))

-           (pub-date (extract-text "pubDate"))

-           (source (extract-text "source")))

-      (setf (rss-item-title result) title)

-      (setf (rss-item-link result) link)

-      (setf (rss-item-description-raw result) description-raw)

-      (setf (rss-item-description result) description-munged)

-      (setf (rss-item-category result) category)

-      ;(setf (rss-item-comments result) comment)

-      ;(setf (rss-item-enclosure result) enclosur)

-      (setf (rss-item-guid result) guid)

-      (setf (rss-item-pub-date result) pub-date)

-      (setf (rss-item-source result) source)

-      result)))

-

-(defun make-rss-feed (feed)

-  (lquery:initialize feed)

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

-         (channel (lquery:$ "channel" (node)))

-         (title (lquery:$  "title" (text) (node)))

-         (link (lquery:$ "link" (text) (node)))

-         (description (lquery:$ "description" (text) (node)))

-         (items (lquery:$ "item")))

-    (setf (rss-feed-channel result) channel)

-    (setf (rss-feed-title result) title)

-    (setf (rss-feed-link result) link)

-    (setf (rss-feed-description result) description)

-    (setf (rss-feed-items result)

-          (loop for it across items

-                collect (make-rss-item it)))

-    result))

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

+  (when (string= (tag-name node) "iframe")

+    (make-text-node node))

+  (call-next-method))

+(in-package :whitespace)

+(ubiquitous:restore :whitespace)

+

+

+(defparameter *app* (make-instance 'ningle:<app>))

+

 (cl-oid-connect:def-route ("/login" (params) :app *app*)

   (cl-who:with-html-output-to-string (s)

     (:html

@@ -139,42 +62,35 @@

           :class "login-button google"

           (:a :href "/login/google" "Google"))))))

-(defparameter *feed-urls*

-  #(

-    "http://www.reddit.com/r/lisp.rss"

-    "http://www.reddit.com/r/scheme.rss"

-    "http://www.reddit.com/r/prolog.rss"

-    "http://www.reddit.com/r/haskell.rss"

-    "http://www.reddit.com/r/talesfromtechsupport.rss"

-    "https://drmeister.wordpress.com/feed/rss"

-    ))

-(let

-  ((plump-parser:*tag-dispatchers* plump-parser:*xml-tags*))

-  (defparameter *docs* (map 'vector

-                            (lambda (x)

-                              (format t "~a~%" x)

-                              (unwind-protect (plump-parser:parse

-                                                (drakma:http-request x))))

-                            *feed-urls*)))

+(handler-bind ((warning #'sb-ext::muffle-warning))

+  (let* ((feed-urls (ubiquitous:value 'feed 'urls))

+         (plump-parser:*tag-dispatchers* plump:*xml-tags*)

+         (docs (map 'vector (lambda (x) (plump:parse (drakma:http-request x))) feed-urls)))

+    (defparameter *feeds* (map 'vector (lambda (x) (make-rss-feed x)) docs))))

-(defparameter *feeds* (map 'vector (lambda (x) (unwind-protect (make-rss-feed x))) *docs*))

+(defparameter *db-connection-info* (ubiquitous:value 'db 'connection 'info))

+(defmacro def-markup (name (&rest args) &body body)

+  `(defmacro ,name ,args

+     (alexandria:once-only ,args

+      `(cl-markup:markup

+         ,,@body))))

 (defmacro item-markup (item)

-  (alexandria:with-gensyms (item-s)

-    `(let ((,item-s ,item))

+  (alexandria:once-only (item)

+    `(let ((,item ,item))

        (cl-markup:markup

          (:li :class "link closed"

           (:section :class "link-header"

-           (:h4 (rss-item-title ,item-s))

+           (:h4 (rss-item-title ,item))

            (:p :class "link-info"

-            (:a :target "_blank" :href (rss-item-link ,item-s)

-             (:span :class "link-url" (rss-item-link ,item-s)))

-            (:span :class "link-date") (rss-item-pub-date ,item-s)))

+            (:a :target "_blank" :href (rss-item-link ,item)

+             (:span :class "link-url" (rss-item-link ,item)))

+            (:span :class "link-date") (rss-item-pub-date ,item)))

           (:section :class "link-content"

            (:div

-             (cl-markup:raw (rss-item-description-raw ,item-s)))))))))

+             (cl-markup:raw (rss-item-description-raw ,item)))))))))

 (defmacro feed-markup (feed-v fc-v)

   (alexandria:with-gensyms (feed fc)

@@ -186,59 +102,120 @@

            (:h2 (rss-feed-title ,feed))

            (:h3 (rss-feed-description ,feed)))

           (:ul :class "post-list"

-           (loop for item in (rss-feed-items ,feed)

-                 collect (item-markup item))))))))

-

-(defmacro feedlist-markup (feedlist-v)

-  (alexandria:with-gensyms (feedlist)

-    `(let ((,feedlist ,feedlist-v))

-       (cl-markup:markup*

-         `(:ul :class "menu"

-           ,@(loop for feed across ,feedlist

-                   count feed into feed-count

-                   collect

-                   (list :li

-                         (list :a

-                               :href (format nil "#feed-~a" feed-count)

-                               (rss-feed-title feed)))))))))

-

-(defmacro base-template ()

-  `(cl-markup:html5

-     (:head

-       (:title "My Feeds")

-       (:script :src "https://code.jquery.com/jquery-2.1.4.min.js" :type "text/javascript" "")

-       (:script :src "/static/js/fold.js" :type "text/javascript" "")

-       (:link :rel "stylesheet" :href "/static/css/main.css")

-       (:link :rel "stylesheet" :href "/static/css/content.css")

-       (:link :rel "stylesheet" :href "/theme/light.css"))

-     (:body

-       (:header

-         (:button :class "flip-button" ">")

-         (:h1 "What?")

-         )

-       (:section :id "content"

-        (:section :id "sidebar"

-         (cl-markup:raw (feedlist-markup *feeds*)))

-        (:main

-          (loop for feed across *feeds*

-                count feed into feed-count

-                collect

-                (feed-markup feed feed-count))))

-       (:footer))))

-

-(defun base-template-f () (base-template))

-

-;(cl-oid-connect:def-route ("/" (params) :app *app*)

-;  (ningle:with-context-variables (session)

-;    (cl-oid-connect:redirect-if-necessary session

-;      (cl-oid-connect:require-login

-;        (anaphora:sunless (gethash :counter session) (setf anaphora:it 0))

-;        (incf (gethash :counter session))

-;        (format nil "~Ath visit<br/>~a<br/><br/>"

-;                (gethash :counter session))))))

-

-(cl-oid-connect:def-route ("/reflect" (params) :app *app* :method :post)

-  (format nil "~s<hr/>" (jonathan.encode:to-json (jonathan:parse (car (elt params 0))))))

+           (:li :class "link closed" :ng-repeat (format nil "item in feeds.result[~d].items" (- ,fc 1))

+            (:section :class "link-header"

+             (:h4 "{{item.title}}")

+             (:p :class "link-info"

+              (:a :target "_blank" :ng-href "{{item.link}}" :class "link-url" "{{item.link}}")

+              (:span :class "link-date" "{{item.date}}")))

+            (:section :class "link-content"

+             (:div

+               "{{item.description}}")))

+           ))))))

+

+(defmacro feedlist-markup (feedlist)

+  (alexandria:once-only (feedlist)

+    `(cl-markup:markup*

+       `(:ul :class "menu"

+         ,@(loop for feed across ,feedlist

+                 count feed into feed-count

+                 collect

+                 (list :li

+                       (list :a

+                             :href (format nil "#feed-~a" feed-count)

+                             (rss-feed-title feed))))))))

+

+(defun base-template-f (&optional demo)

+  (cl-markup:xhtml5

+    (:head

+      (:title "Whitespace")

+      (:script :src "https://code.jquery.com/jquery-2.1.4.min.js" :type "text/javascript" "")

+      (:script :src "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.5/angular.js" :type "text/javascript" "")

+      (:script :src "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.5/angular-resource.js" :type "text/javascript" "")

+      (:script :src "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.5/angular-sanitize.js" :type "text/javascript" "")

+      (:script :src "/static/js/fold.js" :type "text/javascript" "")

+      (:script :src "/static/js/whitespace-angular.js" :type "text/javascript" "")

+      (:link :rel "stylesheet" :href "/static/css/reset.css")

+      (:link :rel "stylesheet" :href "/static/css/baseline_post.css")

+      (:link :rel "stylesheet" :href "/static/css/formalize.css")

+      (:link :rel "stylesheet" :href "/static/css/main.css")

+      (:link :rel "stylesheet" :href "/static/css/content.css")

+      (:link :rel "stylesheet" :href "/theme/light.css")

+      (:link :rel "icon" :href "/static/images/Whitespace_favicon.png" :type "image/x-icon")

+      (:link :rel "shortcut icon" :href "/static/images/Whitespace_favicon.png" :type "image/x-icon"))

+

+    (:body :ng-app "whitespace" :ng-controller "MainCtrl"

+     (:header

+       (:button :class "flip-button" "…")

+       (:h1 "Whitespace")

+       )

+     (:section :id "content"

+      (:section :id "sidebar"

+       (cl-markup:raw (feedlist-markup *feeds*)))

+      (:main

+        (cl-markup:raw

+          (unless demo

+            (cl-markup:markup

+              (:form :action "/feeds/add" :name "add-form" :id "add-form" :method "post"

+               (:input :type "text" :name "url" :class "urltext" "")

+               (:input :type "hidden" :name "api" :value "no" "")

+               (:button :type "submit" :class "fsub" "+")))))

+        (:img :ng-class "{spinner: true, hide: feeds.result !== undefined}" :src "/static/images/spinner.gif" "")

+        (:section :ng-class "{feed: true, closed: !feed.closed}" :ng-repeat "feed in feeds.result"

+         (:section :class "feed-header" :ng-click "toggleClosed(feed)"

+          (:h2 "{{ feed.title }}")

+          (:h3 "{{ feed.description }}"))

+         (:ul :class "post-list"

+          (:li :ng-class "{link: true, closed: !item.closed}" :ng-repeat "item in feed.items"

+           (:section :class "link-header" :ng-click "toggleClosed(item)"

+            (:h4 "{{item.title}}")

+            (:p :class "link-info"

+             (:a :target "_blank" :ng-href "{{item.link}}" :class "link-url" "{{item.link}}")

+             (:span :class "link-date" "{{item.date}}")))

+           (:section :class "link-content"

+            (:div :ng-bind-html "renderHtml(item.description)" "")))))))

+      (:footer))))

+

+(defmacro defun-from-value (name value)

+  `(setf (symbol-function ',name) ,value))

+

+(defun-from-value jsonapi-encoder

+                  (jonathan.helper:compile-encoder () (success result)

+                    (list :|success| success

+                          :|result| result)))

+

+(defmacro neither (&rest forms) `(not (or ,@forms)))

+(defmacro neither-null (&rest forms)

+  `(neither ,@(loop for form in forms collecting `(null ,form))))

+

+; ; ;  Ultimately, this will only serialize the feed if the client

+(cl-oid-connect:def-route ("/feeds/add" (params) :method :post :app *app*)

+  (ningle.context:with-context-variables (session)

+    (cl-oid-connect:require-login

+      (let ((user-info (car (gethash :app-user session)))

+            (result '(302 (:location "/")))

+            (api (string= (cl-oid-connect:assoc-cdr "api" params) "yes"))) 

+        (when (neither-null params user-info)

+          (handler-case

+            (let* ((url (cl-oid-connect:assoc-cdr "url" params 'string=))

+                   (feed (drakma:http-request url))

+                   (plump-parser:*tag-dispatchers* plump-parser:*xml-tags*)

+                   (doc (plump:parse feed)))

+              (store-feed doc (slot-value user-info 'id))

+              (when api

+                (setf result `(200 (:Content-Type "application/json") ,(jsonapi-encoder t "success")))))

+            (cl-postgres-error:unique-violation ()

+                                                (when api

+                                                  (setf result

+                                                        `(400 () ,(jsonapi-encoder nil "Feed already saved")))))))

+        result))))

+;;; TODO: add needs to return the new content, so that angular can append it

+

+(cl-oid-connect:def-route ("/feeds/json" (params) :app *app*)

+  (ningle.context:with-context-variables (session)

+    (let* ((user-info (gethash :app-user session))

+           (*feeds* (if user-info (deserialize user-info) *feeds*)))

+      `(200 (:content-type "application/json" :cache-control "private, max-age=300") ,(jsonapi-encoder t *feeds*)))))

 (cl-oid-connect:def-route ("/feeds/:feeds/html" (params) :app *app*)

   (ningle.context:with-context-variables (session)

@@ -251,13 +228,50 @@

                                                           collect (elt *feeds* x)))))

         (base-template-f)))))

+(defun login-callback (userinfo &rest args)

+  (declare (ignore args))

+  (postmodern:with-transaction ()

+    (let* ((received-id (anaphora:aif (cl-oid-connect:assoc-cdr :id userinfo)

+                          anaphora:it

+                          (cl-oid-connect:assoc-cdr :sub userinfo)))

+           (db-user (postmodern:query-dao 'reader_user (:select :* :from 'reader_user

+                                                        :where (:= :foreign-id received-id)))))

+      (if (not (null db-user))

+        db-user

+        (progn

+          (let ((name (cl-oid-connect:assoc-cdr :name userinfo))

+                (first-name (anaphora:aif (cl-oid-connect:assoc-cdr :first--name userinfo)

+                              anaphora:it

+                              (cl-oid-connect:assoc-cdr :given--name userinfo)))

+                (last-name (anaphora:aif (cl-oid-connect:assoc-cdr :last--name userinfo)

+                             anaphora:it

+                             (cl-oid-connect:assoc-cdr :family--name userinfo)))

+                (email (cl-oid-connect:assoc-cdr :email userinfo))

+                (gender (cl-oid-connect:assoc-cdr :gender userinfo))

+                (link (anaphora:aif (cl-oid-connect:assoc-cdr :link userinfo)

+                        anaphora:it

+                        (cl-oid-connect:assoc-cdr :profile userinfo)))

+                (locale (cl-oid-connect:assoc-cdr :locale userinfo)))

+            (postmodern:make-dao 'reader_user

+                                 :foreign-id received-id

+                                 :first-name first-name

+                                 :last-name last-name

+                                 :name name

+                                 :email email

+                                 :gender gender

+                                 :link link

+                                 :locale locale)))))))

+

+(cl-oid-connect:def-route ("/demo" (params) :app *app*)

+  (base-template-f t))

+

 (cl-oid-connect:def-route ("/" (params) :app *app*)

-  (ningle.context:with-context-variables (session)

-      ;(cl-oid-connect:require-login

-        (cl-oid-connect:redirect-if-necessary session

-          (let ((*feeds* (gethash :feeds session *feeds*)))

-          (base-template-f)));)

-  ))

+  (ningle:with-context-variables (session)

+    (cl-oid-connect:require-login

+      (cl-oid-connect:redirect-if-necessary session

+        (let* ((user-info (gethash :app-user session))

+               (*feeds* (deserialize user-info)))

+          (base-template-f))))))

 ;;; this will be bound by calls to with-palette

 ;;; probably should be refactored out

@@ -265,25 +279,18 @@

 (defparameter *colorscheme* (make-instance 'colors:colorscheme))

-(cl-oid-connect:def-route ("/theme/dark.css" (params) :app *app*)

-  (colors:let-palette (make-instance 'colors:palette)

-    (eval '(get-theme-css))))

-

-(cl-oid-connect:def-route ("/theme/light.css" (params) :app *app*)

-  (colors:let-palette (colors:invert-palette (make-instance 'colors:palette))

-    (eval '(get-theme-css))))

-

-

-

 (defun get-theme-css ()

   (colors:with-palette (*palette*)

     (flet ((combine-unit-q (quant unit) (format nil "~d~a" quant unit)))

       (let* ((header-height 9)

+             (main-right-margin (* 0.618 (- 100 header-height)))

              (height-units "vh")

              (ss (lass:compile-and-write

                    `(* :color ,(colors:colorscheme-fg *colorscheme*))

-                   `(body :background-color ,(colors:colorscheme-bg *colorscheme*))

+                   `(body

+                      :transition "background-color 0.25s ease"

+                      :background-color ,(colors:colorscheme-bg *colorscheme*))

                    `((:or h1 h2 h3)

                      :color ,(colors:colorscheme-fg-highlight *colorscheme*))

@@ -298,33 +305,28 @@

                       :font-size ,(combine-unit-q (* 0.75 header-height) height-units)

                       :line-height ,(combine-unit-q header-height height-units)

                       (.flip-button

-                        :float right

-                        :width "3em"

-                        :height "3em"

-                        :padding-left "1em"

-                        :padding-bottom "1em"

-                        :border-bottom-left-radius "100%"

-                        :border none

-                        :transition "all 2s cubic-bezier(0.175, 0.885, 0.32, 1.275)"

                         :background-color ,(colors:colorscheme-fg *colorscheme*)

                         :color ,(colors:colorscheme-bg *colorscheme*))

                       ((:and .flip-button :focus)

                        :outline none)

                       ((:and .flip-button :hover)

-                       :width "6em"

-                       :height "6em"

-                       :padding-left "4em"

-                       :padding-bottom "3em")

-                      )

+                       :font-size ,(combine-unit-q (* 0.25 header-height) height-units)))

                    `(main

                       :border-left thin solid ,(colors:colorscheme-accent *colorscheme*)

-                      :height ,(combine-unit-q (- 100 header-height) height-units))

+                      :height ,(combine-unit-q (- 100 header-height) height-units)

+                      (.add-form

+                        ((:or input button)

+                          :background-color ,(colors:colorscheme-fg *colorscheme*)

+                          :color ,(colors:colorscheme-bg *colorscheme*))

+                        )

+                      )

                    `((:or a (:and a :visited) (:and a :active) code.url)

                      :color ,(colors:colorscheme-fg-highlight *colorscheme*))

                    `(section#sidebar

+                      :transition opacity "0.5s" ease

                       (ul.menu

                         ((li + li)

                          :border-top "thin" "solid" ,(colors:colorscheme-fg-highlight *colorscheme*))

@@ -350,7 +352,7 @@

                         ((:and a :hover)

                          :color ,(colors:colorscheme-fg *colorscheme*))

                         ))

-                   

+

                    `((:and .feed-header :hover)

                      :background-color ,(colors:colorscheme-hover-highlight *colorscheme*))

@@ -361,27 +363,39 @@

                      :background-color ,(colors:colorscheme-hover-highlight *colorscheme*)))))

         `(200 (:content-type "text/css") ,ss)))))

+(cl-oid-connect:def-route ("/theme/dark.css" (params) :app *app*)

+  (colors:let-palette (make-instance 'colors:palette)

+    (eval '(get-theme-css))))

+

+(cl-oid-connect:def-route ("/theme/light.css" (params) :app *app*)

+  (colors:let-palette (colors:invert-palette (make-instance 'colors:palette))

+    (eval '(get-theme-css))))

+

 (defvar *handler* nil)

 (defun stop ()

   (clack:stop (pop *handler*)))

+(ql:quickload :clack-middleware-postmodern)

+

 (defun start (&optional tmp)

   (let ((server (if (> (length tmp) 1)

                   (intern (string-upcase (elt tmp 1)) 'keyword)

                   :hunchentoot)))

-   (push (clack:clackup

-          (lack.builder:builder

-            :backtrace

-            :session

-            ;:csrf

-            (:static :path "/static/" :root #p"./static/")

-            (funcall

-              (cl-oid-connect:oauth2-login-middleware

-                :facebook-info (truename "~/github_repos/cl-oid-connect/facebook-secrets.json")

-                :google-info (truename "~/github_repos/cl-oid-connect/google-secrets.json"))

-              *app*)) :port 9090 :server server)

-        *handler*)))

-

-

+    (push (clack:clackup

+            (lack.builder:builder

+              :backtrace

+              :session

+              ;:csrf

+              (lambda (app) (lambda (env)

+                              (postmodern:with-connection *db-connection-info*

+                                (funcall app env))))

+              (:static :path "/static/" :root #p"./static/")

+              (funcall

+                (cl-oid-connect:oauth2-login-middleware

+                  :facebook-info (truename "~/github_repos/cl-oid-connect/facebook-secrets.json")

+                  :google-info (truename "~/github_repos/cl-oid-connect/google-secrets.json")

+                  :login-callback #'login-callback)

+                *app*)) :port 9090 :server server)

+          *handler*)))

@@ -11,7 +11,6 @@

   :padding "0px")

 (body

-  :transition "background-color 0.25s ease"

   :font-family "Lato")

 (((:or main "#sidebar" .feed) > (:or ul ol))

@@ -52,7 +51,9 @@

   (ul.menu

     :text-align right

     :font-variant small-caps

+    :opacity 0

     (li

+      :transition "all 0.25s ease"

       (a

         :color inherit

         :display block

@@ -60,16 +61,29 @@

         :font-weight 700

         :padding "0.5em"

         :text-decoration none

-        :transition "background-color 0.25s ease"

         :width "100%"

-        ))))

+        )))

+  (ul.menu.open

+    :opacity 1))

 (main

   :width "62vw"

   :float "right"

   :clear "right"

   :overflow-x "hidden"

-  :overflow-y "scroll")

+  :overflow-y "scroll"

+  :position "relative")

+

+(img.spinner

+  :position "absolute"

+  :top "50%"

+  :left "50%"

+  :transform "translate(-50%,-50%)"

+  )

+

+(.hide

+  :display none

+  )

 (.feed-header

   ((:or h2 h3) :padding "0.62em")

@@ -114,14 +128,25 @@

    :display block

    :clear both)

   (.link-content

+    :overflow hidden

+    

+    (img

+      :margin "1em" "0%" "1em" "10%"

+      :max-width "80%"

+      :max-height "70vh"

+      )

     ((> div)

-     :padding "1em")