Merge branch 'v0.12' into latest

14 files changed, 1698 insertions, 775 deletions

diff --git a/application/bookmark/Bookmark.php b/application/bookmark/Bookmark.php
new file mode 100644
index 00000000..1beb8be2
--- /dev/null
+++ b/application/bookmark/Bookmark.php
@@ -0,0 +1,462 @@
+<?php
+
+namespace Shaarli\Bookmark;
+
+use DateTime;
+use DateTimeInterface;
+use Shaarli\Bookmark\Exception\InvalidBookmarkException;
+
+/**
+ * Class Bookmark
+ *
+ * This class represent a single Bookmark with all its attributes.
+ * Every bookmark should manipulated using this, before being formatted.
+ *
+ * @package Shaarli\Bookmark
+ */
+class Bookmark
+{
+    /** @var string Date format used in string (former ID format) */
+    const LINK_DATE_FORMAT = 'Ymd_His';
+
+    /** @var int Bookmark ID */
+    protected $id;
+
+    /** @var string Permalink identifier */
+    protected $shortUrl;
+
+    /** @var string Bookmark's URL - $shortUrl prefixed with `?` for notes */
+    protected $url;
+
+    /** @var string Bookmark's title */
+    protected $title;
+
+    /** @var string Raw bookmark's description */
+    protected $description;
+
+    /** @var array List of bookmark's tags */
+    protected $tags;
+
+    /** @var string|bool|null Thumbnail's URL - initialized at null, false if no thumbnail could be found */
+    protected $thumbnail;
+
+    /** @var bool Set to true if the bookmark is set as sticky */
+    protected $sticky;
+
+    /** @var DateTimeInterface Creation datetime */
+    protected $created;
+
+    /** @var DateTimeInterface datetime */
+    protected $updated;
+
+    /** @var bool True if the bookmark can only be seen while logged in */
+    protected $private;
+
+    /**
+     * Initialize a link from array data. Especially useful to create a Bookmark from former link storage format.
+     *
+     * @param array $data
+     *
+     * @return $this
+     */
+    public function fromArray($data)
+    {
+        $this->id = $data['id'];
+        $this->shortUrl = $data['shorturl'];
+        $this->url = $data['url'];
+        $this->title = $data['title'];
+        $this->description = $data['description'];
+        $this->thumbnail = isset($data['thumbnail']) ? $data['thumbnail'] : null;
+        $this->sticky = isset($data['sticky']) ? $data['sticky'] : false;
+        $this->created = $data['created'];
+        if (is_array($data['tags'])) {
+            $this->tags = $data['tags'];
+        } else {
+            $this->tags = preg_split('/\s+/', $data['tags'], -1, PREG_SPLIT_NO_EMPTY);
+        }
+        if (! empty($data['updated'])) {
+            $this->updated = $data['updated'];
+        }
+        $this->private = $data['private'] ? true : false;
+
+        return $this;
+    }
+
+    /**
+     * Make sure that the current instance of Bookmark is valid and can be saved into the data store.
+     * A valid link requires:
+     *   - an integer ID
+     *   - a short URL (for permalinks)
+     *   - a creation date
+     *
+     * This function also initialize optional empty fields:
+     *   - the URL with the permalink
+     *   - the title with the URL
+     *
+     * @throws InvalidBookmarkException
+     */
+    public function validate()
+    {
+        if ($this->id === null
+            || ! is_int($this->id)
+            || empty($this->shortUrl)
+            || empty($this->created)
+            || ! $this->created instanceof DateTimeInterface
+        ) {
+            throw new InvalidBookmarkException($this);
+        }
+        if (empty($this->url)) {
+            $this->url = '/shaare/'. $this->shortUrl;
+        }
+        if (empty($this->title)) {
+            $this->title = $this->url;
+        }
+    }
+
+    /**
+     * Set the Id.
+     * If they're not already initialized, this function also set:
+     *   - created: with the current datetime
+     *   - shortUrl: with a generated small hash from the date and the given ID
+     *
+     * @param int $id
+     *
+     * @return Bookmark
+     */
+    public function setId($id)
+    {
+        $this->id = $id;
+        if (empty($this->created)) {
+            $this->created = new DateTime();
+        }
+        if (empty($this->shortUrl)) {
+            $this->shortUrl = link_small_hash($this->created, $this->id);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get the Id.
+     *
+     * @return int
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * Get the ShortUrl.
+     *
+     * @return string
+     */
+    public function getShortUrl()
+    {
+        return $this->shortUrl;
+    }
+
+    /**
+     * Get the Url.
+     *
+     * @return string
+     */
+    public function getUrl()
+    {
+        return $this->url;
+    }
+
+    /**
+     * Get the Title.
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return $this->title;
+    }
+
+    /**
+     * Get the Description.
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return ! empty($this->description) ? $this->description : '';
+    }
+
+    /**
+     * Get the Created.
+     *
+     * @return DateTimeInterface
+     */
+    public function getCreated()
+    {
+        return $this->created;
+    }
+
+    /**
+     * Get the Updated.
+     *
+     * @return DateTimeInterface
+     */
+    public function getUpdated()
+    {
+        return $this->updated;
+    }
+
+    /**
+     * Set the ShortUrl.
+     *
+     * @param string $shortUrl
+     *
+     * @return Bookmark
+     */
+    public function setShortUrl($shortUrl)
+    {
+        $this->shortUrl = $shortUrl;
+
+        return $this;
+    }
+
+    /**
+     * Set the Url.
+     *
+     * @param string $url
+     * @param array  $allowedProtocols
+     *
+     * @return Bookmark
+     */
+    public function setUrl($url, $allowedProtocols = [])
+    {
+        $url = trim($url);
+        if (! empty($url)) {
+            $url = whitelist_protocols($url, $allowedProtocols);
+        }
+        $this->url = $url;
+
+        return $this;
+    }
+
+    /**
+     * Set the Title.
+     *
+     * @param string $title
+     *
+     * @return Bookmark
+     */
+    public function setTitle($title)
+    {
+        $this->title = trim($title);
+
+        return $this;
+    }
+
+    /**
+     * Set the Description.
+     *
+     * @param string $description
+     *
+     * @return Bookmark
+     */
+    public function setDescription($description)
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    /**
+     * Set the Created.
+     * Note: you shouldn't set this manually except for special cases (like bookmark import)
+     *
+     * @param DateTimeInterface $created
+     *
+     * @return Bookmark
+     */
+    public function setCreated($created)
+    {
+        $this->created = $created;
+
+        return $this;
+    }
+
+    /**
+     * Set the Updated.
+     *
+     * @param DateTimeInterface $updated
+     *
+     * @return Bookmark
+     */
+    public function setUpdated($updated)
+    {
+        $this->updated = $updated;
+
+        return $this;
+    }
+
+    /**
+     * Get the Private.
+     *
+     * @return bool
+     */
+    public function isPrivate()
+    {
+        return $this->private ? true : false;
+    }
+
+    /**
+     * Set the Private.
+     *
+     * @param bool $private
+     *
+     * @return Bookmark
+     */
+    public function setPrivate($private)
+    {
+        $this->private = $private ? true : false;
+
+        return $this;
+    }
+
+    /**
+     * Get the Tags.
+     *
+     * @return array
+     */
+    public function getTags()
+    {
+        return is_array($this->tags) ? $this->tags : [];
+    }
+
+    /**
+     * Set the Tags.
+     *
+     * @param array $tags
+     *
+     * @return Bookmark
+     */
+    public function setTags($tags)
+    {
+        $this->setTagsString(implode(' ', $tags));
+
+        return $this;
+    }
+
+    /**
+     * Get the Thumbnail.
+     *
+     * @return string|bool|null Thumbnail's URL - initialized at null, false if no thumbnail could be found
+     */
+    public function getThumbnail()
+    {
+        return !$this->isNote() ? $this->thumbnail : false;
+    }
+
+    /**
+     * Set the Thumbnail.
+     *
+     * @param string|bool $thumbnail Thumbnail's URL - false if no thumbnail could be found
+     *
+     * @return Bookmark
+     */
+    public function setThumbnail($thumbnail)
+    {
+        $this->thumbnail = $thumbnail;
+
+        return $this;
+    }
+
+    /**
+     * Get the Sticky.
+     *
+     * @return bool
+     */
+    public function isSticky()
+    {
+        return $this->sticky ? true : false;
+    }
+
+    /**
+     * Set the Sticky.
+     *
+     * @param bool $sticky
+     *
+     * @return Bookmark
+     */
+    public function setSticky($sticky)
+    {
+        $this->sticky = $sticky ? true : false;
+
+        return $this;
+    }
+
+    /**
+     * @return string Bookmark's tags as a string, separated by a space
+     */
+    public function getTagsString()
+    {
+        return implode(' ', $this->getTags());
+    }
+
+    /**
+     * @return bool
+     */
+    public function isNote()
+    {
+        // We check empty value to get a valid result if the link has not been saved yet
+        return empty($this->url) || startsWith($this->url, '/shaare/') || $this->url[0] === '?';
+    }
+
+    /**
+     * Set tags from a string.
+     * Note:
+     *   - tags must be separated whether by a space or a comma
+     *   - multiple spaces will be removed
+     *   - trailing dash in tags will be removed
+     *
+     * @param string $tags
+     *
+     * @return $this
+     */
+    public function setTagsString($tags)
+    {
+        // Remove first '-' char in tags.
+        $tags = preg_replace('/(^| )\-/', '$1', $tags);
+        // Explode all tags separted by spaces or commas
+        $tags = preg_split('/[\s,]+/', $tags);
+        // Remove eventual empty values
+        $tags = array_values(array_filter($tags));
+
+        $this->tags = $tags;
+
+        return $this;
+    }
+
+    /**
+     * Rename a tag in tags list.
+     *
+     * @param string $fromTag
+     * @param string $toTag
+     */
+    public function renameTag($fromTag, $toTag)
+    {
+        if (($pos = array_search($fromTag, $this->tags)) !== false) {
+            $this->tags[$pos] = trim($toTag);
+        }
+    }
+
+    /**
+     * Delete a tag from tags list.
+     *
+     * @param string $tag
+     */
+    public function deleteTag($tag)
+    {
+        if (($pos = array_search($tag, $this->tags)) !== false) {
+            unset($this->tags[$pos]);
+            $this->tags = array_values($this->tags);
+        }
+    }
+}
diff --git a/application/bookmark/BookmarkArray.php b/application/bookmark/BookmarkArray.php
new file mode 100644
index 00000000..3bd5eb20
--- /dev/null
+++ b/application/bookmark/BookmarkArray.php
@@ -0,0 +1,260 @@
+<?php
+
+namespace Shaarli\Bookmark;
+
+use Shaarli\Bookmark\Exception\InvalidBookmarkException;
+
+/**
+ * Class BookmarkArray
+ *
+ * Implementing ArrayAccess, this allows us to use the bookmark list
+ * as an array and iterate over it.
+ *
+ * @package Shaarli\Bookmark
+ */
+class BookmarkArray implements \Iterator, \Countable, \ArrayAccess
+{
+    /**
+     * @var Bookmark[]
+     */
+    protected $bookmarks;
+
+    /**
+     * @var array List of all bookmarks IDS mapped with their array offset.
+     *            Map: id->offset.
+     */
+    protected $ids;
+
+    /**
+     * @var int Position in the $this->keys array (for the Iterator interface)
+     */
+    protected $position;
+
+    /**
+     * @var array List of offset keys (for the Iterator interface implementation)
+     */
+    protected $keys;
+
+    /**
+     * @var array List of all recorded URLs (key=url, value=bookmark offset)
+     *            for fast reserve search (url-->bookmark offset)
+     */
+    protected $urls;
+
+    public function __construct()
+    {
+        $this->ids = [];
+        $this->bookmarks = [];
+        $this->keys = [];
+        $this->urls = [];
+        $this->position = 0;
+    }
+
+    /**
+     * Countable - Counts elements of an object
+     *
+     * @return int Number of bookmarks
+     */
+    public function count()
+    {
+        return count($this->bookmarks);
+    }
+
+    /**
+     * ArrayAccess - Assigns a value to the specified offset
+     *
+     * @param int      $offset Bookmark ID
+     * @param Bookmark $value  instance
+     *
+     * @throws InvalidBookmarkException
+     */
+    public function offsetSet($offset, $value)
+    {
+        if (! $value instanceof Bookmark
+            || $value->getId() === null || empty($value->getUrl())
+            || ($offset !== null && ! is_int($offset)) || ! is_int($value->getId())
+            || $offset !== null && $offset !== $value->getId()
+        ) {
+            throw new InvalidBookmarkException($value);
+        }
+
+        // If the bookmark exists, we reuse the real offset, otherwise new entry
+        if ($offset !== null) {
+            $existing = $this->getBookmarkOffset($offset);
+        } else {
+            $existing = $this->getBookmarkOffset($value->getId());
+        }
+
+        if ($existing !== null) {
+            $offset = $existing;
+        } else {
+            $offset = count($this->bookmarks);
+        }
+
+        $this->bookmarks[$offset] = $value;
+        $this->urls[$value->getUrl()] = $offset;
+        $this->ids[$value->getId()] = $offset;
+    }
+
+    /**
+     * ArrayAccess - Whether or not an offset exists
+     *
+     * @param int $offset Bookmark ID
+     *
+     * @return bool true if it exists, false otherwise
+     */
+    public function offsetExists($offset)
+    {
+        return array_key_exists($this->getBookmarkOffset($offset), $this->bookmarks);
+    }
+
+    /**
+     * ArrayAccess - Unsets an offset
+     *
+     * @param int $offset Bookmark ID
+     */
+    public function offsetUnset($offset)
+    {
+        $realOffset = $this->getBookmarkOffset($offset);
+        $url = $this->bookmarks[$realOffset]->getUrl();
+        unset($this->urls[$url]);
+        unset($this->ids[$offset]);
+        unset($this->bookmarks[$realOffset]);
+    }
+
+    /**
+     * ArrayAccess - Returns the value at specified offset
+     *
+     * @param int $offset Bookmark ID
+     *
+     * @return Bookmark|null The Bookmark if found, null otherwise
+     */
+    public function offsetGet($offset)
+    {
+        $realOffset = $this->getBookmarkOffset($offset);
+        return isset($this->bookmarks[$realOffset]) ? $this->bookmarks[$realOffset] : null;
+    }
+
+    /**
+     * Iterator - Returns the current element
+     *
+     * @return Bookmark corresponding to the current position
+     */
+    public function current()
+    {
+        return $this[$this->keys[$this->position]];
+    }
+
+    /**
+     * Iterator - Returns the key of the current element
+     *
+     * @return int Bookmark ID corresponding to the current position
+     */
+    public function key()
+    {
+        return $this->keys[$this->position];
+    }
+
+    /**
+     * Iterator - Moves forward to next element
+     */
+    public function next()
+    {
+        ++$this->position;
+    }
+
+    /**
+     * Iterator - Rewinds the Iterator to the first element
+     *
+     * Entries are sorted by date (latest first)
+     */
+    public function rewind()
+    {
+        $this->keys = array_keys($this->ids);
+        $this->position = 0;
+    }
+
+    /**
+     * Iterator - Checks if current position is valid
+     *
+     * @return bool true if the current Bookmark ID exists, false otherwise
+     */
+    public function valid()
+    {
+        return isset($this->keys[$this->position]);
+    }
+
+    /**
+     * Returns a bookmark offset in bookmarks array from its unique ID.
+     *
+     * @param int $id Persistent ID of a bookmark.
+     *
+     * @return int Real offset in local array, or null if doesn't exist.
+     */
+    protected function getBookmarkOffset($id)
+    {
+        if (isset($this->ids[$id])) {
+            return $this->ids[$id];
+        }
+        return null;
+    }
+
+    /**
+     * Return the next key for bookmark creation.
+     * E.g. If the last ID is 597, the next will be 598.
+     *
+     * @return int next ID.
+     */
+    public function getNextId()
+    {
+        if (!empty($this->ids)) {
+            return max(array_keys($this->ids)) + 1;
+        }
+        return 0;
+    }
+
+    /**
+     * @param $url
+     *
+     * @return Bookmark|null
+     */
+    public function getByUrl($url)
+    {
+        if (! empty($url)
+            && isset($this->urls[$url])
+            && isset($this->bookmarks[$this->urls[$url]])
+        ) {
+            return $this->bookmarks[$this->urls[$url]];
+        }
+        return null;
+    }
+
+    /**
+     * Reorder links by creation date (newest first).
+     *
+     * Also update the urls and ids mapping arrays.
+     *
+     * @param string $order        ASC|DESC
+     * @param bool   $ignoreSticky If set to true, sticky bookmarks won't be first
+     */
+    public function reorder(string $order = 'DESC', bool $ignoreSticky = false): void
+    {
+        $order = $order === 'ASC' ? -1 : 1;
+        // Reorder array by dates.
+        usort($this->bookmarks, function ($a, $b) use ($order, $ignoreSticky) {
+            /** @var $a Bookmark */
+            /** @var $b Bookmark */
+            if (false === $ignoreSticky && $a->isSticky() !== $b->isSticky()) {
+                return $a->isSticky() ? -1 : 1;
+            }
+            return $a->getCreated() < $b->getCreated() ? 1 * $order : -1 * $order;
+        });
+
+        $this->urls = [];
+        $this->ids = [];
+        foreach ($this->bookmarks as $key => $bookmark) {
+            $this->urls[$bookmark->getUrl()] = $key;
+            $this->ids[$bookmark->getId()] = $key;
+        }
+    }
+}
diff --git a/application/bookmark/BookmarkFileService.php b/application/bookmark/BookmarkFileService.php
new file mode 100644
index 00000000..c9ec2609
--- /dev/null
+++ b/application/bookmark/BookmarkFileService.php
@@ -0,0 +1,407 @@
+<?php
+
+
+namespace Shaarli\Bookmark;
+
+
+use Exception;
+use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
+use Shaarli\Bookmark\Exception\DatastoreNotInitializedException;
+use Shaarli\Bookmark\Exception\EmptyDataStoreException;
+use Shaarli\Config\ConfigManager;
+use Shaarli\Formatter\BookmarkMarkdownFormatter;
+use Shaarli\History;
+use Shaarli\Legacy\LegacyLinkDB;
+use Shaarli\Legacy\LegacyUpdater;
+use Shaarli\Render\PageCacheManager;
+use Shaarli\Updater\UpdaterUtils;
+
+/**
+ * Class BookmarksService
+ *
+ * This is the entry point to manipulate the bookmark DB.
+ * It manipulates loads links from a file data store containing all bookmarks.
+ *
+ * It also triggers the legacy format (bookmarks as arrays) migration.
+ */
+class BookmarkFileService implements BookmarkServiceInterface
+{
+    /** @var Bookmark[] instance */
+    protected $bookmarks;
+
+    /** @var BookmarkIO instance */
+    protected $bookmarksIO;
+
+    /** @var BookmarkFilter */
+    protected $bookmarkFilter;
+
+    /** @var ConfigManager instance */
+    protected $conf;
+
+    /** @var History instance */
+    protected $history;
+
+    /** @var PageCacheManager instance */
+    protected $pageCacheManager;
+
+    /** @var bool true for logged in users. Default value to retrieve private bookmarks. */
+    protected $isLoggedIn;
+
+    /**
+     * @inheritDoc
+     */
+    public function __construct(ConfigManager $conf, History $history, $isLoggedIn)
+    {
+        $this->conf = $conf;
+        $this->history = $history;
+        $this->pageCacheManager = new PageCacheManager($this->conf->get('resource.page_cache'), $isLoggedIn);
+        $this->bookmarksIO = new BookmarkIO($this->conf);
+        $this->isLoggedIn = $isLoggedIn;
+
+        if (!$this->isLoggedIn && $this->conf->get('privacy.hide_public_links', false)) {
+            $this->bookmarks = [];
+        } else {
+            try {
+                $this->bookmarks = $this->bookmarksIO->read();
+            } catch (EmptyDataStoreException|DatastoreNotInitializedException $e) {
+                $this->bookmarks = new BookmarkArray();
+
+                if ($this->isLoggedIn) {
+                    // Datastore file does not exists, we initialize it with default bookmarks.
+                    if ($e instanceof DatastoreNotInitializedException) {
+                        $this->initialize();
+                    } else {
+                        $this->save();
+                    }
+                }
+            }
+
+            if (! $this->bookmarks instanceof BookmarkArray) {
+                $this->migrate();
+                exit(
+                    'Your data store has been migrated, please reload the page.'. PHP_EOL .
+                    'If this message keeps showing up, please delete data/updates.txt file.'
+                );
+            }
+        }
+
+        $this->bookmarkFilter = new BookmarkFilter($this->bookmarks);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function findByHash($hash)
+    {
+        $bookmark = $this->bookmarkFilter->filter(BookmarkFilter::$FILTER_HASH, $hash);
+        // PHP 7.3 introduced array_key_first() to avoid this hack
+        $first = reset($bookmark);
+        if (! $this->isLoggedIn && $first->isPrivate()) {
+            throw new Exception('Not authorized');
+        }
+
+        return $first;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function findByUrl($url)
+    {
+        return $this->bookmarks->getByUrl($url);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function search(
+        $request = [],
+        $visibility = null,
+        $caseSensitive = false,
+        $untaggedOnly = false,
+        bool $ignoreSticky = false
+    ) {
+        if ($visibility === null) {
+            $visibility = $this->isLoggedIn ? BookmarkFilter::$ALL : BookmarkFilter::$PUBLIC;
+        }
+
+        // Filter bookmark database according to parameters.
+        $searchtags = isset($request['searchtags']) ? $request['searchtags'] : '';
+        $searchterm = isset($request['searchterm']) ? $request['searchterm'] : '';
+
+        if ($ignoreSticky) {
+            $this->bookmarks->reorder('DESC', true);
+        }
+
+        return $this->bookmarkFilter->filter(
+            BookmarkFilter::$FILTER_TAG | BookmarkFilter::$FILTER_TEXT,
+            [$searchtags, $searchterm],
+            $caseSensitive,
+            $visibility,
+            $untaggedOnly
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function get($id, $visibility = null)
+    {
+        if (! isset($this->bookmarks[$id])) {
+            throw new BookmarkNotFoundException();
+        }
+
+        if ($visibility === null) {
+            $visibility = $this->isLoggedIn ? BookmarkFilter::$ALL : BookmarkFilter::$PUBLIC;
+        }
+
+        $bookmark = $this->bookmarks[$id];
+        if (($bookmark->isPrivate() && $visibility != 'all' && $visibility != 'private')
+            || (! $bookmark->isPrivate() && $visibility != 'all' && $visibility != 'public')
+        ) {
+            throw new Exception('Unauthorized');
+        }
+
+        return $bookmark;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function set($bookmark, $save = true)
+    {
+        if (true !== $this->isLoggedIn) {
+            throw new Exception(t('You\'re not authorized to alter the datastore'));
+        }
+        if (! $bookmark instanceof Bookmark) {
+            throw new Exception(t('Provided data is invalid'));
+        }
+        if (! isset($this->bookmarks[$bookmark->getId()])) {
+            throw new BookmarkNotFoundException();
+        }
+        $bookmark->validate();
+
+        $bookmark->setUpdated(new \DateTime());
+        $this->bookmarks[$bookmark->getId()] = $bookmark;
+        if ($save === true) {
+            $this->save();
+            $this->history->updateLink($bookmark);
+        }
+        return $this->bookmarks[$bookmark->getId()];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function add($bookmark, $save = true)
+    {
+        if (true !== $this->isLoggedIn) {
+            throw new Exception(t('You\'re not authorized to alter the datastore'));
+        }
+        if (! $bookmark instanceof Bookmark) {
+            throw new Exception(t('Provided data is invalid'));
+        }
+        if (! empty($bookmark->getId())) {
+            throw new Exception(t('This bookmarks already exists'));
+        }
+        $bookmark->setId($this->bookmarks->getNextId());
+        $bookmark->validate();
+
+        $this->bookmarks[$bookmark->getId()] = $bookmark;
+        if ($save === true) {
+            $this->save();
+            $this->history->addLink($bookmark);
+        }
+        return $this->bookmarks[$bookmark->getId()];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function addOrSet($bookmark, $save = true)
+    {
+        if (true !== $this->isLoggedIn) {
+            throw new Exception(t('You\'re not authorized to alter the datastore'));
+        }
+        if (! $bookmark instanceof Bookmark) {
+            throw new Exception('Provided data is invalid');
+        }
+        if ($bookmark->getId() === null) {
+            return $this->add($bookmark, $save);
+        }
+        return $this->set($bookmark, $save);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function remove($bookmark, $save = true)
+    {
+        if (true !== $this->isLoggedIn) {
+            throw new Exception(t('You\'re not authorized to alter the datastore'));
+        }
+        if (! $bookmark instanceof Bookmark) {
+            throw new Exception(t('Provided data is invalid'));
+        }
+        if (! isset($this->bookmarks[$bookmark->getId()])) {
+            throw new BookmarkNotFoundException();
+        }
+
+        unset($this->bookmarks[$bookmark->getId()]);
+        if ($save === true) {
+            $this->save();
+            $this->history->deleteLink($bookmark);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function exists($id, $visibility = null)
+    {
+        if (! isset($this->bookmarks[$id])) {
+            return false;
+        }
+
+        if ($visibility === null) {
+            $visibility = $this->isLoggedIn ? 'all' : 'public';
+        }
+
+        $bookmark = $this->bookmarks[$id];
+        if (($bookmark->isPrivate() && $visibility != 'all' && $visibility != 'private')
+            || (! $bookmark->isPrivate() && $visibility != 'all' && $visibility != 'public')
+        ) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function count($visibility = null)
+    {
+        return count($this->search([], $visibility));
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function save()
+    {
+        if (true !== $this->isLoggedIn) {
+            // TODO: raise an Exception instead
+            die('You are not authorized to change the database.');
+        }
+
+        $this->bookmarks->reorder();
+        $this->bookmarksIO->write($this->bookmarks);
+        $this->pageCacheManager->invalidateCaches();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function bookmarksCountPerTag($filteringTags = [], $visibility = null)
+    {
+        $bookmarks = $this->search(['searchtags' => $filteringTags], $visibility);
+        $tags = [];
+        $caseMapping = [];
+        foreach ($bookmarks as $bookmark) {
+            foreach ($bookmark->getTags() as $tag) {
+                if (empty($tag)
+                    || (! $this->isLoggedIn && startsWith($tag, '.'))
+                    || $tag === BookmarkMarkdownFormatter::NO_MD_TAG
+                    || in_array($tag, $filteringTags, true)
+                ) {
+                    continue;
+                }
+
+                // The first case found will be displayed.
+                if (!isset($caseMapping[strtolower($tag)])) {
+                    $caseMapping[strtolower($tag)] = $tag;
+                    $tags[$caseMapping[strtolower($tag)]] = 0;
+                }
+                $tags[$caseMapping[strtolower($tag)]]++;
+            }
+        }
+
+        /*
+         * Formerly used arsort(), which doesn't define the sort behaviour for equal values.
+         * Also, this function doesn't produce the same result between PHP 5.6 and 7.
+         *
+         * So we now use array_multisort() to sort tags by DESC occurrences,
+         * then ASC alphabetically for equal values.
+         *
+         * @see https://github.com/shaarli/Shaarli/issues/1142
+         */
+        $keys = array_keys($tags);
+        $tmpTags = array_combine($keys, $keys);
+        array_multisort($tags, SORT_DESC, $tmpTags, SORT_ASC, $tags);
+        return $tags;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function days()
+    {
+        $bookmarkDays = [];
+        foreach ($this->search() as $bookmark) {
+            $bookmarkDays[$bookmark->getCreated()->format('Ymd')] = 0;
+        }
+        $bookmarkDays = array_keys($bookmarkDays);
+        sort($bookmarkDays);
+
+        return $bookmarkDays;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function filterDay($request)
+    {
+        $visibility = $this->isLoggedIn ? BookmarkFilter::$ALL : BookmarkFilter::$PUBLIC;
+
+        return $this->bookmarkFilter->filter(BookmarkFilter::$FILTER_DAY, $request, false, $visibility);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function initialize()
+    {
+        $initializer = new BookmarkInitializer($this);
+        $initializer->initialize();
+
+        if (true === $this->isLoggedIn) {
+            $this->save();
+        }
+    }
+
+    /**
+     * Handles migration to the new database format (BookmarksArray).
+     */
+    protected function migrate()
+    {
+        $bookmarkDb = new LegacyLinkDB(
+            $this->conf->get('resource.datastore'),
+            true,
+            false
+        );
+        $updater = new LegacyUpdater(
+            UpdaterUtils::read_updates_file($this->conf->get('resource.updates')),
+            $bookmarkDb,
+            $this->conf,
+            true
+        );
+        $newUpdates = $updater->update();
+        if (! empty($newUpdates)) {
+            UpdaterUtils::write_updates_file(
+                $this->conf->get('resource.updates'),
+                $updater->getDoneUpdates()
+            );
+        }
+    }
+}
diff --git a/application/bookmark/LinkFilter.php b/application/bookmark/BookmarkFilter.php
index 9b966307..6636bbfe 100644
--- a/application/bookmark/LinkFilter.php
+++ b/application/bookmark/BookmarkFilter.php
@@ -3,14 +3,14 @@
 namespace Shaarli\Bookmark;
 
 use Exception;
-use Shaarli\Bookmark\Exception\LinkNotFoundException;
+use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
 
 /**
  * Class LinkFilter.
  *
  * Perform search and filter operation on link data list.
  */
-class LinkFilter
+class BookmarkFilter
 {
     /**
      * @var string permalinks.
@@ -33,33 +33,49 @@ class LinkFilter
     public static $FILTER_DAY = 'FILTER_DAY';
 
     /**
+     * @var string filter by day.
+     */
+    public static $DEFAULT = 'NO_FILTER';
+
+    /** @var string Visibility: all */
+    public static $ALL = 'all';
+
+    /** @var string Visibility: public */
+    public static $PUBLIC = 'public';
+
+    /** @var string Visibility: private */
+    public static $PRIVATE = 'private';
+
+    /**
      * @var string Allowed characters for hashtags (regex syntax).
      */
     public static $HASHTAG_CHARS = '\p{Pc}\p{N}\p{L}\p{Mn}';
 
     /**
-     * @var LinkDB all available links.
+     * @var Bookmark[] all available bookmarks.
      */
-    private $links;
+    private $bookmarks;
 
     /**
-     * @param LinkDB $links initialization.
+     * @param Bookmark[] $bookmarks initialization.
      */
-    public function __construct($links)
+    public function __construct($bookmarks)
     {
-        $this->links = $links;
+        $this->bookmarks = $bookmarks;
     }
 
     /**
-     * Filter links according to parameters.
+     * Filter bookmarks according to parameters.
      *
      * @param string $type          Type of filter (eg. tags, permalink, etc.).
      * @param mixed  $request       Filter content.
      * @param bool   $casesensitive Optional: Perform case sensitive filter if true.
-     * @param string $visibility    Optional: return only all/private/public links
-     * @param string $untaggedonly  Optional: return only untagged links. Applies only if $type includes FILTER_TAG
+     * @param string $visibility    Optional: return only all/private/public bookmarks
+     * @param bool   $untaggedonly  Optional: return only untagged bookmarks. Applies only if $type includes FILTER_TAG
      *
-     * @return array filtered link list.
+     * @return Bookmark[] filtered bookmark list.
+     *
+     * @throws BookmarkNotFoundException
      */
     public function filter($type, $request, $casesensitive = false, $visibility = 'all', $untaggedonly = false)
     {
@@ -81,13 +97,13 @@ class LinkFilter
                 if ($untaggedonly) {
                     $filtered = $this->filterUntagged($visibility);
                 } else {
-                    $filtered = $this->links;
+                    $filtered = $this->bookmarks;
                 }
                 if (!empty($request[0])) {
-                    $filtered = (new LinkFilter($filtered))->filterTags($request[0], $casesensitive, $visibility);
+                    $filtered = (new BookmarkFilter($filtered))->filterTags($request[0], $casesensitive, $visibility);
                 }
                 if (!empty($request[1])) {
-                    $filtered = (new LinkFilter($filtered))->filterFulltext($request[1], $visibility);
+                    $filtered = (new BookmarkFilter($filtered))->filterFulltext($request[1], $visibility);
                 }
                 return $filtered;
             case self::$FILTER_TEXT:
@@ -99,7 +115,7 @@ class LinkFilter
                     return $this->filterTags($request, $casesensitive, $visibility);
                 }
             case self::$FILTER_DAY:
-                return $this->filterDay($request);
+                return $this->filterDay($request, $visibility);
             default:
                 return $this->noFilter($visibility);
         }
@@ -108,21 +124,21 @@ class LinkFilter
     /**
      * Unknown filter, but handle private only.
      *
-     * @param string $visibility Optional: return only all/private/public links
+     * @param string $visibility Optional: return only all/private/public bookmarks
      *
-     * @return array filtered links.
+     * @return Bookmark[] filtered bookmarks.
      */
     private function noFilter($visibility = 'all')
     {
         if ($visibility === 'all') {
-            return $this->links;
+            return $this->bookmarks;
         }
 
         $out = array();
-        foreach ($this->links as $key => $value) {
-            if ($value['private'] && $visibility === 'private') {
+        foreach ($this->bookmarks as $key => $value) {
+            if ($value->isPrivate() && $visibility === 'private') {
                 $out[$key] = $value;
-            } elseif (!$value['private'] && $visibility === 'public') {
+            } elseif (!$value->isPrivate() && $visibility === 'public') {
                 $out[$key] = $value;
             }
         }
@@ -137,28 +153,22 @@ class LinkFilter
      *
      * @return array $filtered array containing permalink data.
      *
-     * @throws \Shaarli\Bookmark\Exception\LinkNotFoundException if the smallhash doesn't match any link.
+     * @throws \Shaarli\Bookmark\Exception\BookmarkNotFoundException if the smallhash doesn't match any link.
      */
     private function filterSmallHash($smallHash)
     {
-        $filtered = array();
-        foreach ($this->links as $key => $l) {
-            if ($smallHash == $l['shorturl']) {
+        foreach ($this->bookmarks as $key => $l) {
+            if ($smallHash == $l->getShortUrl()) {
                 // Yes, this is ugly and slow
-                $filtered[$key] = $l;
-                return $filtered;
+                return [$key => $l];
             }
         }
 
-        if (empty($filtered)) {
-            throw new LinkNotFoundException();
-        }
-
-        return $filtered;
+        throw new BookmarkNotFoundException();
     }
 
     /**
-     * Returns the list of links corresponding to a full-text search
+     * Returns the list of bookmarks corresponding to a full-text search
      *
      * Searches:
      *  - in the URLs, title and description;
@@ -174,7 +184,7 @@ class LinkFilter
      *  - see https://github.com/shaarli/Shaarli/issues/75 for examples
      *
      * @param string $searchterms search query.
-     * @param string $visibility  Optional: return only all/private/public links.
+     * @param string $visibility  Optional: return only all/private/public bookmarks.
      *
      * @return array search results.
      */
@@ -206,25 +216,23 @@ class LinkFilter
             }
         }
 
-        $keys = array('title', 'description', 'url', 'tags');
-
         // Iterate over every stored link.
-        foreach ($this->links as $id => $link) {
-            // ignore non private links when 'privatonly' is on.
+        foreach ($this->bookmarks as $id => $link) {
+            // ignore non private bookmarks when 'privatonly' is on.
             if ($visibility !== 'all') {
-                if (!$link['private'] && $visibility === 'private') {
+                if (!$link->isPrivate() && $visibility === 'private') {
                     continue;
-                } elseif ($link['private'] && $visibility === 'public') {
+                } elseif ($link->isPrivate() && $visibility === 'public') {
                     continue;
                 }
             }
 
             // Concatenate link fields to search across fields.
             // Adds a '\' separator for exact search terms.
-            $content = '';
-            foreach ($keys as $key) {
-                $content .= mb_convert_case($link[$key], MB_CASE_LOWER, 'UTF-8') . '\\';
-            }
+            $content  = mb_convert_case($link->getTitle(), MB_CASE_LOWER, 'UTF-8') .'\\';
+            $content .= mb_convert_case($link->getDescription(), MB_CASE_LOWER, 'UTF-8') .'\\';
+            $content .= mb_convert_case($link->getUrl(), MB_CASE_LOWER, 'UTF-8') .'\\';
+            $content .= mb_convert_case($link->getTagsString(), MB_CASE_LOWER, 'UTF-8') .'\\';
 
             // Be optimistic
             $found = true;
@@ -301,16 +309,16 @@ class LinkFilter
     }
 
     /**
-     * Returns the list of links associated with a given list of tags
+     * Returns the list of bookmarks associated with a given list of tags
      *
      * You can specify one or more tags, separated by space or a comma, e.g.
      *  print_r($mydb->filterTags('linux programming'));
      *
      * @param string $tags          list of tags separated by commas or blank spaces.
      * @param bool   $casesensitive ignore case if false.
-     * @param string $visibility    Optional: return only all/private/public links.
+     * @param string $visibility    Optional: return only all/private/public bookmarks.
      *
-     * @return array filtered links.
+     * @return array filtered bookmarks.
      */
     public function filterTags($tags, $casesensitive = false, $visibility = 'all')
     {
@@ -326,6 +334,17 @@ class LinkFilter
             return $this->noFilter($visibility);
         }
 
+        // If we only have public visibility, we can't look for hidden tags
+        if ($visibility === self::$PUBLIC) {
+            $inputTags = array_values(array_filter($inputTags, function ($tag) {
+                return ! startsWith($tag, '.');
+            }));
+
+            if (empty($inputTags)) {
+                return [];
+            }
+        }
+
         // build regex from all tags
         $re = '/^' . implode(array_map("self::tag2regex", $inputTags)) . '.*$/';
         if (!$casesensitive) {
@@ -334,27 +353,27 @@ class LinkFilter
         }
 
         // create resulting array
-        $filtered = array();
+        $filtered = [];
 
         // iterate over each link
-        foreach ($this->links as $key => $link) {
+        foreach ($this->bookmarks as $key => $link) {
             // check level of visibility
-            // ignore non private links when 'privateonly' is on.
+            // ignore non private bookmarks when 'privateonly' is on.
             if ($visibility !== 'all') {
-                if (!$link['private'] && $visibility === 'private') {
+                if (!$link->isPrivate() && $visibility === 'private') {
                     continue;
-                } elseif ($link['private'] && $visibility === 'public') {
+                } elseif ($link->isPrivate() && $visibility === 'public') {
                     continue;
                 }
             }
-            $search = $link['tags']; // build search string, start with tags of current link
-            if (strlen(trim($link['description'])) && strpos($link['description'], '#') !== false) {
+            $search = $link->getTagsString(); // build search string, start with tags of current link
+            if (strlen(trim($link->getDescription())) && strpos($link->getDescription(), '#') !== false) {
                 // description given and at least one possible tag found
                 $descTags = array();
                 // find all tags in the form of #tag in the description
                 preg_match_all(
                     '/(?<![' . self::$HASHTAG_CHARS . '])#([' . self::$HASHTAG_CHARS . ']+?)\b/sm',
-                    $link['description'],
+                    $link->getDescription(),
                     $descTags
                 );
                 if (count($descTags[1])) {
@@ -373,25 +392,25 @@ class LinkFilter
     }
 
     /**
-     * Return only links without any tag.
+     * Return only bookmarks without any tag.
      *
-     * @param string $visibility return only all/private/public links.
+     * @param string $visibility return only all/private/public bookmarks.
      *
-     * @return array filtered links.
+     * @return array filtered bookmarks.
      */
     public function filterUntagged($visibility)
     {
         $filtered = [];
-        foreach ($this->links as $key => $link) {
+        foreach ($this->bookmarks as $key => $link) {
             if ($visibility !== 'all') {
-                if (!$link['private'] && $visibility === 'private') {
+                if (!$link->isPrivate() && $visibility === 'private') {
                     continue;
-                } elseif ($link['private'] && $visibility === 'public') {
+                } elseif ($link->isPrivate() && $visibility === 'public') {
                     continue;
                 }
             }
 
-            if (empty(trim($link['tags']))) {
+            if (empty(trim($link->getTagsString()))) {
                 $filtered[$key] = $link;
             }
         }
@@ -406,21 +425,26 @@ class LinkFilter
      *  print_r($mydb->filterDay('20120125'));
      *
      * @param string $day day to filter.
-     *
+     * @param string $visibility return only all/private/public bookmarks.
+
      * @return array all link matching given day.
      *
      * @throws Exception if date format is invalid.
      */
-    public function filterDay($day)
+    public function filterDay($day, $visibility)
     {
         if (!checkDateFormat('Ymd', $day)) {
             throw new Exception('Invalid date format');
         }
 
-        $filtered = array();
-        foreach ($this->links as $key => $l) {
-            if ($l['created']->format('Ymd') == $day) {
-                $filtered[$key] = $l;
+        $filtered = [];
+        foreach ($this->bookmarks as $key => $bookmark) {
+            if ($visibility === static::$PUBLIC && $bookmark->isPrivate()) {
+                continue;
+            }
+
+            if ($bookmark->getCreated()->format('Ymd') == $day) {
+                $filtered[$key] = $bookmark;
             }
         }
 
diff --git a/application/bookmark/BookmarkIO.php b/application/bookmark/BookmarkIO.php
new file mode 100644
index 00000000..6bf7f365
--- /dev/null
+++ b/application/bookmark/BookmarkIO.php
@@ -0,0 +1,108 @@
+<?php
+
+namespace Shaarli\Bookmark;
+
+use Shaarli\Bookmark\Exception\DatastoreNotInitializedException;
+use Shaarli\Bookmark\Exception\EmptyDataStoreException;
+use Shaarli\Bookmark\Exception\NotWritableDataStoreException;
+use Shaarli\Config\ConfigManager;
+
+/**
+ * Class BookmarkIO
+ *
+ * This class performs read/write operation to the file data store.
+ * Used by BookmarkFileService.
+ *
+ * @package Shaarli\Bookmark
+ */
+class BookmarkIO
+{
+    /**
+     * @var string Datastore file path
+     */
+    protected $datastore;
+
+    /**
+     * @var ConfigManager instance
+     */
+    protected $conf;
+
+    /**
+     * string Datastore PHP prefix
+     */
+    protected static $phpPrefix = '<?php /* ';
+
+    /**
+     * string Datastore PHP suffix
+     */
+    protected static $phpSuffix = ' */ ?>';
+
+    /**
+     * LinksIO constructor.
+     *
+     * @param ConfigManager $conf instance
+     */
+    public function __construct($conf)
+    {
+        $this->conf = $conf;
+        $this->datastore = $conf->get('resource.datastore');
+    }
+
+    /**
+     * Reads database from disk to memory
+     *
+     * @return BookmarkArray instance
+     *
+     * @throws NotWritableDataStoreException    Data couldn't be loaded
+     * @throws EmptyDataStoreException          Datastore file exists but does not contain any bookmark
+     * @throws DatastoreNotInitializedException File does not exists
+     */
+    public function read()
+    {
+        if (! file_exists($this->datastore)) {
+            throw new DatastoreNotInitializedException();
+        }
+
+        if (!is_writable($this->datastore)) {
+            throw new NotWritableDataStoreException($this->datastore);
+        }
+
+        // Note that gzinflate is faster than gzuncompress.
+        // See: http://www.php.net/manual/en/function.gzdeflate.php#96439
+        $links = unserialize(gzinflate(base64_decode(
+            substr(file_get_contents($this->datastore),
+                strlen(self::$phpPrefix), -strlen(self::$phpSuffix)))));
+
+        if (empty($links)) {
+            if (filesize($this->datastore) > 100) {
+                throw new NotWritableDataStoreException($this->datastore);
+            }
+            throw new EmptyDataStoreException();
+        }
+
+        return $links;
+    }
+
+    /**
+     * Saves the database from memory to disk
+     *
+     * @param BookmarkArray $links instance.
+     *
+     * @throws NotWritableDataStoreException the datastore is not writable
+     */
+    public function write($links)
+    {
+        if (is_file($this->datastore) && !is_writeable($this->datastore)) {
+            // The datastore exists but is not writeable
+            throw new NotWritableDataStoreException($this->datastore);
+        } else if (!is_file($this->datastore) && !is_writeable(dirname($this->datastore))) {
+            // The datastore does not exist and its parent directory is not writeable
+            throw new NotWritableDataStoreException(dirname($this->datastore));
+        }
+
+        file_put_contents(
+            $this->datastore,
+            self::$phpPrefix.base64_encode(gzdeflate(serialize($links))).self::$phpSuffix
+        );
+    }
+}
diff --git a/application/bookmark/BookmarkInitializer.php b/application/bookmark/BookmarkInitializer.php
new file mode 100644
index 00000000..815047e3
--- /dev/null
+++ b/application/bookmark/BookmarkInitializer.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace Shaarli\Bookmark;
+
+/**
+ * Class BookmarkInitializer
+ *
+ * This class is used to initialized default bookmarks after a fresh install of Shaarli.
+ * It should be only called if the datastore file does not exist(users might want to delete the default bookmarks).
+ *
+ * To prevent data corruption, it does not overwrite existing bookmarks,
+ * even though there should not be any.
+ *
+ * @package Shaarli\Bookmark
+ */
+class BookmarkInitializer
+{
+    /** @var BookmarkServiceInterface */
+    protected $bookmarkService;
+
+    /**
+     * BookmarkInitializer constructor.
+     *
+     * @param BookmarkServiceInterface $bookmarkService
+     */
+    public function __construct($bookmarkService)
+    {
+        $this->bookmarkService = $bookmarkService;
+    }
+
+    /**
+     * Initialize the data store with default bookmarks
+     */
+    public function initialize()
+    {
+        $bookmark = new Bookmark();
+        $bookmark->setTitle('quicksilver (loop) on Vimeo ' . t('(private bookmark with thumbnail demo)'));
+        $bookmark->setUrl('https://vimeo.com/153493904');
+        $bookmark->setDescription(t(
+'Shaarli will automatically pick up the thumbnail for links to a variety of websites.
+
+Explore your new Shaarli instance by trying out controls and menus.
+Visit the project on [Github](https://github.com/shaarli/Shaarli) or [the documentation](https://shaarli.readthedocs.io/en/master/) to learn more about Shaarli.
+
+Now you can edit or delete the default shaares.
+'
+        ));
+        $bookmark->setTagsString('shaarli help thumbnail');
+        $bookmark->setPrivate(true);
+        $this->bookmarkService->add($bookmark, false);
+
+        $bookmark = new Bookmark();
+        $bookmark->setTitle(t('Note: Shaare descriptions'));
+        $bookmark->setDescription(t(
+'Adding a shaare without entering a URL creates a text-only "note" post such as this one.
+This note is private, so you are the only one able to see it while logged in.
+
+You can use this to keep notes, post articles, code snippets, and much more.
+
+The Markdown formatting setting allows you to format your notes and bookmark description:
+
+### Title headings
+
+#### Multiple headings levels
+  * bullet lists
+  * _italic_ text
+  * **bold** text
+  * ~~strike through~~ text
+  * `code` blocks
+  * images
+  * [links](https://en.wikipedia.org/wiki/Markdown)
+
+Markdown also supports tables:
+
+| Name    | Type      | Color  | Qty   |
+| ------- | --------- | ------ | ----- |
+| Orange  | Fruit     | Orange | 126   |
+| Apple   | Fruit     | Any    | 62    |
+| Lemon   | Fruit     | Yellow | 30    |
+| Carrot  | Vegetable | Red    | 14    |
+'
+        ));
+        $bookmark->setTagsString('shaarli help');
+        $bookmark->setPrivate(true);
+        $this->bookmarkService->add($bookmark, false);
+
+        $bookmark = new Bookmark();
+        $bookmark->setTitle(
+            'Shaarli - ' . t('The personal, minimalist, super-fast, database free, bookmarking service')
+        );
+        $bookmark->setDescription(t(
+'Welcome to Shaarli!
+
+Shaarli allows you to bookmark your favorite pages, and share them with others or store them privately.
+You can add a description to your bookmarks, such as this one, and tag them.
+
+Create a new shaare by clicking the `+Shaare` button, or using any of the recommended tools (browser extension, mobile app, bookmarklet, REST API, etc.).
+
+You can easily retrieve your links, even with thousands of them, using the internal search engine, or search through tags (e.g. this Shaare is tagged with `shaarli` and `help`).
+Hashtags such as #shaarli #help are also supported.
+You can also filter the available [RSS feed](/feed/atom) and picture wall by tag or plaintext search.
+
+We hope that you will enjoy using Shaarli, maintained with ❤️ by the community!
+Feel free to open [an issue](https://github.com/shaarli/Shaarli/issues) if you have a suggestion or encounter an issue.
+'
+        ));
+        $bookmark->setTagsString('shaarli help');
+        $this->bookmarkService->add($bookmark, false);
+    }
+}
diff --git a/application/bookmark/BookmarkServiceInterface.php b/application/bookmark/BookmarkServiceInterface.php
new file mode 100644
index 00000000..b9b483eb
--- /dev/null
+++ b/application/bookmark/BookmarkServiceInterface.php
@@ -0,0 +1,186 @@
+<?php
+
+namespace Shaarli\Bookmark;
+
+
+use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
+use Shaarli\Bookmark\Exception\NotWritableDataStoreException;
+use Shaarli\Config\ConfigManager;
+use Shaarli\History;
+
+/**
+ * Class BookmarksService
+ *
+ * This is the entry point to manipulate the bookmark DB.
+ */
+interface BookmarkServiceInterface
+{
+    /**
+     * BookmarksService constructor.
+     *
+     * @param ConfigManager $conf       instance
+     * @param History       $history    instance
+     * @param bool          $isLoggedIn true if the current user is logged in
+     */
+    public function __construct(ConfigManager $conf, History $history, $isLoggedIn);
+
+    /**
+     * Find a bookmark by hash
+     *
+     * @param string $hash
+     *
+     * @return mixed
+     *
+     * @throws \Exception
+     */
+    public function findByHash($hash);
+
+    /**
+     * @param $url
+     *
+     * @return Bookmark|null
+     */
+    public function findByUrl($url);
+
+    /**
+     * Search bookmarks
+     *
+     * @param mixed  $request
+     * @param string $visibility
+     * @param bool   $caseSensitive
+     * @param bool   $untaggedOnly
+     * @param bool   $ignoreSticky
+     *
+     * @return Bookmark[]
+     */
+    public function search(
+        $request = [],
+        $visibility = null,
+        $caseSensitive = false,
+        $untaggedOnly = false,
+        bool $ignoreSticky = false
+    );
+
+    /**
+     * Get a single bookmark by its ID.
+     *
+     * @param int    $id         Bookmark ID
+     * @param string $visibility all|public|private e.g. with public, accessing a private bookmark will throw an
+     *                           exception
+     *
+     * @return Bookmark
+     *
+     * @throws BookmarkNotFoundException
+     * @throws \Exception
+     */
+    public function get($id, $visibility = null);
+
+    /**
+     * Updates an existing bookmark (depending on its ID).
+     *
+     * @param Bookmark $bookmark
+     * @param bool     $save Writes to the datastore if set to true
+     *
+     * @return Bookmark Updated bookmark
+     *
+     * @throws BookmarkNotFoundException
+     * @throws \Exception
+     */
+    public function set($bookmark, $save = true);
+
+    /**
+     * Adds a new bookmark (the ID must be empty).
+     *
+     * @param Bookmark $bookmark
+     * @param bool     $save Writes to the datastore if set to true
+     *
+     * @return Bookmark new bookmark
+     *
+     * @throws \Exception
+     */
+    public function add($bookmark, $save = true);
+
+    /**
+     * Adds or updates a bookmark depending on its ID:
+     *   - a Bookmark without ID will be added
+     *   - a Bookmark with an existing ID will be updated
+     *
+     * @param Bookmark $bookmark
+     * @param bool     $save
+     *
+     * @return Bookmark
+     *
+     * @throws \Exception
+     */
+    public function addOrSet($bookmark, $save = true);
+
+    /**
+     * Deletes a bookmark.
+     *
+     * @param Bookmark $bookmark
+     * @param bool     $save
+     *
+     * @throws \Exception
+     */
+    public function remove($bookmark, $save = true);
+
+    /**
+     * Get a single bookmark by its ID.
+     *
+     * @param int    $id         Bookmark ID
+     * @param string $visibility all|public|private e.g. with public, accessing a private bookmark will throw an
+     *                           exception
+     *
+     * @return bool
+     */
+    public function exists($id, $visibility = null);
+
+    /**
+     * Return the number of available bookmarks for given visibility.
+     *
+     * @param string $visibility public|private|all
+     *
+     * @return int Number of bookmarks
+     */
+    public function count($visibility = null);
+
+    /**
+     * Write the datastore.
+     *
+     * @throws NotWritableDataStoreException
+     */
+    public function save();
+
+    /**
+     * Returns the list tags appearing in the bookmarks with the given tags
+     *
+     * @param array  $filteringTags tags selecting the bookmarks to consider
+     * @param string $visibility    process only all/private/public bookmarks
+     *
+     * @return array tag => bookmarksCount
+     */
+    public function bookmarksCountPerTag($filteringTags = [], $visibility = 'all');
+
+    /**
+     * Returns the list of days containing articles (oldest first)
+     *
+     * @return array containing days (in format YYYYMMDD).
+     */
+    public function days();
+
+    /**
+     * Returns the list of articles for a given day.
+     *
+     * @param string $request day to filter. Format: YYYYMMDD.
+     *
+     * @return Bookmark[] list of shaare found.
+     *
+     * @throws BookmarkNotFoundException
+     */
+    public function filterDay($request);
+
+    /**
+     * Creates the default database after a fresh install.
+     */
+    public function initialize();
+}
diff --git a/application/bookmark/LinkDB.php b/application/bookmark/LinkDB.php
deleted file mode 100644
index 76ba95f0..00000000
--- a/application/bookmark/LinkDB.php
+++ /dev/null
@@ -1,575 +0,0 @@
-<?php
-
-namespace Shaarli\Bookmark;
-
-use ArrayAccess;
-use Countable;
-use DateTime;
-use Iterator;
-use Shaarli\Bookmark\Exception\LinkNotFoundException;
-use Shaarli\Exceptions\IOException;
-use Shaarli\FileUtils;
-
-/**
- * Data storage for links.
- *
- * This object behaves like an associative array.
- *
- * Example:
- *    $myLinks = new LinkDB();
- *    echo $myLinks[350]['title'];
- *    foreach ($myLinks as $link)
- *       echo $link['title'].' at url '.$link['url'].'; description:'.$link['description'];
- *
- * Available keys:
- *  - id:       primary key, incremental integer identifier (persistent)
- *  - description: description of the entry
- *  - created:  creation date of this entry, DateTime object.
- *  - updated:  last modification date of this entry, DateTime object.
- *  - private:  Is this link private? 0=no, other value=yes
- *  - tags:     tags attached to this entry (separated by spaces)
- *  - title     Title of the link
- *  - url       URL of the link. Used for displayable links.
- *              Can be absolute or relative in the database but the relative links
- *              will be converted to absolute ones in templates.
- *  - real_url  Raw URL in stored in the DB (absolute or relative).
- *  - shorturl  Permalink smallhash
- *
- * Implements 3 interfaces:
- *  - ArrayAccess: behaves like an associative array;
- *  - Countable:   there is a count() method;
- *  - Iterator:    usable in foreach () loops.
- *
- * ID mechanism:
- *   ArrayAccess is implemented in a way that will allow to access a link
- *   with the unique identifier ID directly with $link[ID].
- *   Note that it's not the real key of the link array attribute.
- *   This mechanism is in place to have persistent link IDs,
- *   even though the internal array is reordered by date.
- *   Example:
- *     - DB: link #1 (2010-01-01) link #2 (2016-01-01)
- *     - Order: #2 #1
- *     - Import links containing: link #3 (2013-01-01)
- *     - New DB: link #1 (2010-01-01) link #2 (2016-01-01) link #3 (2013-01-01)
- *     - Real order: #2 #3 #1
- */
-class LinkDB implements Iterator, Countable, ArrayAccess
-{
-    // Links are stored as a PHP serialized string
-    private $datastore;
-
-    // Link date storage format
-    const LINK_DATE_FORMAT = 'Ymd_His';
-
-    // List of links (associative array)
-    //  - key:   link date (e.g. "20110823_124546"),
-    //  - value: associative array (keys: title, description...)
-    private $links;
-
-    // List of all recorded URLs (key=url, value=link offset)
-    // for fast reserve search (url-->link offset)
-    private $urls;
-
-    /**
-     * @var array List of all links IDS mapped with their array offset.
-     *            Map: id->offset.
-     */
-    protected $ids;
-
-    // List of offset keys (for the Iterator interface implementation)
-    private $keys;
-
-    // Position in the $this->keys array (for the Iterator interface)
-    private $position;
-
-    // Is the user logged in? (used to filter private links)
-    private $loggedIn;
-
-    // Hide public links
-    private $hidePublicLinks;
-
-    /**
-     * Creates a new LinkDB
-     *
-     * Checks if the datastore exists; else, attempts to create a dummy one.
-     *
-     * @param string  $datastore        datastore file path.
-     * @param boolean $isLoggedIn       is the user logged in?
-     * @param boolean $hidePublicLinks  if true all links are private.
-     */
-    public function __construct(
-        $datastore,
-        $isLoggedIn,
-        $hidePublicLinks
-    ) {
-
-        $this->datastore = $datastore;
-        $this->loggedIn = $isLoggedIn;
-        $this->hidePublicLinks = $hidePublicLinks;
-        $this->check();
-        $this->read();
-    }
-
-    /**
-     * Countable - Counts elements of an object
-     */
-    public function count()
-    {
-        return count($this->links);
-    }
-
-    /**
-     * ArrayAccess - Assigns a value to the specified offset
-     */
-    public function offsetSet($offset, $value)
-    {
-        // TODO: use exceptions instead of "die"
-        if (!$this->loggedIn) {
-            die(t('You are not authorized to add a link.'));
-        }
-        if (!isset($value['id']) || empty($value['url'])) {
-            die(t('Internal Error: A link should always have an id and URL.'));
-        }
-        if (($offset !== null && !is_int($offset)) || !is_int($value['id'])) {
-            die(t('You must specify an integer as a key.'));
-        }
-        if ($offset !== null && $offset !== $value['id']) {
-            die(t('Array offset and link ID must be equal.'));
-        }
-
-        // If the link exists, we reuse the real offset, otherwise new entry
-        $existing = $this->getLinkOffset($offset);
-        if ($existing !== null) {
-            $offset = $existing;
-        } else {
-            $offset = count($this->links);
-        }
-        $this->links[$offset] = $value;
-        $this->urls[$value['url']] = $offset;
-        $this->ids[$value['id']] = $offset;
-    }
-
-    /**
-     * ArrayAccess - Whether or not an offset exists
-     */
-    public function offsetExists($offset)
-    {
-        return array_key_exists($this->getLinkOffset($offset), $this->links);
-    }
-
-    /**
-     * ArrayAccess - Unsets an offset
-     */
-    public function offsetUnset($offset)
-    {
-        if (!$this->loggedIn) {
-            // TODO: raise an exception
-            die('You are not authorized to delete a link.');
-        }
-        $realOffset = $this->getLinkOffset($offset);
-        $url = $this->links[$realOffset]['url'];
-        unset($this->urls[$url]);
-        unset($this->ids[$realOffset]);
-        unset($this->links[$realOffset]);
-    }
-
-    /**
-     * ArrayAccess - Returns the value at specified offset
-     */
-    public function offsetGet($offset)
-    {
-        $realOffset = $this->getLinkOffset($offset);
-        return isset($this->links[$realOffset]) ? $this->links[$realOffset] : null;
-    }
-
-    /**
-     * Iterator - Returns the current element
-     */
-    public function current()
-    {
-        return $this[$this->keys[$this->position]];
-    }
-
-    /**
-     * Iterator - Returns the key of the current element
-     */
-    public function key()
-    {
-        return $this->keys[$this->position];
-    }
-
-    /**
-     * Iterator - Moves forward to next element
-     */
-    public function next()
-    {
-        ++$this->position;
-    }
-
-    /**
-     * Iterator - Rewinds the Iterator to the first element
-     *
-     * Entries are sorted by date (latest first)
-     */
-    public function rewind()
-    {
-        $this->keys = array_keys($this->ids);
-        $this->position = 0;
-    }
-
-    /**
-     * Iterator - Checks if current position is valid
-     */
-    public function valid()
-    {
-        return isset($this->keys[$this->position]);
-    }
-
-    /**
-     * Checks if the DB directory and file exist
-     *
-     * If no DB file is found, creates a dummy DB.
-     */
-    private function check()
-    {
-        if (file_exists($this->datastore)) {
-            return;
-        }
-
-        // Create a dummy database for example
-        $this->links = array();
-        $link = array(
-            'id' => 1,
-            'title' => t('The personal, minimalist, super-fast, database free, bookmarking service'),
-            'url' => 'https://shaarli.readthedocs.io',
-            'description' => t(
-                'Welcome to Shaarli! This is your first public bookmark. '
-                . 'To edit or delete me, you must first login.
-
-To learn how to use Shaarli, consult the link "Documentation" at the bottom of this page.
-
-You use the community supported version of the original Shaarli project, by Sebastien Sauvage.'
-            ),
-            'private' => 0,
-            'created' => new DateTime(),
-            'tags' => 'opensource software',
-            'sticky' => false,
-        );
-        $link['shorturl'] = link_small_hash($link['created'], $link['id']);
-        $this->links[1] = $link;
-
-        $link = array(
-            'id' => 0,
-            'title' => t('My secret stuff... - Pastebin.com'),
-            'url' => 'http://sebsauvage.net/paste/?8434b27936c09649#bR7XsXhoTiLcqCpQbmOpBi3rq2zzQUC5hBI7ZT1O3x8=',
-            'description' => t('Shhhh! I\'m a private link only YOU can see. You can delete me too.'),
-            'private' => 1,
-            'created' => new DateTime('1 minute ago'),
-            'tags' => 'secretstuff',
-            'sticky' => false,
-        );
-        $link['shorturl'] = link_small_hash($link['created'], $link['id']);
-        $this->links[0] = $link;
-
-        // Write database to disk
-        $this->write();
-    }
-
-    /**
-     * Reads database from disk to memory
-     */
-    private function read()
-    {
-        // Public links are hidden and user not logged in => nothing to show
-        if ($this->hidePublicLinks && !$this->loggedIn) {
-            $this->links = array();
-            return;
-        }
-
-        $this->urls = [];
-        $this->ids = [];
-        $this->links = FileUtils::readFlatDB($this->datastore, []);
-
-        $toremove = array();
-        foreach ($this->links as $key => &$link) {
-            if (!$this->loggedIn && $link['private'] != 0) {
-                // Transition for not upgraded databases.
-                unset($this->links[$key]);
-                continue;
-            }
-
-            // Sanitize data fields.
-            sanitizeLink($link);
-
-            // Remove private tags if the user is not logged in.
-            if (!$this->loggedIn) {
-                $link['tags'] = preg_replace('/(^|\s+)\.[^($|\s)]+\s*/', ' ', $link['tags']);
-            }
-
-            $link['real_url'] = $link['url'];
-
-            $link['sticky'] = isset($link['sticky']) ? $link['sticky'] : false;
-
-            // To be able to load links before running the update, and prepare the update
-            if (!isset($link['created'])) {
-                $link['id'] = $link['linkdate'];
-                $link['created'] = DateTime::createFromFormat(self::LINK_DATE_FORMAT, $link['linkdate']);
-                if (!empty($link['updated'])) {
-                    $link['updated'] = DateTime::createFromFormat(self::LINK_DATE_FORMAT, $link['updated']);
-                }
-                $link['shorturl'] = smallHash($link['linkdate']);
-            }
-
-            $this->urls[$link['url']] = $key;
-            $this->ids[$link['id']] = $key;
-        }
-    }
-
-    /**
-     * Saves the database from memory to disk
-     *
-     * @throws IOException the datastore is not writable
-     */
-    private function write()
-    {
-        $this->reorder();
-        FileUtils::writeFlatDB($this->datastore, $this->links);
-    }
-
-    /**
-     * Saves the database from memory to disk
-     *
-     * @param string $pageCacheDir page cache directory
-     */
-    public function save($pageCacheDir)
-    {
-        if (!$this->loggedIn) {
-            // TODO: raise an Exception instead
-            die('You are not authorized to change the database.');
-        }
-
-        $this->write();
-
-        invalidateCaches($pageCacheDir);
-    }
-
-    /**
-     * Returns the link for a given URL, or False if it does not exist.
-     *
-     * @param string $url URL to search for
-     *
-     * @return mixed the existing link if it exists, else 'false'
-     */
-    public function getLinkFromUrl($url)
-    {
-        if (isset($this->urls[$url])) {
-            return $this->links[$this->urls[$url]];
-        }
-        return false;
-    }
-
-    /**
-     * Returns the shaare corresponding to a smallHash.
-     *
-     * @param string $request QUERY_STRING server parameter.
-     *
-     * @return array $filtered array containing permalink data.
-     *
-     * @throws LinkNotFoundException if the smallhash is malformed or doesn't match any link.
-     */
-    public function filterHash($request)
-    {
-        $request = substr($request, 0, 6);
-        $linkFilter = new LinkFilter($this->links);
-        return $linkFilter->filter(LinkFilter::$FILTER_HASH, $request);
-    }
-
-    /**
-     * Returns the list of articles for a given day.
-     *
-     * @param string $request day to filter. Format: YYYYMMDD.
-     *
-     * @return array list of shaare found.
-     */
-    public function filterDay($request)
-    {
-        $linkFilter = new LinkFilter($this->links);
-        return $linkFilter->filter(LinkFilter::$FILTER_DAY, $request);
-    }
-
-    /**
-     * Filter links according to search parameters.
-     *
-     * @param array  $filterRequest  Search request content. Supported keys:
-     *                                - searchtags: list of tags
-     *                                - searchterm: term search
-     * @param bool   $casesensitive  Optional: Perform case sensitive filter
-     * @param string $visibility     return only all/private/public links
-     * @param bool   $untaggedonly   return only untagged links
-     *
-     * @return array filtered links, all links if no suitable filter was provided.
-     */
-    public function filterSearch(
-        $filterRequest = array(),
-        $casesensitive = false,
-        $visibility = 'all',
-        $untaggedonly = false
-    ) {
-
-        // Filter link database according to parameters.
-        $searchtags = isset($filterRequest['searchtags']) ? escape($filterRequest['searchtags']) : '';
-        $searchterm = isset($filterRequest['searchterm']) ? escape($filterRequest['searchterm']) : '';
-
-        // Search tags + fullsearch - blank string parameter will return all links.
-        $type = LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT; // == "vuotext"
-        $request = [$searchtags, $searchterm];
-
-        $linkFilter = new LinkFilter($this);
-        return $linkFilter->filter($type, $request, $casesensitive, $visibility, $untaggedonly);
-    }
-
-    /**
-     * Returns the list tags appearing in the links with the given tags
-     *
-     * @param array  $filteringTags tags selecting the links to consider
-     * @param string $visibility    process only all/private/public links
-     *
-     * @return array tag => linksCount
-     */
-    public function linksCountPerTag($filteringTags = [], $visibility = 'all')
-    {
-        $links = $this->filterSearch(['searchtags' => $filteringTags], false, $visibility);
-        $tags = [];
-        $caseMapping = [];
-        foreach ($links as $link) {
-            foreach (preg_split('/\s+/', $link['tags'], 0, PREG_SPLIT_NO_EMPTY) as $tag) {
-                if (empty($tag)) {
-                    continue;
-                }
-                // The first case found will be displayed.
-                if (!isset($caseMapping[strtolower($tag)])) {
-                    $caseMapping[strtolower($tag)] = $tag;
-                    $tags[$caseMapping[strtolower($tag)]] = 0;
-                }
-                $tags[$caseMapping[strtolower($tag)]]++;
-            }
-        }
-
-        /*
-         * Formerly used arsort(), which doesn't define the sort behaviour for equal values.
-         * Also, this function doesn't produce the same result between PHP 5.6 and 7.
-         *
-         * So we now use array_multisort() to sort tags by DESC occurrences,
-         * then ASC alphabetically for equal values.
-         *
-         * @see https://github.com/shaarli/Shaarli/issues/1142
-         */
-        $keys = array_keys($tags);
-        $tmpTags = array_combine($keys, $keys);
-        array_multisort($tags, SORT_DESC, $tmpTags, SORT_ASC, $tags);
-        return $tags;
-    }
-
-    /**
-     * Rename or delete a tag across all links.
-     *
-     * @param string $from Tag to rename
-     * @param string $to   New tag. If none is provided, the from tag will be deleted
-     *
-     * @return array|bool List of altered links or false on error
-     */
-    public function renameTag($from, $to)
-    {
-        if (empty($from)) {
-            return false;
-        }
-        $delete = empty($to);
-        // True for case-sensitive tag search.
-        $linksToAlter = $this->filterSearch(['searchtags' => $from], true);
-        foreach ($linksToAlter as $key => &$value) {
-            $tags = preg_split('/\s+/', trim($value['tags']));
-            if (($pos = array_search($from, $tags)) !== false) {
-                if ($delete) {
-                    unset($tags[$pos]); // Remove tag.
-                } else {
-                    $tags[$pos] = trim($to);
-                }
-                $value['tags'] = trim(implode(' ', array_unique($tags)));
-                $this[$value['id']] = $value;
-            }
-        }
-
-        return $linksToAlter;
-    }
-
-    /**
-     * Returns the list of days containing articles (oldest first)
-     * Output: An array containing days (in format YYYYMMDD).
-     */
-    public function days()
-    {
-        $linkDays = array();
-        foreach ($this->links as $link) {
-            $linkDays[$link['created']->format('Ymd')] = 0;
-        }
-        $linkDays = array_keys($linkDays);
-        sort($linkDays);
-
-        return $linkDays;
-    }
-
-    /**
-     * Reorder links by creation date (newest first).
-     *
-     * Also update the urls and ids mapping arrays.
-     *
-     * @param string $order ASC|DESC
-     */
-    public function reorder($order = 'DESC')
-    {
-        $order = $order === 'ASC' ? -1 : 1;
-        // Reorder array by dates.
-        usort($this->links, function ($a, $b) use ($order) {
-            if (isset($a['sticky']) && isset($b['sticky']) && $a['sticky'] !== $b['sticky']) {
-                return $a['sticky'] ? -1 : 1;
-            }
-            return $a['created'] < $b['created'] ? 1 * $order : -1 * $order;
-        });
-
-        $this->urls = [];
-        $this->ids = [];
-        foreach ($this->links as $key => $link) {
-            $this->urls[$link['url']] = $key;
-            $this->ids[$link['id']] = $key;
-        }
-    }
-
-    /**
-     * Return the next key for link creation.
-     * E.g. If the last ID is 597, the next will be 598.
-     *
-     * @return int next ID.
-     */
-    public function getNextId()
-    {
-        if (!empty($this->ids)) {
-            return max(array_keys($this->ids)) + 1;
-        }
-        return 0;
-    }
-
-    /**
-     * Returns a link offset in links array from its unique ID.
-     *
-     * @param int $id Persistent ID of a link.
-     *
-     * @return int Real offset in local array, or null if doesn't exist.
-     */
-    protected function getLinkOffset($id)
-    {
-        if (isset($this->ids[$id])) {
-            return $this->ids[$id];
-        }
-        return null;
-    }
-}
diff --git a/application/bookmark/LinkUtils.php b/application/bookmark/LinkUtils.php
index 77eb2d95..e7af4d55 100644
--- a/application/bookmark/LinkUtils.php
+++ b/application/bookmark/LinkUtils.php
@@ -1,112 +1,6 @@
 <?php
 
-use Shaarli\Bookmark\LinkDB;
-
-/**
- * Get cURL callback function for CURLOPT_WRITEFUNCTION
- *
- * @param string $charset     to extract from the downloaded page (reference)
- * @param string $title       to extract from the downloaded page (reference)
- * @param string $description to extract from the downloaded page (reference)
- * @param string $keywords    to extract from the downloaded page (reference)
- * @param bool   $retrieveDescription Automatically tries to retrieve description and keywords from HTML content
- * @param string $curlGetInfo Optionally overrides curl_getinfo function
- *
- * @return Closure
- */
-function get_curl_download_callback(
-    &$charset,
-    &$title,
-    &$description,
-    &$keywords,
-    $retrieveDescription,
-    $curlGetInfo = 'curl_getinfo'
-) {
-    $isRedirected = false;
-    $currentChunk = 0;
-    $foundChunk = null;
-
-    /**
-     * cURL callback function for CURLOPT_WRITEFUNCTION (called during the download).
-     *
-     * While downloading the remote page, we check that the HTTP code is 200 and content type is 'html/text'
-     * Then we extract the title and the charset and stop the download when it's done.
-     *
-     * @param resource $ch   cURL resource
-     * @param string   $data chunk of data being downloaded
-     *
-     * @return int|bool length of $data or false if we need to stop the download
-     */
-    return function (&$ch, $data) use (
-        $retrieveDescription,
-        $curlGetInfo,
-        &$charset,
-        &$title,
-        &$description,
-        &$keywords,
-        &$isRedirected,
-        &$currentChunk,
-        &$foundChunk
-    ) {
-        $currentChunk++;
-        $responseCode = $curlGetInfo($ch, CURLINFO_RESPONSE_CODE);
-        if (!empty($responseCode) && in_array($responseCode, [301, 302])) {
-            $isRedirected = true;
-            return strlen($data);
-        }
-        if (!empty($responseCode) && $responseCode !== 200) {
-            return false;
-        }
-        // After a redirection, the content type will keep the previous request value
-        // until it finds the next content-type header.
-        if (! $isRedirected || strpos(strtolower($data), 'content-type') !== false) {
-            $contentType = $curlGetInfo($ch, CURLINFO_CONTENT_TYPE);
-        }
-        if (!empty($contentType) && strpos($contentType, 'text/html') === false) {
-            return false;
-        }
-        if (!empty($contentType) && empty($charset)) {
-            $charset = header_extract_charset($contentType);
-        }
-        if (empty($charset)) {
-            $charset = html_extract_charset($data);
-        }
-        if (empty($title)) {
-            $title = html_extract_title($data);
-            $foundChunk = ! empty($title) ? $currentChunk : $foundChunk;
-        }
-        if ($retrieveDescription && empty($description)) {
-            $description = html_extract_tag('description', $data);
-            $foundChunk = ! empty($description) ? $currentChunk : $foundChunk;
-        }
-        if ($retrieveDescription && empty($keywords)) {
-            $keywords = html_extract_tag('keywords', $data);
-            if (! empty($keywords)) {
-                $foundChunk = $currentChunk;
-                // Keywords use the format tag1, tag2 multiple words, tag
-                // So we format them to match Shaarli's separator and glue multiple words with '-'
-                $keywords = implode(' ', array_map(function($keyword) {
-                    return implode('-', preg_split('/\s+/', trim($keyword)));
-                }, explode(',', $keywords)));
-            }
-        }
-
-        // We got everything we want, stop the download.
-        // If we already found either the title, description or keywords,
-        // it's highly unlikely that we'll found the other metas further than
-        // in the same chunk of data or the next one. So we also stop the download after that.
-        if ((!empty($responseCode) && !empty($contentType) && !empty($charset)) && $foundChunk !== null
-            && (! $retrieveDescription
-                || $foundChunk < $currentChunk
-                || (!empty($title) && !empty($description) && !empty($keywords))
-            )
-        ) {
-            return false;
-        }
-
-        return strlen($data);
-    };
-}
+use Shaarli\Bookmark\Bookmark;
 
 /**
  * Extract title from an HTML document.
@@ -132,7 +26,7 @@ function html_extract_title($html)
  */
 function header_extract_charset($header)
 {
-    preg_match('/charset="?([^; ]+)/i', $header, $match);
+    preg_match('/charset=["\']?([^; "\']+)/i', $header, $match);
     if (! empty($match[1])) {
         return strtolower(trim($match[1]));
     }
@@ -188,30 +82,11 @@ function html_extract_tag($tag, $html)
 }
 
 /**
- * Count private links in given linklist.
- *
- * @param array|Countable $links Linklist.
- *
- * @return int Number of private links.
- */
-function count_private($links)
-{
-    $cpt = 0;
-    foreach ($links as $link) {
-        if ($link['private']) {
-            $cpt += 1;
-        }
-    }
-
-    return $cpt;
-}
-
-/**
- * In a string, converts URLs to clickable links.
+ * In a string, converts URLs to clickable bookmarks.
  *
  * @param string $text       input string.
  *
- * @return string returns $text with all links converted to HTML links.
+ * @return string returns $text with all bookmarks converted to HTML bookmarks.
  *
  * @see Function inspired from http://www.php.net/manual/en/function.preg-replace.php#85722
  */
@@ -239,7 +114,7 @@ function hashtag_autolink($description, $indexUrl = '')
      * \p{Mn} - any non marking space (accents, umlauts, etc)
      */
     $regex = '/(^|\s)#([\p{Pc}\p{N}\p{L}\p{Mn}]+)/mui';
-    $replacement = '$1<a href="'. $indexUrl .'?addtag=$2" title="Hashtag $2">#$2</a>';
+    $replacement = '$1<a href="'. $indexUrl .'./add-tag/$2" title="Hashtag $2">#$2</a>';
     return preg_replace($regex, $replacement, $description);
 }
 
@@ -279,7 +154,7 @@ function format_description($description, $indexUrl = '')
  */
 function link_small_hash($date, $id)
 {
-    return smallHash($date->format(LinkDB::LINK_DATE_FORMAT) . $id);
+    return smallHash($date->format(Bookmark::LINK_DATE_FORMAT) . $id);
 }
 
 /**
diff --git a/application/bookmark/exception/LinkNotFoundException.php b/application/bookmark/exception/BookmarkNotFoundException.php
index f9414428..827a3d35 100644
--- a/application/bookmark/exception/LinkNotFoundException.php
+++ b/application/bookmark/exception/BookmarkNotFoundException.php
@@ -3,7 +3,7 @@ namespace Shaarli\Bookmark\Exception;
 
 use Exception;
 
-class LinkNotFoundException extends Exception
+class BookmarkNotFoundException extends Exception
 {
     /**
      * LinkNotFoundException constructor.
diff --git a/application/bookmark/exception/DatastoreNotInitializedException.php b/application/bookmark/exception/DatastoreNotInitializedException.php
new file mode 100644
index 00000000..f495049d
--- /dev/null
+++ b/application/bookmark/exception/DatastoreNotInitializedException.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shaarli\Bookmark\Exception;
+
+class DatastoreNotInitializedException extends \Exception
+{
+
+}
diff --git a/application/bookmark/exception/EmptyDataStoreException.php b/application/bookmark/exception/EmptyDataStoreException.php
new file mode 100644
index 00000000..cd48c1e6
--- /dev/null
+++ b/application/bookmark/exception/EmptyDataStoreException.php
@@ -0,0 +1,7 @@
+<?php
+
+
+namespace Shaarli\Bookmark\Exception;
+
+
+class EmptyDataStoreException extends \Exception {}
diff --git a/application/bookmark/exception/InvalidBookmarkException.php b/application/bookmark/exception/InvalidBookmarkException.php
new file mode 100644
index 00000000..10c84a6d
--- /dev/null
+++ b/application/bookmark/exception/InvalidBookmarkException.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Shaarli\Bookmark\Exception;
+
+use Shaarli\Bookmark\Bookmark;
+
+class InvalidBookmarkException extends \Exception
+{
+    public function __construct($bookmark)
+    {
+        if ($bookmark instanceof Bookmark) {
+            if ($bookmark->getCreated() instanceof \DateTime) {
+                $created = $bookmark->getCreated()->format(\DateTime::ATOM);
+            } elseif (empty($bookmark->getCreated())) {
+                $created = '';
+            } else {
+                $created = 'Not a DateTime object';
+            }
+            $this->message = 'This bookmark is not valid'. PHP_EOL;
+            $this->message .= ' - ID: '. $bookmark->getId() . PHP_EOL;
+            $this->message .= ' - Title: '. $bookmark->getTitle() . PHP_EOL;
+            $this->message .= ' - Url: '. $bookmark->getUrl() . PHP_EOL;
+            $this->message .= ' - ShortUrl: '. $bookmark->getShortUrl() . PHP_EOL;
+            $this->message .= ' - Created: '. $created . PHP_EOL;
+        } else {
+            $this->message = 'The provided data is not a bookmark'. PHP_EOL;
+            $this->message .= var_export($bookmark, true);
+        }
+    }
+}
diff --git a/application/bookmark/exception/NotWritableDataStoreException.php b/application/bookmark/exception/NotWritableDataStoreException.php
new file mode 100644
index 00000000..95f34b50
--- /dev/null
+++ b/application/bookmark/exception/NotWritableDataStoreException.php
@@ -0,0 +1,19 @@
+<?php
+
+
+namespace Shaarli\Bookmark\Exception;
+
+
+class NotWritableDataStoreException extends \Exception
+{
+    /**
+     * NotReadableDataStore constructor.
+     *
+     * @param string $dataStore file path
+     */
+    public function __construct($dataStore)
+    {
+        $this->message = 'Couldn\'t load data from the data store file "'. $dataStore .'". '.
+            'Your data might be corrupted, or your file isn\'t readable.';
+    }
+}