application/LinkDB.php

   1 <?php
   2 /**
   3  * Data storage for links.
   4  *
   5  * This object behaves like an associative array.
   6  *
   7  * Example:
   8  *    $myLinks = new LinkDB();
   9  *    echo $myLinks['20110826_161819']['title'];
  10  *    foreach ($myLinks as $link)
  11  *       echo $link['title'].' at url '.$link['url'].'; description:'.$link['description'];
  12  *
  13  * Available keys:
  14  *  - description: description of the entry
  15  *  - linkdate: date of the creation of this entry, in the form YYYYMMDD_HHMMSS
  16  *              (e.g.'20110914_192317')
  17  *  - private:  Is this link private? 0=no, other value=yes
  18  *  - tags:     tags attached to this entry (separated by spaces)
  19  *  - title     Title of the link
  20  *  - url       URL of the link. Used for displayable links (no redirector, relative, etc.).
  21  *              Can be absolute or relative.
  22  *              Relative URLs are permalinks (e.g.'?m-ukcw')
  23  *  - real_url  Absolute processed URL.
  24  *
  25  * Implements 3 interfaces:
  26  *  - ArrayAccess: behaves like an associative array;
  27  *  - Countable:   there is a count() method;
  28  *  - Iterator:    usable in foreach () loops.
  29  */
  30 class LinkDB implements Iterator, Countable, ArrayAccess
  31 {
  32     // Links are stored as a PHP serialized string
  33     private $_datastore;
  34
  35     // Datastore PHP prefix
  36     protected static $phpPrefix = '<?php /* ';
  37
  38     // Datastore PHP suffix
  39     protected static $phpSuffix = ' */ ?>';
  40
  41     // List of links (associative array)
  42     //  - key:   link date (e.g. "20110823_124546"),
  43     //  - value: associative array (keys: title, description...)
  44     private $_links;
  45
  46     // List of all recorded URLs (key=url, value=linkdate)
  47     // for fast reserve search (url-->linkdate)
  48     private $_urls;
  49
  50     // List of linkdate keys (for the Iterator interface implementation)
  51     private $_keys;
  52
  53     // Position in the $this->_keys array (for the Iterator interface)
  54     private $_position;
  55
  56     // Is the user logged in? (used to filter private links)
  57     private $_loggedIn;
  58
  59     // Hide public links
  60     private $_hidePublicLinks;
  61
  62     // link redirector set in user settings.
  63     private $_redirector;
  64
  65     /**
  66      * Creates a new LinkDB
  67      *
  68      * Checks if the datastore exists; else, attempts to create a dummy one.
  69      *
  70      * @param string  $datastore       datastore file path.
  71      * @param boolean $isLoggedIn      is the user logged in?
  72      * @param boolean $hidePublicLinks if true all links are private.
  73      * @param string  $redirector      link redirector set in user settings.
  74      */
  75     function __construct($datastore, $isLoggedIn, $hidePublicLinks, $redirector = '')
  76     {
  77         $this->_datastore = $datastore;
  78         $this->_loggedIn = $isLoggedIn;
  79         $this->_hidePublicLinks = $hidePublicLinks;
  80         $this->_redirector = $redirector;
  81         $this->_checkDB();
  82         $this->_readDB();
  83     }
  84
  85     /**
  86      * Countable - Counts elements of an object
  87      */
  88     public function count()
  89     {
  90         return count($this->_links);
  91     }
  92
  93     /**
  94      * ArrayAccess - Assigns a value to the specified offset
  95      */
  96     public function offsetSet($offset, $value)
  97     {
  98         // TODO: use exceptions instead of "die"
  99         if (!$this->_loggedIn) {
 100             die('You are not authorized to add a link.');
 101         }
 102         if (empty($value['linkdate']) || empty($value['url'])) {
 103             die('Internal Error: A link should always have a linkdate and URL.');
 104         }
 105         if (empty($offset)) {
 106             die('You must specify a key.');
 107         }
 108         $this->_links[$offset] = $value;
 109         $this->_urls[$value['url']]=$offset;
 110     }
 111
 112     /**
 113      * ArrayAccess - Whether or not an offset exists
 114      */
 115     public function offsetExists($offset)
 116     {
 117         return array_key_exists($offset, $this->_links);
 118     }
 119
 120     /**
 121      * ArrayAccess - Unsets an offset
 122      */
 123     public function offsetUnset($offset)
 124     {
 125         if (!$this->_loggedIn) {
 126             // TODO: raise an exception
 127             die('You are not authorized to delete a link.');
 128         }
 129         $url = $this->_links[$offset]['url'];
 130         unset($this->_urls[$url]);
 131         unset($this->_links[$offset]);
 132     }
 133
 134     /**
 135      * ArrayAccess - Returns the value at specified offset
 136      */
 137     public function offsetGet($offset)
 138     {
 139         return isset($this->_links[$offset]) ? $this->_links[$offset] : null;
 140     }
 141
 142     /**
 143      * Iterator - Returns the current element
 144      */
 145     function current()
 146     {
 147         return $this->_links[$this->_keys[$this->_position]];
 148     }
 149
 150     /**
 151      * Iterator - Returns the key of the current element
 152      */
 153     function key()
 154     {
 155         return $this->_keys[$this->_position];
 156     }
 157
 158     /**
 159      * Iterator - Moves forward to next element
 160      */
 161     function next()
 162     {
 163         ++$this->_position;
 164     }
 165
 166     /**
 167      * Iterator - Rewinds the Iterator to the first element
 168      *
 169      * Entries are sorted by date (latest first)
 170      */
 171     function rewind()
 172     {
 173         $this->_keys = array_keys($this->_links);
 174         rsort($this->_keys);
 175         $this->_position = 0;
 176     }
 177
 178     /**
 179      * Iterator - Checks if current position is valid
 180      */
 181     function valid()
 182     {
 183         return isset($this->_keys[$this->_position]);
 184     }
 185
 186     /**
 187      * Checks if the DB directory and file exist
 188      *
 189      * If no DB file is found, creates a dummy DB.
 190      */
 191     private function _checkDB()
 192     {
 193         if (file_exists($this->_datastore)) {
 194             return;
 195         }
 196
 197         // Create a dummy database for example
 198         $this->_links = array();
 199         $link = array(
 200             'title'=>' Shaarli: the personal, minimalist, super-fast, no-database delicious clone',
 201             'url'=>'https://github.com/shaarli/Shaarli/wiki',
 202             'description'=>'Welcome to Shaarli! This is your first public bookmark. To edit or delete me, you must first login.
 203
 204 To learn how to use Shaarli, consult the link "Help/documentation" at the bottom of this page.
 205
 206 You use the community supported version of the original Shaarli project, by Sebastien Sauvage.',
 207             'private'=>0,
 208             'linkdate'=> date('Ymd_His'),
 209             'tags'=>'opensource software'
 210         );
 211         $this->_links[$link['linkdate']] = $link;
 212
 213         $link = array(
 214             'title'=>'My secret stuff... - Pastebin.com',
 215             'url'=>'http://sebsauvage.net/paste/?8434b27936c09649#bR7XsXhoTiLcqCpQbmOpBi3rq2zzQUC5hBI7ZT1O3x8=',
 216             'description'=>'Shhhh! I\'m a private link only YOU can see. You can delete me too.',
 217             'private'=>1,
 218             'linkdate'=> date('Ymd_His', strtotime('-1 minute')),
 219             'tags'=>'secretstuff'
 220         );
 221         $this->_links[$link['linkdate']] = $link;
 222
 223         // Write database to disk
 224         $this->writeDB();
 225     }
 226
 227     /**
 228      * Reads database from disk to memory
 229      */
 230     private function _readDB()
 231     {
 232
 233         // Public links are hidden and user not logged in => nothing to show
 234         if ($this->_hidePublicLinks && !$this->_loggedIn) {
 235             $this->_links = array();
 236             return;
 237         }
 238
 239         // Read data
 240         // Note that gzinflate is faster than gzuncompress.
 241         // See: http://www.php.net/manual/en/function.gzdeflate.php#96439
 242         $this->_links = array();
 243
 244         if (file_exists($this->_datastore)) {
 245             $this->_links = unserialize(gzinflate(base64_decode(
 246                 substr(file_get_contents($this->_datastore),
 247                        strlen(self::$phpPrefix), -strlen(self::$phpSuffix)))));
 248         }
 249
 250         // If user is not logged in, filter private links.
 251         if (!$this->_loggedIn) {
 252             $toremove = array();
 253             foreach ($this->_links as $link) {
 254                 if ($link['private'] != 0) {
 255                     $toremove[] = $link['linkdate'];
 256                 }
 257             }
 258             foreach ($toremove as $linkdate) {
 259                 unset($this->_links[$linkdate]);
 260             }
 261         }
 262
 263         // Keep the list of the mapping URLs-->linkdate up-to-date.
 264         $this->_urls = array();
 265         foreach ($this->_links as $link) {
 266             $this->_urls[$link['url']] = $link['linkdate'];
 267         }
 268
 269         // Escape links data
 270         foreach($this->_links as &$link) {
 271             sanitizeLink($link);
 272             // Do not use the redirector for internal links (Shaarli note URL starting with a '?').
 273             if (!empty($this->_redirector) && !startsWith($link['url'], '?')) {
 274                 $link['real_url'] = $this->_redirector . urlencode($link['url']);
 275             }
 276             else {
 277                 $link['real_url'] = $link['url'];
 278             }
 279         }
 280     }
 281
 282     /**
 283      * Saves the database from memory to disk
 284      *
 285      * @throws IOException the datastore is not writable
 286      */
 287     private function writeDB()
 288     {
 289         if (is_file($this->_datastore) && !is_writeable($this->_datastore)) {
 290             // The datastore exists but is not writeable
 291             throw new IOException($this->_datastore);
 292         } else if (!is_file($this->_datastore) && !is_writeable(dirname($this->_datastore))) {
 293             // The datastore does not exist and its parent directory is not writeable
 294             throw new IOException(dirname($this->_datastore));
 295         }
 296
 297         file_put_contents(
 298             $this->_datastore,
 299             self::$phpPrefix.base64_encode(gzdeflate(serialize($this->_links))).self::$phpSuffix
 300         );
 301
 302     }
 303
 304     /**
 305      * Saves the database from memory to disk
 306      *
 307      * @param string $pageCacheDir page cache directory
 308      */
 309     public function savedb($pageCacheDir)
 310     {
 311         if (!$this->_loggedIn) {
 312             // TODO: raise an Exception instead
 313             die('You are not authorized to change the database.');
 314         }
 315
 316         $this->writeDB();
 317
 318         invalidateCaches($pageCacheDir);
 319     }
 320
 321     /**
 322      * Returns the link for a given URL, or False if it does not exist.
 323      *
 324      * @param string $url URL to search for
 325      *
 326      * @return mixed the existing link if it exists, else 'false'
 327      */
 328     public function getLinkFromUrl($url)
 329     {
 330         if (isset($this->_urls[$url])) {
 331             return $this->_links[$this->_urls[$url]];
 332         }
 333         return false;
 334     }
 335
 336     /**
 337      * Filter links.
 338      *
 339      * @param string $type          Type of filter.
 340      * @param mixed  $request       Search request, string or array.
 341      * @param bool   $casesensitive Optional: Perform case sensitive filter
 342      * @param bool   $privateonly   Optional: Returns private links only if true.
 343      *
 344      * @return array filtered links
 345      */
 346     public function filter($type, $request, $casesensitive = false, $privateonly = false)
 347     {
 348         $linkFilter = new LinkFilter($this->_links);
 349         $requestFilter = is_array($request) ? implode(' ', $request) : $request;
 350         return $linkFilter->filter($type, trim($requestFilter), $casesensitive, $privateonly);
 351     }
 352
 353     /**
 354      * Returns the list of all tags
 355      * Output: associative array key=tags, value=0
 356      */
 357     public function allTags()
 358     {
 359         $tags = array();
 360         foreach ($this->_links as $link) {
 361             foreach (explode(' ', $link['tags']) as $tag) {
 362                 if (!empty($tag)) {
 363                     $tags[$tag] = (empty($tags[$tag]) ? 1 : $tags[$tag] + 1);
 364                 }
 365             }
 366         }
 367         // Sort tags by usage (most used tag first)
 368         arsort($tags);
 369         return $tags;
 370     }
 371
 372     /**
 373      * Returns the list of days containing articles (oldest first)
 374      * Output: An array containing days (in format YYYYMMDD).
 375      */
 376     public function days()
 377     {
 378         $linkDays = array();
 379         foreach (array_keys($this->_links) as $day) {
 380             $linkDays[substr($day, 0, 8)] = 0;
 381         }
 382         $linkDays = array_keys($linkDays);
 383         sort($linkDays);
 384         return $linkDays;
 385     }
 386 }