Merge branch '0.9.x' into activityatompub

diff --cc classes/Subscription.php
index d413494123565d8402c8afb11364dfb83b1bb300,763e3835b8b05f2dad789d356b8d92e657290993..1d4f37929b900bd740d173939516401bd693988b
--- 1/classes/Subscription.php
--- 2/classes/Subscription.php
+++ b/classes/Subscription.php
@@@ -264,13 -270,149 +272,156 @@@ class Subscription extends Memcached_Da
          $act->actor     = ActivityObject::fromProfile($subscriber);
          $act->objects[] = ActivityObject::fromProfile($subscribed);
  
 +        $url = common_local_url('AtomPubShowSubscription',
 +                                array('subscriber' => $subscriber->id,
 +                                      'subscribed' => $subscribed->id));
 +
 +        $act->selfLink = $url;
 +        $act->editLink = $url;
 +
          return $act;
      }
+ 
+     /**
+      * Stream of subscriptions with the same subscriber
+      *
+      * Useful for showing pages that list subscriptions in reverse
+      * chronological order. Has offset & limit to make paging
+      * easy.
+      *
+      * @param integer $subscriberId Profile ID of the subscriber
+      * @param integer $offset       Offset from latest
+      * @param integer $limit        Maximum number to fetch
+      *
+      * @return Subscription stream of subscriptions; use fetch() to iterate
+      */
+ 
+     static function bySubscriber($subscriberId,
+                                  $offset = 0,
+                                  $limit = PROFILES_PER_PAGE)
+     {
+         if ($offset + $limit > self::CACHE_WINDOW) {
+             return new ArrayWrapper(self::realBySubscriber($subscriberId,
+                                                            $offset,
+                                                            $limit));
+         } else {
+             $key = 'subscription:by-subscriber:'.$subscriberId;
+             $window = self::cacheGet($key);
+             if ($window === false) {
+                 $window = self::realBySubscriber($subscriberId,
+                                                  0,
+                                                  self::CACHE_WINDOW);
+                 self::cacheSet($key, $window);
+             }
+             return new ArrayWrapper(array_slice($window,
+                                                 $offset,
+                                                 $limit));
+         }
+     }
+ 
+     private static function realBySubscriber($subscriberId,
+                                              $offset,
+                                              $limit)
+     {
+         $sub = new Subscription();
+ 
+         $sub->subscriber = $subscriberId;
+ 
+         $sub->whereAdd('subscribed != ' . $subscriberId);
+ 
+         $sub->orderBy('created DESC');
+         $sub->limit($offset, $limit);
+ 
+         $sub->find();
+ 
+         $subs = array();
+ 
+         while ($sub->fetch()) {
+             $subs[] = clone($sub);
+         }
+ 
+         return $subs;
+     }
+ 
+     /**
+      * Stream of subscriptions with the same subscribed profile
+      *
+      * Useful for showing pages that list subscribers in reverse
+      * chronological order. Has offset & limit to make paging
+      * easy.
+      *
+      * @param integer $subscribedId Profile ID of the subscribed
+      * @param integer $offset       Offset from latest
+      * @param integer $limit        Maximum number to fetch
+      *
+      * @return Subscription stream of subscriptions; use fetch() to iterate
+      */
+ 
+     static function bySubscribed($subscribedId,
+                                  $offset = 0,
+                                  $limit = PROFILES_PER_PAGE)
+     {
+         if ($offset + $limit > self::CACHE_WINDOW) {
+             return new ArrayWrapper(self::realBySubscribed($subscribedId,
+                                                            $offset,
+                                                            $limit));
+         } else {
+             $key = 'subscription:by-subscribed:'.$subscribedId;
+             $window = self::cacheGet($key);
+             if ($window === false) {
+                 $window = self::realBySubscribed($subscribedId,
+                                                  0,
+                                                  self::CACHE_WINDOW);
+                 self::cacheSet($key, $window);
+             }
+             return new ArrayWrapper(array_slice($window,
+                                                 $offset,
+                                                 $limit));
+         }
+     }
+ 
+     private static function realBySubscribed($subscribedId,
+                                              $offset,
+                                              $limit)
+     {
+         $sub = new Subscription();
+ 
+         $sub->subscribed = $subscribedId;
+ 
+         $sub->whereAdd('subscriber != ' . $subscribedId);
+ 
+         $sub->orderBy('created DESC');
+         $sub->limit($offset, $limit);
+ 
+         $sub->find();
+ 
+         $subs = array();
+ 
+         while ($sub->fetch()) {
+             $subs[] = clone($sub);
+         }
+ 
+         return $subs;
+     }
+ 
+     /**
+      * Flush cached subscriptions when subscription is updated
+      *
+      * Because we cache subscriptions, it's useful to flush them
+      * here.
+      *
+      * @param mixed $orig Original version of object
+      *
+      * @return boolean success flag.
+      */
+ 
+     function update($orig=null)
+     {
+         $result = parent::update($orig);
+ 
+         self::blow('subscription:by-subscriber:'.$this->subscriber);
+         self::blow('subscription:by-subscribed:'.$this->subscribed);
+ 
+         return $result;
+     }
  }