@@ -28,18 +28,18 @@

   (:panes

    (feeds :application

           :height 400

-          ;; :width 100

+          :width 300

           :display-function 'display-app

           :default-view (clim:with-application-frame (frame)

                           (feed-list frame)))

    (items :application

           :height 400

-          ;; :width  200

+          :width  600

           :display-function #'display-app

           :default-view *feed-view*)

    (articles :application

              :height 400

-             ;; :width 300

+             :width  600

              :display-function 'display-app

              )

    (int :interactor

@@ -158,14 +158,13 @@

             (t 'default)))))

+

 (defun main ()

   (clim:run-frame-top-level

    (clim:make-application-frame 'alimenta-clim::alimenta

                                 :feed-list

                                 (make-instance 'feed-list

-                                               :feeds (list (make-instance 'feed-url

-                                                                           :uri

-                                                                           "http://thomism.wordpress.com/feed")

-                                                            (make-instance 'feed-url

-                                                                           :uri

-                                                                           "http://planet.lisp.org/rss20.xml"))))))

+                                               :feeds (list 

+                                                       (make-instance 'feed-url

+                                                                      :uri

+                                                                      "http://planet.lisp.org/rss20.xml"))))))

@@ -10,7 +10,7 @@

                #:chronicity

                #:drakma

                #:for

-               #:fwoar.lisputils

+               #:fwoar-lisputils

                #:collection-class

                #:lquery

                #:plump

@@ -23,12 +23,13 @@

                (:file "alimenta")  

                (:file "data-class")

                (:file "date-handling")

+               (:file "render-protocol")

                (:file "atom")  

                (:file "rss")  

                (:file "fetching")

                (:file "discovery")))

-(defsystem :alimenta+patmatch 

+(defsystem :alimenta/patmatch 

   :description ""

   :author "Ed L <edward@elangley.org>"

   :license "MIT"

@@ -36,7 +37,7 @@

                #:uiop

                #:serapeum

                #:alimenta

-               #:fwoar.lisputils)

+               #:fwoar-lisputils)

   :serial t

   :components ((:file "pattern-matcher")))

@@ -24,17 +24,6 @@

   (:documentation "Given a lisp object representing a feed, return it rendered

                    to the specified format"))

-(defgeneric render-feed (feed renderer)

-  (:documentation "Render the container for the feed's items. Return an object

-                   to which the items can be added via add-rendered-item"))

-

-(defgeneric render-item (item renderer)

-  (:documentation "Render an item to be added to a feed. Return an object that

-                   can be added to the container by add-rendered-item"))

-

-(defgeneric add-rendered-item (item-representation feed-representation renderer)

-  (:documentation "Add the rendered item to the rendered feed"))

-

 (defgeneric generate-xml (feed feed-type &key partial)

   (:documentation "Given a lisp object representing a feed, return an xml

                    document"))

@@ -55,9 +44,13 @@

    (source-type :initarg :source-type :initform nil :accessor source-type)))

 (defmethod render ((feed feed) renderer)

-  (let ((doc (render-feed feed renderer)))

+  (let ((doc (alimenta.render:render-feed feed renderer)))

     (for:for ((item over feed))

-      (add-rendered-item (render-item item renderer) doc renderer))))

+      (setf doc

+            (alimenta.render:add-rendered-item doc

+                                               (alimenta.render:render-item item feed renderer)

+                                               renderer)))

+    doc))

 (defmethod (setf feed-link) ((value string) (feed feed))

   (setf (slot-value feed 'feed-link)

@@ -180,8 +173,8 @@

                  #'local-time:timestamp>

                  :key #'date)))))

-                                        ;(defun generate-xml (feed &key (feed-type :rss))

-                                        ;  (%generate-xml feed feed-type))

+;;(defun generate-xml (feed &key (feed-type :rss))

+;;  (%generate-xml feed feed-type))

 (defun to-feed (doc &key type feed-link)

   "Makes an instance of feed from the given document.  Specialize to-feed with

@@ -192,11 +185,11 @@

   (-to-feed doc type :feed-link feed-link))

-                                        ;(defun -get-items (feed xml-dom &key type)

-                                        ;  (with-accessors ((items items)) feed

-                                        ;    (loop for item across (get-items xml-dom type)

-                                        ;          do (push (make-item xml-dom type) items)

-                                        ;          finally (return items)))) 

+;;(defun -get-items (feed xml-dom &key type)

+;;  (with-accessors ((items items)) feed

+;;    (loop for item across (get-items xml-dom type)

+;;          do (push (make-item xml-dom type) items)

+;;          finally (return items)))) 

 (defun make-feed (&key title link items feed-link description)

   (make-instance 'feed

@@ -232,16 +225,16 @@ of this mapping directly, however any modifications to an item mutate

 the original.")

   (:method :around (item transform)

-    (call-next-method)

-    item)

+           (call-next-method)

+           item)

   (:method ((feed feed-entity) transform)

     (funcall transform feed))

   (:method :after ((feed feed) transform)

-    (map nil (lambda (it)

-                 (transform it transform))

-         (items feed))))

+           (map nil (lambda (it)

+                      (transform it transform))

+                (items feed))))

 (defun transform-content (item function)

   (setf (content item)

@@ -257,13 +250,13 @@ the original.")

         (items feed)))

 (deftest push-item ()

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

-          (item (make-instance 'item)))

-      (with-accessors ((items items)) feed

-                                        ;(should signal error (push-item feed 2))

-        (should be eql item

-                (progn

-                  (push-item feed item)

-                  (car items))))))

+  (let ((feed (make-instance 'feed))

+        (item (make-instance 'item)))

+    (with-accessors ((items items)) feed

+      ;;(should signal error (push-item feed 2))

+      (should be eql item

+              (progn

+                (push-item feed item)

+                (car items))))))

 ;; vim: set foldmethod=marker:

@@ -5,6 +5,8 @@

   ((term :initarg :term :initform nil :accessor term)

    (label :initarg :label :initform nil :accessor label)

    (scheme :initarg :scheme :initform nil :accessor scheme)))

+(defmethod print-object ((o atom-category) s)

+  (format s "#.(~s ~s ~s ~s)" 'make-category (term o) (label o) (scheme o)))

 (defclass atom-person ()

   ((name  :initarg :name  :type (or null string) :initform nil :accessor name)

@@ -25,7 +27,8 @@

    (alimenta::target   :initarg :target)))

 (defclass atom-item (alimenta:item)

-  ((author-uri :initarg :author-uri :initform nil :accessor author-uri)))

+  ((author-uri :initarg :author-uri :initform nil :accessor author-uri)

+   (categories :initarg :categories :type (or null list) :initform nil :accessor categories)))

 (defun make-category (term &optional label scheme)

   (make-instance 'atom-category :term term :label label :scheme scheme))

@@ -60,17 +63,21 @@

          (item-content ($ "> content" (text) (node)))

          (item-author ($ "> author > name" (text) (node)))

          (item-author-uri ($ "> author > uri" (text) (node)))

+         (item-categories ($ (inline xml-dom) "> category"

+                            (combine (attr "term") (attr "label") (attr "scheme"))

+                            (map-apply #'make-category)))

          (*tag-dispatchers* *html-tags*)

          (content (with-output-to-string (s)

                     (awhen (or item-content item-description) (serialize  (parse it) s)))))

     (make-instance 'atom-item

-         :doc xml-dom

+                   :doc xml-dom

                    :content content

                    :date (local-time:parse-timestring item-date)

                    :id item-guid

                    :author item-author

                    :author-uri item-author-uri

                    :link item-link

+                   :categories (coerce item-categories 'list)

                    :title item-title)))

 (defun get-authors (xml-dom)

@@ -1,14 +1,40 @@

 (in-package :collection-class)

+#+nil

+(defmethod sequence:length ((sequence collection))

+  (length (items sequence)))

+

+#+sbcl

 (defmethod sb-sequence:length ((sequence collection))

   (length (items sequence)))

+#+nil

+(defmethod sequence:elt ((sequence collection) index)

+  (elt (items sequence) index))

+

+#+sbcl

 (defmethod sb-sequence:elt ((sequence collection) index)

   (elt (items sequence) index))

+#+nil

+(defmethod (setf sequence:elt) (new-value (sequence collection) index)

+  (setf (elt (items sequence) index) new-value))

+

+#+sbcl

 (defmethod (setf sb-sequence:elt) (new-value (sequence collection) index)

   (setf (elt (items sequence) index) new-value))

+#+nil

+(defmethod sequence:adjust-sequence ((sequence collection) length &key initial-element initial-contents)

+  (let ((result (duplicate-collection sequence)))

+    (when (or initial-element initial-contents)

+      (setf (items result)

+            (sequence:adjust-sequence (items result) length

+                                      :initial-element initial-element

+                                      :initial-contents initial-contents)))

+    result))

+

+#+sbcl

 (defmethod sb-sequence:adjust-sequence ((sequence collection) length &key initial-element initial-contents)

   (let ((result (duplicate-collection sequence)))

     (when (or initial-element initial-contents)

@@ -18,6 +44,16 @@

                                          :initial-contents initial-contents)))

     result))

+#+nil

+(defmethod sequence:make-sequence-like ((sequence collection) length &key initial-element initial-contents)

+  (let ((result (duplicate-collection sequence)))

+    (setf (items result)

+          (sequence:make-sequence-like (items result) length

+                                       :initial-element initial-element

+                                       :initial-contents initial-contents))

+    result))

+

+#+sbcl

 (defmethod sb-sequence:make-sequence-like ((sequence collection) length &key initial-element initial-contents)

   (let ((result (duplicate-collection sequence)))

     (setf (items result)

@@ -4,6 +4,10 @@

   (:use #:cl #:alexandria #:serapeum)

   (:export collection value-error push-item define-collection random-item nth-item items))

+(defpackage :alimenta.render

+  (:use :cl )

+  (:export #:render-feed #:render-item #:add-rendered-item))

+

 (defpackage #:data-class

   (:use #:cl #:should-test #:lquery #:plump #:alexandria #:anaphora)

   (:export #:define-data-class))

new file mode 100644

@@ -0,0 +1,12 @@

+(in-package :alimenta.render)

+

+(defgeneric render-feed (feed renderer)

+  (:documentation "Render the container for the feed's items. Return an object

+                   to which the items can be added via add-rendered-item"))

+

+(defgeneric render-item (item feed renderer)

+  (:documentation "Render an item to be added to a feed. Return an object that

+                   can be added to the container by add-rendered-item"))

+

+(defgeneric add-rendered-item (feed-representation item-representation renderer)

+  (:documentation "Add the rendered item to the rendered feed"))