Bump version

* Extract bookmark view contexts

* Implement basic partial updates for bookmark list and tag cloud

* Refactor confirm button JS into web component

* Refactor bulk edit JS into web component

* Refactor tag autocomplete JS into web component

* Refactor bookmark page JS into web component

* Refactor global shortcuts JS into web component

* Update tests

* Add E2E test for partial updates

* Add partial updates for archived bookmarks

* Add partial updates for shared bookmarks

* Cleanup helpers

* Improve naming in bulk edit

* Refactor shared components into behaviors

* Refactor bulk edit components into behaviors

* Refactor bookmark list components into behaviors

* Update tests

* Combine all scripts into bundle

* Fix E2E CI

.devcontainer/devcontainer.json

@@ -0,0 +1,29 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+	"name": "Python 3",
+	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
+	"features": {
+		"ghcr.io/devcontainers/features/node:1": {}
+	},
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	"forwardPorts": [8000],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "pip3 install --user -r requirements.txt && npm install && mkdir -p data && python3 manage.py migrate",
+
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python"
+			]
+		}
+	},
+
+	"remoteUser": "vscode"
+}

.dockerignore

@@ -6,12 +6,15 @@
 /tmp
 /docs
 /static
+/scripts
 /build
 /out
 /.git
+/.devcontainer
 
 /.dockerignore
 /.gitignore
+/.gitattributes
 /Dockerfile
 /docker-compose.yml
 /*.sh

.env.sample

@@ -45,3 +45,5 @@ LD_DB_HOST=
 # Port use to connect to the database server
 # Should use the default port if not set
 LD_DB_PORT=
+# Any additional options to pass to the database (default: {})
+LD_DB_OPTIONS=

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto
+*.sh text eol=lf

.github/workflows/main.yaml

@@ -41,7 +41,10 @@ jobs:
         run: |
           pip install -r requirements.txt
           playwright install chromium
+      - name: Run build
+        run: |
+          npm run build
           python manage.py compilescss
           python manage.py collectstatic --ignore=*.scss
       - name: Run tests
-        run: python manage.py test bookmarks.e2e
+        run: python manage.py test bookmarks.e2e --pattern="e2e_test_*.py"

.grenrc.js

@@ -1,6 +0,0 @@
-module.exports = {
-    ignoreIssuesWith: [
-        "wontfix",
-        "duplicate"
-    ]
-}

CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## v1.19.0 (20/05/2023)
+
+### What's Changed
+* Add notes to bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/472
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.18.0...v1.19.0
+
+---
+
+## v1.18.0 (18/05/2023)
+
+### What's Changed
+* Make search case-insensitive on Postgres by @sissbruecker in https://github.com/sissbruecker/linkding/pull/432
+* Allow searching for tags without hash character by @sissbruecker in https://github.com/sissbruecker/linkding/pull/449
+* Prevent zoom-in after focusing an input on small viewports on iOS devices by @puresick in https://github.com/sissbruecker/linkding/pull/440
+* Add database options by @plockaby in https://github.com/sissbruecker/linkding/pull/406
+* Allow to log real client ip in logs when using a reverse proxy by @fmenabe in https://github.com/sissbruecker/linkding/pull/398
+* Add option to display URL below title by @bah0 in https://github.com/sissbruecker/linkding/pull/365
+* Add LinkThing iOS app to community section by @amoscardino in https://github.com/sissbruecker/linkding/pull/446
+* Bump django from 4.1.7 to 4.1.9 by @dependabot in https://github.com/sissbruecker/linkding/pull/466
+* Bump sqlparse from 0.4.2 to 0.4.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/455
+
+### New Contributors
+* @amoscardino made their first contribution in https://github.com/sissbruecker/linkding/pull/446
+* @puresick made their first contribution in https://github.com/sissbruecker/linkding/pull/440
+* @plockaby made their first contribution in https://github.com/sissbruecker/linkding/pull/406
+* @fmenabe made their first contribution in https://github.com/sissbruecker/linkding/pull/398
+* @bah0 made their first contribution in https://github.com/sissbruecker/linkding/pull/365
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.2...v1.18.0
+
+---
+
+## v1.17.2 (18/02/2023)
+
+### What's Changed
+* Escape texts in exported HTML by @sissbruecker in https://github.com/sissbruecker/linkding/pull/429
+* Bump django from 4.1.2 to 4.1.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/427
+* Make health check in Dockerfile honor context path setting by @mrex in https://github.com/sissbruecker/linkding/pull/407
+* Disable autocapitalization for tag input form by @joshdick in https://github.com/sissbruecker/linkding/pull/395
+
+### New Contributors
+* @mrex made their first contribution in https://github.com/sissbruecker/linkding/pull/407
+* @joshdick made their first contribution in https://github.com/sissbruecker/linkding/pull/395
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.1...v1.17.2
+
+---
+
+## v1.17.1 (22/01/2023)
+
+### What's Changed
+* Fix favicon being cleared by web archive snapshot task by @sissbruecker in https://github.com/sissbruecker/linkding/pull/405
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.0...v1.17.1
+
+---
+
 ## v1.17.0 (21/01/2023)
 
 ### What's Changed

Dockerfile

@@ -53,6 +53,6 @@ RUN ["chmod", "g+w", "."]
 RUN ["chmod", "+x", "./bootstrap.sh"]
 
 HEALTHCHECK --interval=30s --retries=3 --timeout=1s \
-CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/health || exit 1
+CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/${LD_CONTEXT_PATH}health || exit 1
 
 CMD ["./bootstrap.sh"]

README.md

@@ -17,11 +17,12 @@
 - [Documentation](#documentation)
 - [Browser Extension](#browser-extension)
 - [Community](#community)
+- [Acknowledgements](#acknowledgements)
 - [Development](#development)
 
 ##  Introduction
 
-linkding is a simple bookmark service that you can host yourself.
+linkding is a bookmark manager that you can host yourself.
 It's designed be to be minimal, fast, and easy to set up using Docker.
 
 The name comes from:
@@ -30,22 +31,23 @@ The name comes from:
 - ...so basically something for managing your links
 
 **Feature Overview:**
+- Clean UI optimized for readability
 - Organize bookmarks with tags
+- Add notes using Markdown
 - Read it later functionality
 - Share bookmarks with other users
 - Bulk editing
-- Bookmark archive
-- Automatically provides titles and descriptions of bookmarked websites
+- Automatically provides titles, descriptions and icons of bookmarked websites
 - Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
 - Import and export bookmarks in Netscape HTML format
 - Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
 - Light and dark themes
 - REST API for developing 3rd party apps
 - Admin panel for user self-service and raw data access
-- Easy setup using Docker, uses SQLite as database
+- Easy setup using Docker and a SQLite database, with PostgreSQL as an option
 
 
-**Demo:** https://demo.linkding.link/ (configured with open registration)
+**Demo:** https://demo.linkding.link/ ([see here](https://github.com/sissbruecker/linkding/issues/408) if you have trouble accessing it)
 
 **Screenshot:**
 
@@ -63,15 +65,13 @@ Alternatively linkding supports PostgreSQL, see the [database options](docs/Opti
 
 To install linkding using Docker you can just run the [latest image](https://hub.docker.com/repository/docker/sissbruecker/linkding) from Docker Hub:
 ```shell
-docker run --name linkding -p 9090:9090 -d sissbruecker/linkding:latest
-```
-By default, the application runs on port `9090`, you can map it to a different host port by modifying the port mapping in the command above. If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090, provided you did not change the port mapping.
-
-Note that the command above will store the linkding SQLite database in the container, which means that deleting the container, for example when upgrading the installation, will also remove the database. For hosting an actual installation you usually want to store the database on the host system, rather than in the container. To do so, run the following command, and replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database:
-```shell
 docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d sissbruecker/linkding:latest
 ```
 
+In the command above, replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database.
+
+If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090.
+
 To upgrade the installation to a new version, remove the existing container, pull the latest version of the linkding Docker image, and then start a new container using the same command that you used above. There is a [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) available to automate these steps. The script can be configured using environment variables, or you can just modify it.
 
 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
@@ -101,6 +101,8 @@ docker-compose exec linkding python manage.py createsuperuser --username=joe --e
 
 The command will prompt you for a secure password. After the command has completed you can start using the application by logging into the UI with your credentials.
 
+Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME). 
+
 ### Reverse Proxy Setup
 
 When using a reverse proxy, such as Nginx or Apache, you may need to configure your proxy to correctly forward the `Host` header to linkding, otherwise certain requests, such as login, might fail.
@@ -158,7 +160,7 @@ Instead of configuring header forwarding in your proxy, you can also configure t
 
 ### Managed Hosting Options
 
-Self-hosting web applications on your own hardware (unfortunately) still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting linkding, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a (usually monthly) fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
+Self-hosting web applications still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
 
 - [linkding on fly.io](https://github.com/fspoettel/linkding-on-fly) - Guide for hosting a linkding installation on [fly.io](https://fly.io). By [fspoettel](https://github.com/fspoettel)
 - [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding)
@@ -171,6 +173,7 @@ Self-hosting web applications on your own hardware (unfortunately) still require
 | [Backups](https://github.com/sissbruecker/linkding/blob/master/docs/backup.md)                  | How to backup the linkding database                      |
 | [Troubleshooting](https://github.com/sissbruecker/linkding/blob/master/docs/troubleshooting.md) | Advice for troubleshooting common problems               |
 | [How To](https://github.com/sissbruecker/linkding/blob/master/docs/how-to.md)                   | Tips and tricks around using linking                     |
+| [Keyboard shortcuts](https://github.com/sissbruecker/linkding/blob/master/docs/shortcuts.md)    | List of available keyboard shortcuts                     |
 | [Admin documentation](https://github.com/sissbruecker/linkding/blob/master/docs/Admin.md)       | User documentation for the Admin UI                      |
 | [API documentation](https://github.com/sissbruecker/linkding/blob/master/docs/API.md)           | Documentation for the REST API                           |
 
@@ -186,13 +189,15 @@ The extension is open-source as well, and can be found [here](https://github.com
 
 This section lists community projects around using linkding, in alphabetical order. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.
 
+- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
 - [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
+- [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
 - [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
 - [linkding-injector](https://github.com/Fivefold/linkding-injector) Injects search results from linkding into the sidebar of search pages like google and duckduckgo. Tested with Firefox and Chrome. By [Fivefold](https://github.com/Fivefold)
-- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
-- [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
+- [LinkThing](https://apps.apple.com/us/app/linkthing/id1666031776) An iOS client for linkding. By [amoscardino](https://github.com/amoscardino)
 - [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
+- [Postman collection](https://gist.github.com/gingerbeardman/f0b42502f3bc9344e92ce63afd4360d3) a group of saved request templates for API testing. By [gingerbeardman](https://github.com/gingerbeardman)
 
 ## Acknowledgements
 
@@ -242,3 +247,23 @@ Start the Django development server with:
 python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
+
+### DevContainers
+
+This repository also supports DevContainers: [![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=git@github.com:sissbruecker/linkding.git)
+
+Once checked out, only the following commands are required to get started:
+
+Create a user for the frontend:
+```
+python3 manage.py createsuperuser --username=joe --email=joe@example.com
+```
+Start the Node.js development server (used for compiling JavaScript components like tag auto-completion) with:
+```
+npm run dev
+```
+Start the Django development server with:
+```
+python3 manage.py runserver
+```
+The frontend is now available under http://localhost:8000

bookmarks/api/routes.py

@@ -1,5 +1,6 @@
 from rest_framework import viewsets, mixins, status
 from rest_framework.decorators import action
+from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
 from rest_framework.routers import DefaultRouter
 
@@ -18,12 +19,23 @@ class BookmarkViewSet(viewsets.GenericViewSet,
                       mixins.DestroyModelMixin):
     serializer_class = BookmarkSerializer
 
+    def get_permissions(self):
+        # Allow unauthenticated access to shared bookmarks.
+        # The shared action should still filter bookmarks so that
+        # unauthenticated users only see bookmarks from users that have public
+        # sharing explicitly enabled
+        if self.action == 'shared':
+            return [AllowAny()]
+
+        # Otherwise use default permissions which should require authentication
+        return super().get_permissions()
+
     def get_queryset(self):
         user = self.request.user
         # For list action, use query set that applies search and tag projections
         if self.action == 'list':
             query_string = self.request.GET.get('q')
-            return queries.query_bookmarks(user, query_string)
+            return queries.query_bookmarks(user, user.profile, query_string)
 
         # For single entity actions use default query set without projections
         return Bookmark.objects.all().filter(owner=user)
@@ -35,7 +47,7 @@ class BookmarkViewSet(viewsets.GenericViewSet,
     def archived(self, request):
         user = request.user
         query_string = request.GET.get('q')
-        query_set = queries.query_archived_bookmarks(user, query_string)
+        query_set = queries.query_archived_bookmarks(user, user.profile, query_string)
         page = self.paginate_queryset(query_set)
         serializer = self.get_serializer_class()
         data = serializer(page, many=True).data
@@ -45,7 +57,8 @@ class BookmarkViewSet(viewsets.GenericViewSet,
     def shared(self, request):
         filters = BookmarkFilters(request)
         user = User.objects.filter(username=filters.user).first()
-        query_set = queries.query_shared_bookmarks(user, filters.query)
+        public_only = not request.user.is_authenticated
+        query_set = queries.query_shared_bookmarks(user, request.user_profile, filters.query, public_only)
         page = self.paginate_queryset(query_set)
         serializer = self.get_serializer_class()
         data = serializer(page, many=True).data

bookmarks/api/serializers.py

@@ -27,6 +27,7 @@ class BookmarkSerializer(serializers.ModelSerializer):
             'url',
             'title',
             'description',
+            'notes',
             'website_title',
             'website_description',
             'is_archived',
@@ -47,6 +48,7 @@ class BookmarkSerializer(serializers.ModelSerializer):
     # Override optional char fields to provide default value
     title = serializers.CharField(required=False, allow_blank=True, default='')
     description = serializers.CharField(required=False, allow_blank=True, default='')
+    notes = serializers.CharField(required=False, allow_blank=True, default='')
     is_archived = serializers.BooleanField(required=False, default=False)
     unread = serializers.BooleanField(required=False, default=False)
     shared = serializers.BooleanField(required=False, default=False)
@@ -58,6 +60,7 @@ class BookmarkSerializer(serializers.ModelSerializer):
         bookmark.url = validated_data['url']
         bookmark.title = validated_data['title']
         bookmark.description = validated_data['description']
+        bookmark.notes = validated_data['notes']
         bookmark.is_archived = validated_data['is_archived']
         bookmark.unread = validated_data['unread']
         bookmark.shared = validated_data['shared']
@@ -66,7 +69,7 @@ class BookmarkSerializer(serializers.ModelSerializer):
 
     def update(self, instance: Bookmark, validated_data):
         # Update fields if they were provided in the payload
-        for key in ['url', 'title', 'description', 'unread', 'shared']:
+        for key in ['url', 'title', 'description', 'notes', 'unread', 'shared']:
             if key in validated_data:
                 setattr(instance, key, validated_data[key])
 

bookmarks/components/SearchAutoComplete.svelte

@@ -1,271 +0,0 @@
-<script>
-    import {SearchHistory} from "./SearchHistory";
-    import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "./util";
-
-    const searchHistory = new SearchHistory()
-
-    export let name;
-    export let placeholder;
-    export let value;
-    export let tags;
-    export let mode = '';
-    export let apiClient;
-    export let filters;
-
-    let isFocus = false;
-    let isOpen = false;
-    let suggestions = []
-    let selectedIndex = undefined;
-    let input = null;
-
-    // Track current search query after loading the page
-    searchHistory.pushCurrent()
-    updateSuggestions()
-
-    function handleFocus() {
-        isFocus = true;
-    }
-
-    function handleBlur() {
-        isFocus = false;
-        close();
-    }
-
-    function handleInput(e) {
-        value = e.target.value
-        debouncedLoadSuggestions()
-    }
-
-    function handleKeyDown(e) {
-        // Enter
-        if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
-            const suggestion = suggestions.total[selectedIndex];
-            if (suggestion) completeSuggestion(suggestion);
-            e.preventDefault();
-        }
-        // Escape
-        if (e.keyCode === 27) {
-            close();
-            e.preventDefault();
-        }
-        // Up arrow
-        if (e.keyCode === 38) {
-            updateSelection(-1);
-            e.preventDefault();
-        }
-        // Down arrow
-        if (e.keyCode === 40) {
-            if (!isOpen) {
-                loadSuggestions()
-            } else {
-                updateSelection(1);
-            }
-            e.preventDefault();
-        }
-    }
-
-    function open() {
-        isOpen = true;
-    }
-
-    function close() {
-        isOpen = false;
-        updateSuggestions()
-        selectedIndex = undefined
-    }
-
-    function hasSuggestions() {
-        return suggestions.total.length > 0
-    }
-
-    async function loadSuggestions() {
-
-        let suggestionIndex = 0
-
-        function nextIndex() {
-            return suggestionIndex++
-        }
-
-        // Tag suggestions
-        let tagSuggestions = []
-        const currentWord = getCurrentWord(input)
-        if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
-            const searchTag = currentWord.substring(1, currentWord.length)
-            tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
-                .slice(0, 5)
-                .map(tagName => ({
-                    type: 'tag',
-                    index: nextIndex(),
-                    label: `#${tagName}`,
-                    tagName: tagName
-                }))
-        }
-
-        // Recent search suggestions
-        const search = searchHistory.getRecentSearches(value, 5).map(value => ({
-            type: 'search',
-            index: nextIndex(),
-            label: value,
-            value
-        }))
-
-        // Bookmark suggestions
-        let bookmarks = []
-
-        if (value && value.length >= 3) {
-            const path = mode ? `/${mode}` : ''
-            const suggestionFilters = {
-                ...filters,
-                q: value
-            }
-            const fetchedBookmarks = await apiClient.listBookmarks(suggestionFilters, {limit: 5, offset: 0, path})
-            bookmarks = fetchedBookmarks.map(bookmark => {
-                const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
-                const label = clampText(fullLabel, 60)
-                return {
-                    type: 'bookmark',
-                    index: nextIndex(),
-                    label,
-                    bookmark
-                }
-            })
-        }
-
-        updateSuggestions(search, bookmarks, tagSuggestions)
-
-        if (hasSuggestions()) {
-            open()
-        } else {
-            close()
-        }
-    }
-
-    const debouncedLoadSuggestions = debounce(loadSuggestions)
-
-    function updateSuggestions(search, bookmarks, tagSuggestions) {
-        search = search || []
-        bookmarks = bookmarks || []
-        tagSuggestions = tagSuggestions || []
-        suggestions = {
-            search,
-            bookmarks,
-            tags: tagSuggestions,
-            total: [
-                ...tagSuggestions,
-                ...search,
-                ...bookmarks,
-            ]
-        }
-    }
-
-    function completeSuggestion(suggestion) {
-        if (suggestion.type === 'search') {
-            value = suggestion.value
-            close()
-        }
-        if (suggestion.type === 'bookmark') {
-            window.open(suggestion.bookmark.url, '_blank')
-            close()
-        }
-        if (suggestion.type === 'tag') {
-            const bounds = getCurrentWordBounds(input);
-            const inputValue = input.value;
-            input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
-            close()
-        }
-    }
-
-    function updateSelection(dir) {
-
-        const length = suggestions.total.length;
-
-        if (length === 0) return
-
-        if (selectedIndex === undefined) {
-            selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
-            return
-        }
-
-        let newIndex = selectedIndex + dir;
-
-        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
-        if (newIndex >= length) newIndex = 0;
-
-        selectedIndex = newIndex;
-    }
-</script>
-
-<div class="form-autocomplete">
-    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
-        <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
-               bind:this={input}
-               on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
-    </div>
-
-    <ul class="menu" class:open={isOpen}>
-        {#if suggestions.tags.length > 0}
-            <li class="menu-item group-item">Tags</li>
-        {/if}
-        {#each suggestions.tags as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-
-        {#if suggestions.search.length > 0}
-            <li class="menu-item group-item">Recent Searches</li>
-        {/if}
-        {#each suggestions.search as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-
-        {#if suggestions.bookmarks.length > 0}
-            <li class="menu-item group-item">Bookmarks</li>
-        {/if}
-        {#each suggestions.bookmarks as suggestion}
-            <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
-                <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {suggestion.label}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-    </ul>
-</div>
-
-<style>
-    .menu {
-        display: none;
-        max-height: 400px;
-        overflow: auto;
-    }
-
-    .menu.open {
-        display: block;
-    }
-
-    .form-autocomplete-input {
-        padding: 0;
-    }
-    .form-autocomplete-input.is-focused {
-        z-index: 2;
-    }
-
-</style>

bookmarks/components/SearchHistory.js

@@ -1,48 +0,0 @@
-const SEARCH_HISTORY_KEY = 'searchHistory'
-const MAX_ENTRIES = 30
-
-export class SearchHistory {
-
-    getHistory() {
-        const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY)
-        return historyJson ? JSON.parse(historyJson) : {
-            recent: []
-        }
-    }
-
-    pushCurrent() {
-        // Skip if browser is not compatible
-        if (!window.URLSearchParams) return
-        const urlParams = new URLSearchParams(window.location.search);
-        const searchParam = urlParams.get('q');
-
-        if (!searchParam) return
-
-        this.push(searchParam)
-    }
-
-    push(search) {
-        const history = this.getHistory()
-
-        history.recent.unshift(search)
-
-        // Remove duplicates and clamp to max entries
-        history.recent = history.recent.reduce((acc, cur) => {
-            if (acc.length >= MAX_ENTRIES) return acc
-            if (acc.indexOf(cur) >= 0) return acc
-            acc.push(cur)
-            return acc
-        }, [])
-
-        const newHistoryJson = JSON.stringify(history)
-        localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson)
-    }
-
-    getRecentSearches(query, max) {
-        const history = this.getHistory()
-
-        return history.recent
-            .filter(search => !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0)
-            .slice(0, max)
-    }
-}

bookmarks/components/TagAutocomplete.svelte

@@ -1,168 +0,0 @@
-<script>
-    import {getCurrentWord, getCurrentWordBounds} from "./util";
-
-    export let id;
-    export let name;
-    export let value;
-    export let apiClient;
-    export let variant = 'default';
-
-    let tags = [];
-    let isFocus = false;
-    let isOpen = false;
-    let input = null;
-    let suggestionList = null;
-
-    let suggestions = [];
-    let selectedIndex = 0;
-
-    init();
-
-    async function init() {
-        // For now we cache all tags on load as the template did before
-        try {
-            tags = await apiClient.getTags({limit: 1000, offset: 0});
-            tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
-        } catch (e) {
-            console.warn('TagAutocomplete: Error loading tag list');
-        }
-    }
-
-    function handleFocus() {
-        isFocus = true;
-    }
-
-    function handleBlur() {
-        isFocus = false;
-        close();
-    }
-
-    function handleInput(e) {
-        input = e.target;
-
-        const word = getCurrentWord(input);
-
-        suggestions = word
-            ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
-            : [];
-
-        if (word && suggestions.length > 0) {
-            open();
-        } else {
-            close();
-        }
-    }
-
-    function handleKeyDown(e) {
-        if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
-            const suggestion = suggestions[selectedIndex];
-            complete(suggestion);
-            e.preventDefault();
-        }
-        if (e.keyCode === 27) {
-            close();
-            e.preventDefault();
-        }
-        if (e.keyCode === 38) {
-            updateSelection(-1);
-            e.preventDefault();
-        }
-        if (e.keyCode === 40) {
-            updateSelection(1);
-            e.preventDefault();
-        }
-    }
-
-    function open() {
-        isOpen = true;
-        selectedIndex = 0;
-    }
-
-    function close() {
-        isOpen = false;
-        suggestions = [];
-        selectedIndex = 0;
-    }
-
-    function complete(suggestion) {
-        const bounds = getCurrentWordBounds(input);
-        const value = input.value;
-        input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
-
-        close();
-    }
-
-    function updateSelection(dir) {
-
-        const length = suggestions.length;
-        let newIndex = selectedIndex + dir;
-
-        if (newIndex < 0) newIndex = Math.max(length - 1, 0);
-        if (newIndex >= length) newIndex = 0;
-
-        selectedIndex = newIndex;
-
-        // Scroll to selected list item
-        setTimeout(() => {
-            if (suggestionList) {
-                const selectedListItem = suggestionList.querySelector('li.selected');
-                if (selectedListItem) {
-                    selectedListItem.scrollIntoView({block: 'center'});
-                }
-            }
-        }, 0);
-    }
-</script>
-
-<div class="form-autocomplete" class:small={variant === 'small'}>
-    <!-- autocomplete input container -->
-    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
-        <!-- autocomplete real input box -->
-        <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
-               class="form-input" type="text" autocomplete="off"
-               on:input={handleInput} on:keydown={handleKeyDown}
-               on:focus={handleFocus} on:blur={handleBlur}>
-    </div>
-
-    <!-- autocomplete suggestion list -->
-    <ul class="menu" class:open={isOpen && suggestions.length > 0}
-        bind:this={suggestionList}>
-        <!-- menu list items -->
-        {#each suggestions as tag,i}
-            <li class="menu-item" class:selected={selectedIndex === i}>
-                <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
-                    <div class="tile tile-centered">
-                        <div class="tile-content">
-                            {tag.name}
-                        </div>
-                    </div>
-                </a>
-            </li>
-        {/each}
-    </ul>
-</div>
-
-<style>
-    .menu {
-        display: none;
-        max-height: 200px;
-        overflow: auto;
-    }
-
-    .menu.open {
-        display: block;
-    }
-
-    .form-autocomplete.small .form-autocomplete-input {
-        height: 1.4rem;
-        min-height: 1.4rem;
-    }
-    .form-autocomplete.small .form-autocomplete-input input {
-        margin: 0;
-        padding: 0;
-        font-size: 0.7rem;
-    }
-    .form-autocomplete.small .menu .menu-item {
-        font-size: 0.7rem;
-    }
-</style>

bookmarks/components/api.js

@@ -1,32 +0,0 @@
-export class ApiClient {
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl
-    }
-
-    listBookmarks(filters, options = {limit: 100, offset: 0, path: ''}) {
-        const query = [
-          `limit=${options.limit}`,
-          `offset=${options.offset}`,
-        ]
-        Object.keys(filters).forEach(key => {
-            const value = filters[key]
-            if (value) {
-                query.push(`${key}=${encodeURIComponent(value)}`)
-            }
-        })
-        const queryString = query.join('&')
-        const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-
-    getTags(options = {limit: 100, offset: 0}) {
-        const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-}

bookmarks/components/index.js

@@ -1,10 +0,0 @@
-import TagAutoComplete from './TagAutocomplete.svelte'
-import SearchAutoComplete from './SearchAutoComplete.svelte'
-import {ApiClient} from './api'
-
-export default {
-    ApiClient,
-    TagAutoComplete,
-    SearchAutoComplete
-}
-

bookmarks/components/util.js

@@ -1,37 +0,0 @@
-export function debounce(callback, delay = 250) {
-    let timeoutId
-    return (...args) => {
-        clearTimeout(timeoutId)
-        timeoutId = setTimeout(() => {
-            timeoutId = null
-            callback(...args)
-        }, delay)
-    }
-}
-
-export function clampText(text, maxChars = 30) {
-    if(!text || text.length <= 30) return text
-
-    return text.substr(0, maxChars) + '...'
-}
-
-export function getCurrentWordBounds(input) {
-    const text = input.value;
-    const end = input.selectionStart;
-    let start = end;
-
-    let currentChar = text.charAt(start - 1);
-
-    while (currentChar && currentChar !== ' ' && start > 0) {
-        start--;
-        currentChar = text.charAt(start - 1);
-    }
-
-    return {start, end};
-}
-
-export function getCurrentWord(input) {
-    const bounds = getCurrentWordBounds(input);
-
-    return input.value.substring(bounds.start, bounds.end);
-}

bookmarks/context_processors.py

@@ -1,12 +1,25 @@
+from bookmarks import queries
 from bookmarks.models import Toast
 
 
 def toasts(request):
-    user = request.user if hasattr(request, 'user') else None
-    toast_messages = Toast.objects.filter(owner=user, acknowledged=False) if user and user.is_authenticated else []
+    user = request.user
+    toast_messages = Toast.objects.filter(owner=user, acknowledged=False) if user.is_authenticated else []
     has_toasts = len(toast_messages) > 0
 
     return {
         'has_toasts': has_toasts,
         'toast_messages': toast_messages,
     }
+
+
+def public_shares(request):
+    # Only check for public shares for anonymous users
+    if not request.user.is_authenticated:
+        query_set = queries.query_shared_bookmarks(None, request.user_profile, '', True)
+        has_public_shares = query_set.count() > 0
+        return {
+            'has_public_shares': has_public_shares,
+        }
+
+    return {}

bookmarks/e2e/e2e_test_bookmark_form.py

@@ -1,5 +1,5 @@
 from django.urls import reverse
-from playwright.sync_api import sync_playwright
+from playwright.sync_api import sync_playwright, expect
 
 from bookmarks.e2e.helpers import LinkdingE2ETestCase
 
@@ -8,6 +8,7 @@ class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
     def test_create_should_check_for_existing_bookmark(self):
         existing_bookmark = self.setup_bookmark(title='Existing title',
                                                 description='Existing description',
+                                                notes='Existing notes',
                                                 tags=[self.setup_tag(name='tag1'), self.setup_tag(name='tag2')],
                                                 website_title='Existing website title',
                                                 website_description='Existing website description',
@@ -26,6 +27,7 @@ class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
             # Form should be pre-filled with data from existing bookmark
             self.assertEqual(existing_bookmark.title, page.get_by_label('Title').input_value())
             self.assertEqual(existing_bookmark.description, page.get_by_label('Description').input_value())
+            self.assertEqual(existing_bookmark.notes, page.get_by_label('Notes').input_value())
             self.assertEqual(existing_bookmark.website_title, page.get_by_label('Title').get_attribute('placeholder'))
             self.assertEqual(existing_bookmark.website_description,
                              page.get_by_label('Description').get_attribute('placeholder'))
@@ -49,3 +51,17 @@ class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
 
             page.wait_for_timeout(timeout=1000)
             page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden')
+
+    def test_enter_url_of_existing_bookmark_should_show_notes(self):
+        bookmark = self.setup_bookmark(notes='Existing notes', description='Existing description')
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:new'))
+
+            details = page.locator('details.notes')
+            expect(details).not_to_have_attribute('open', value='')
+
+            page.get_by_label('URL').fill(bookmark.url)
+            expect(details).to_have_attribute('open', value='')

bookmarks/e2e/e2e_test_bookmark_item.py

@@ -0,0 +1,25 @@
+from unittest import skip
+
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkItemE2ETestCase(LinkdingE2ETestCase):
+    @skip("Fails in CI, needs investigation")
+    def test_toggle_notes_should_show_hide_notes(self):
+        bookmark = self.setup_bookmark(notes='Test notes')
+
+        with sync_playwright() as p:
+            page = self.open(reverse('bookmarks:index'), p)
+
+            notes = self.locate_bookmark(bookmark.title).locator('.notes')
+            expect(notes).to_be_hidden()
+
+            toggle_notes = page.locator('li button.toggle-notes')
+            toggle_notes.click()
+            expect(notes).to_be_visible()
+
+            toggle_notes.click()
+            expect(notes).to_be_hidden()

bookmarks/e2e/e2e_test_bookmark_page_partial_updates.py

@@ -0,0 +1,252 @@
+from typing import List
+
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkPagePartialUpdatesE2ETestCase(LinkdingE2ETestCase):
+    def setup_fixture(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_sharing = True
+        profile.save()
+
+        # create a number of bookmarks with different states / visibility to
+        # verify correct data is loaded on update
+        self.setup_numbered_bookmarks(3, with_tags=True)
+        self.setup_numbered_bookmarks(3, with_tags=True, archived=True)
+        self.setup_numbered_bookmarks(3,
+                                      shared=True,
+                                      prefix="Joe's Bookmark",
+                                      user=self.setup_user(enable_sharing=True))
+
+    def assertVisibleBookmarks(self, titles: List[str]):
+        bookmark_tags = self.page.locator('li[ld-bookmark-item]')
+        expect(bookmark_tags).to_have_count(len(titles))
+
+        for title in titles:
+            matching_tag = bookmark_tags.filter(has_text=title)
+            expect(matching_tag).to_be_visible()
+
+    def assertVisibleTags(self, titles: List[str]):
+        tag_tags = self.page.locator('.tag-cloud .unselected-tags a')
+        expect(tag_tags).to_have_count(len(titles))
+
+        for title in titles:
+            matching_tag = tag_tags.filter(has_text=title)
+            expect(matching_tag).to_be_visible()
+
+    def test_partial_update_respects_query(self):
+        self.setup_numbered_bookmarks(5, prefix='foo')
+        self.setup_numbered_bookmarks(5, prefix='bar')
+
+        with sync_playwright() as p:
+            url = reverse('bookmarks:index') + '?q=foo'
+            self.open(url, p)
+
+            self.assertVisibleBookmarks(['foo 1', 'foo 2', 'foo 3', 'foo 4', 'foo 5'])
+
+            self.locate_bookmark('foo 2').get_by_text('Archive').click()
+            self.assertVisibleBookmarks(['foo 1', 'foo 3', 'foo 4', 'foo 5'])
+
+    def test_partial_update_respects_page(self):
+        # add a suffix, otherwise 'foo 1' also matches 'foo 10'
+        self.setup_numbered_bookmarks(50, prefix='foo', suffix='-')
+
+        with sync_playwright() as p:
+            url = reverse('bookmarks:index') + '?q=foo&page=2'
+            self.open(url, p)
+
+            # with descending sort, page two has 'foo 1' to 'foo 20'
+            expected_titles = [f'foo {i}-' for i in range(1, 21)]
+            self.assertVisibleBookmarks(expected_titles)
+
+            self.locate_bookmark('foo 20-').get_by_text('Archive').click()
+
+            expected_titles = [f'foo {i}-' for i in range(1, 20)]
+            self.assertVisibleBookmarks(expected_titles)
+
+    def test_multiple_partial_updates(self):
+        self.setup_numbered_bookmarks(5)
+
+        with sync_playwright() as p:
+            url = reverse('bookmarks:index')
+            self.open(url, p)
+
+            self.locate_bookmark('Bookmark 1').get_by_text('Archive').click()
+            self.assertVisibleBookmarks(['Bookmark 2', 'Bookmark 3', 'Bookmark 4', 'Bookmark 5'])
+
+            self.locate_bookmark('Bookmark 2').get_by_text('Archive').click()
+            self.assertVisibleBookmarks(['Bookmark 3', 'Bookmark 4', 'Bookmark 5'])
+
+            self.locate_bookmark('Bookmark 3').get_by_text('Archive').click()
+            self.assertVisibleBookmarks(['Bookmark 4', 'Bookmark 5'])
+
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_archive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:index'), p)
+
+            self.locate_bookmark('Bookmark 2').get_by_text('Archive').click()
+
+            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
+            self.assertVisibleTags(['Tag 1', 'Tag 3'])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:index'), p)
+
+            self.locate_bookmark('Bookmark 2').get_by_text('Remove').click()
+            self.locate_bookmark('Bookmark 2').get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
+            self.assertVisibleTags(['Tag 1', 'Tag 3'])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_mark_as_read(self):
+        self.setup_fixture()
+        bookmark2 = self.get_numbered_bookmark('Bookmark 2')
+        bookmark2.unread = True
+        bookmark2.save()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:index'), p)
+
+            expect(self.locate_bookmark('Bookmark 2').get_by_text('Bookmark 2')).to_have_class('text-italic')
+            self.locate_bookmark('Bookmark 2').get_by_text('Mark as read').click()
+
+            expect(self.locate_bookmark('Bookmark 2').get_by_text('Bookmark 2')).not_to_have_class('text-italic')
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_bulk_archive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:index'), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark('Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
+            self.locate_bulk_edit_bar().get_by_text('Archive').click()
+            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
+            self.assertVisibleTags(['Tag 1', 'Tag 3'])
+            self.assertReloads(0)
+
+    def test_active_bookmarks_partial_update_on_bulk_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:index'), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark('Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
+            self.locate_bulk_edit_bar().get_by_text('Delete').click()
+            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Bookmark 1', 'Bookmark 3'])
+            self.assertVisibleTags(['Tag 1', 'Tag 3'])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_unarchive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:archived'), p)
+
+            self.locate_bookmark('Archived Bookmark 2').get_by_text('Unarchive').click()
+
+            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
+            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:archived'), p)
+
+            self.locate_bookmark('Archived Bookmark 2').get_by_text('Remove').click()
+            self.locate_bookmark('Archived Bookmark 2').get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
+            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_bulk_archive(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:archived'), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark('Archived Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
+            self.locate_bulk_edit_bar().get_by_text('Archive').click()
+            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
+            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
+            self.assertReloads(0)
+
+    def test_archived_bookmarks_partial_update_on_bulk_delete(self):
+        self.setup_fixture()
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:archived'), p)
+
+            self.locate_bulk_edit_toggle().click()
+            self.locate_bookmark('Archived Bookmark 2').locator('label[ld-bulk-edit-checkbox]').click()
+            self.locate_bulk_edit_bar().get_by_text('Delete').click()
+            self.locate_bulk_edit_bar().get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks(['Archived Bookmark 1', 'Archived Bookmark 3'])
+            self.assertVisibleTags(['Archived Tag 1', 'Archived Tag 3'])
+            self.assertReloads(0)
+
+    def test_shared_bookmarks_partial_update_on_unarchive(self):
+        self.setup_fixture()
+        self.setup_numbered_bookmarks(3, shared=True, prefix="My Bookmark", with_tags=True)
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:shared'), p)
+
+            self.locate_bookmark('My Bookmark 2').get_by_text('Archive').click()
+
+            # Shared bookmarks page also shows archived bookmarks, though it probably shouldn't
+            self.assertVisibleBookmarks([
+                'My Bookmark 1',
+                'My Bookmark 2',
+                'My Bookmark 3',
+                "Joe's Bookmark 1",
+                "Joe's Bookmark 2",
+                "Joe's Bookmark 3",
+            ])
+            self.assertVisibleTags(['Shared Tag 1', 'Shared Tag 2', 'Shared Tag 3'])
+            self.assertReloads(0)
+
+    def test_shared_bookmarks_partial_update_on_delete(self):
+        self.setup_fixture()
+        self.setup_numbered_bookmarks(3, shared=True, prefix="My Bookmark", with_tags=True)
+
+        with sync_playwright() as p:
+            self.open(reverse('bookmarks:shared'), p)
+
+            self.locate_bookmark('My Bookmark 2').get_by_text('Remove').click()
+            self.locate_bookmark('My Bookmark 2').get_by_text('Confirm').click()
+
+            self.assertVisibleBookmarks([
+                'My Bookmark 1',
+                'My Bookmark 3',
+                "Joe's Bookmark 1",
+                "Joe's Bookmark 2",
+                "Joe's Bookmark 3",
+            ])
+            self.assertVisibleTags(['Shared Tag 1', 'Shared Tag 3'])
+            self.assertReloads(0)

bookmarks/e2e/e2e_test_settings_general.py

@@ -0,0 +1,39 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class SettingsGeneralE2ETestCase(LinkdingE2ETestCase):
+    def test_should_only_enable_public_sharing_if_sharing_is_enabled(self):
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:settings.general'))
+
+            enable_sharing = page.get_by_label('Enable bookmark sharing')
+            enable_sharing_label = page.get_by_text('Enable bookmark sharing')
+            enable_public_sharing = page.get_by_label('Enable public bookmark sharing')
+            enable_public_sharing_label = page.get_by_text('Enable public bookmark sharing')
+
+            # Public sharing is disabled by default
+            expect(enable_sharing).not_to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_disabled()
+
+            # Enable sharing
+            enable_sharing_label.click()
+            expect(enable_sharing).to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_enabled()
+
+            # Enable public sharing
+            enable_public_sharing_label.click()
+            expect(enable_public_sharing).to_be_checked()
+            expect(enable_public_sharing).to_be_enabled()
+
+            # Disable sharing
+            enable_sharing_label.click()
+            expect(enable_sharing).not_to_be_checked()
+            expect(enable_public_sharing).not_to_be_checked()
+            expect(enable_public_sharing).to_be_disabled()

bookmarks/e2e/helpers.py

@@ -1,5 +1,5 @@
 from django.contrib.staticfiles.testing import LiveServerTestCase
-from playwright.sync_api import BrowserContext
+from playwright.sync_api import BrowserContext, Playwright, Page
 
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 
@@ -19,3 +19,27 @@ class LinkdingE2ETestCase(LiveServerTestCase, BookmarkFactoryMixin):
             'path': '/'
         }])
         return context
+
+    def open(self, url: str, playwright: Playwright) -> Page:
+        browser = self.setup_browser(playwright)
+        self.page = browser.new_page()
+        self.page.goto(self.live_server_url + url)
+        self.page.on('load', self.on_load)
+        self.num_loads = 0
+        return self.page
+
+    def on_load(self):
+        self.num_loads += 1
+
+    def assertReloads(self, count: int):
+        self.assertEqual(self.num_loads, count)
+
+    def locate_bookmark(self, title: str):
+        bookmark_tags = self.page.locator('li[ld-bookmark-item]')
+        return bookmark_tags.filter(has_text=title)
+
+    def locate_bulk_edit_bar(self):
+        return self.page.locator('.bulk-edit-bar')
+
+    def locate_bulk_edit_toggle(self):
+        return self.page.get_by_title('Bulk edit')

bookmarks/feeds.py

@@ -18,7 +18,7 @@ class BaseBookmarksFeed(Feed):
     def get_object(self, request, feed_key: str):
         feed_token = FeedToken.objects.get(key__exact=feed_key)
         query_string = request.GET.get('q')
-        query_set = queries.query_bookmarks(feed_token.user, query_string)
+        query_set = queries.query_bookmarks(feed_token.user, feed_token.user.profile, query_string)
         return FeedContext(feed_token, query_set)
 
     def item_title(self, item: Bookmark):

bookmarks/frontend/api.js

@@ -0,0 +1,29 @@
+export class ApiClient {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+
+  listBookmarks(filters, options = { limit: 100, offset: 0, path: "" }) {
+    const query = [`limit=${options.limit}`, `offset=${options.offset}`];
+    Object.keys(filters).forEach((key) => {
+      const value = filters[key];
+      if (value) {
+        query.push(`${key}=${encodeURIComponent(value)}`);
+      }
+    });
+    const queryString = query.join("&");
+    const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`;
+
+    return fetch(url)
+      .then((response) => response.json())
+      .then((data) => data.results);
+  }
+
+  getTags(options = { limit: 100, offset: 0 }) {
+    const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`;
+
+    return fetch(url)
+      .then((response) => response.json())
+      .then((data) => data.results);
+  }
+}

bookmarks/frontend/behaviors/bookmark-page.js

@@ -0,0 +1,65 @@
+import { registerBehavior, swap } from "./index";
+
+class BookmarkPage {
+  constructor(element) {
+    this.element = element;
+    this.form = element.querySelector("form.bookmark-actions");
+    this.form.addEventListener("submit", this.onFormSubmit.bind(this));
+
+    this.bookmarkList = element.querySelector(".bookmark-list-container");
+    this.tagCloud = element.querySelector(".tag-cloud-container");
+  }
+
+  async onFormSubmit(event) {
+    event.preventDefault();
+
+    const url = this.form.action;
+    const formData = new FormData(this.form);
+    formData.append(event.submitter.name, event.submitter.value);
+
+    await fetch(url, {
+      method: "POST",
+      body: formData,
+      redirect: "manual", // ignore redirect
+    });
+    await this.refresh();
+  }
+
+  async refresh() {
+    const query = window.location.search;
+    const bookmarksUrl = this.element.getAttribute("bookmarks-url");
+    const tagsUrl = this.element.getAttribute("tags-url");
+    Promise.all([
+      fetch(`${bookmarksUrl}${query}`).then((response) => response.text()),
+      fetch(`${tagsUrl}${query}`).then((response) => response.text()),
+    ]).then(([bookmarkListHtml, tagCloudHtml]) => {
+      swap(this.bookmarkList, bookmarkListHtml);
+      swap(this.tagCloud, tagCloudHtml);
+
+      this.bookmarkList.dispatchEvent(
+        new CustomEvent("bookmark-list-updated", { bubbles: true }),
+      );
+    });
+  }
+}
+
+registerBehavior("ld-bookmark-page", BookmarkPage);
+
+class BookmarkItem {
+  constructor(element) {
+    this.element = element;
+
+    const notesToggle = element.querySelector(".toggle-notes");
+    if (notesToggle) {
+      notesToggle.addEventListener("click", this.onToggleNotes.bind(this));
+    }
+  }
+
+  onToggleNotes(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    this.element.classList.toggle("show-notes");
+  }
+}
+
+registerBehavior("ld-bookmark-item", BookmarkItem);

bookmarks/frontend/behaviors/bulk-edit.js

@@ -0,0 +1,100 @@
+import { registerBehavior } from "./index";
+
+class BulkEdit {
+  constructor(element) {
+    this.element = element;
+    this.active = false;
+
+    element.addEventListener(
+      "bulk-edit-toggle-active",
+      this.onToggleActive.bind(this),
+    );
+    element.addEventListener(
+      "bulk-edit-toggle-all",
+      this.onToggleAll.bind(this),
+    );
+    element.addEventListener(
+      "bulk-edit-toggle-bookmark",
+      this.onToggleBookmark.bind(this),
+    );
+    element.addEventListener(
+      "bookmark-list-updated",
+      this.onListUpdated.bind(this),
+    );
+  }
+
+  get allCheckbox() {
+    return this.element.querySelector("[ld-bulk-edit-checkbox][all] input");
+  }
+
+  get bookmarkCheckboxes() {
+    return [
+      ...this.element.querySelectorAll(
+        "[ld-bulk-edit-checkbox]:not([all]) input",
+      ),
+    ];
+  }
+
+  onToggleActive() {
+    this.active = !this.active;
+    if (this.active) {
+      this.element.classList.add("active", "activating");
+      setTimeout(() => {
+        this.element.classList.remove("activating");
+      }, 500);
+    } else {
+      this.element.classList.remove("active");
+    }
+  }
+
+  onToggleBookmark() {
+    this.allCheckbox.checked = this.bookmarkCheckboxes.every((checkbox) => {
+      return checkbox.checked;
+    });
+  }
+
+  onToggleAll() {
+    const checked = this.allCheckbox.checked;
+    this.bookmarkCheckboxes.forEach((checkbox) => {
+      checkbox.checked = checked;
+    });
+  }
+
+  onListUpdated() {
+    this.allCheckbox.checked = false;
+    this.bookmarkCheckboxes.forEach((checkbox) => {
+      checkbox.checked = false;
+    });
+  }
+}
+
+class BulkEditActiveToggle {
+  constructor(element) {
+    this.element = element;
+    element.addEventListener("click", this.onClick.bind(this));
+  }
+
+  onClick() {
+    this.element.dispatchEvent(
+      new CustomEvent("bulk-edit-toggle-active", { bubbles: true }),
+    );
+  }
+}
+
+class BulkEditCheckbox {
+  constructor(element) {
+    this.element = element;
+    element.addEventListener("change", this.onChange.bind(this));
+  }
+
+  onChange() {
+    const type = this.element.hasAttribute("all") ? "all" : "bookmark";
+    this.element.dispatchEvent(
+      new CustomEvent(`bulk-edit-toggle-${type}`, { bubbles: true }),
+    );
+  }
+}
+
+registerBehavior("ld-bulk-edit", BulkEdit);
+registerBehavior("ld-bulk-edit-active-toggle", BulkEditActiveToggle);
+registerBehavior("ld-bulk-edit-checkbox", BulkEditCheckbox);

bookmarks/frontend/behaviors/confirm-button.js

@@ -0,0 +1,50 @@
+import { registerBehavior } from "./index";
+
+class ConfirmButtonBehavior {
+  constructor(element) {
+    const button = element;
+    button.dataset.type = button.type;
+    button.dataset.name = button.name;
+    button.dataset.value = button.value;
+    button.removeAttribute("type");
+    button.removeAttribute("name");
+    button.removeAttribute("value");
+    button.addEventListener("click", this.onClick.bind(this));
+    this.button = button;
+  }
+
+  onClick(event) {
+    event.preventDefault();
+
+    const cancelButton = document.createElement(this.button.nodeName);
+    cancelButton.type = "button";
+    cancelButton.innerText = "Cancel";
+    cancelButton.className = "btn btn-link btn-sm mr-1";
+    cancelButton.addEventListener("click", this.reset.bind(this));
+
+    const confirmButton = document.createElement(this.button.nodeName);
+    confirmButton.type = this.button.dataset.type;
+    confirmButton.name = this.button.dataset.name;
+    confirmButton.value = this.button.dataset.value;
+    confirmButton.innerText = "Confirm";
+    confirmButton.className = "btn btn-link btn-sm";
+    confirmButton.addEventListener("click", this.reset.bind(this));
+
+    const container = document.createElement("span");
+    container.className = "confirmation";
+    container.append(cancelButton, confirmButton);
+    this.container = container;
+
+    this.button.before(container);
+    this.button.classList.add("d-none");
+  }
+
+  reset() {
+    setTimeout(() => {
+      this.container.remove();
+      this.button.classList.remove("d-none");
+    });
+  }
+}
+
+registerBehavior("ld-confirm-button", ConfirmButtonBehavior);

bookmarks/frontend/behaviors/global-shortcuts.js

@@ -0,0 +1,73 @@
+import { registerBehavior } from "./index";
+
+class GlobalShortcuts {
+  constructor() {
+    document.addEventListener("keydown", this.onKeyDown.bind(this));
+  }
+
+  onKeyDown(event) {
+    // Skip if event occurred within an input element
+    const targetNodeName = event.target.nodeName;
+    const isInputTarget =
+      targetNodeName === "INPUT" ||
+      targetNodeName === "SELECT" ||
+      targetNodeName === "TEXTAREA";
+
+    if (isInputTarget) {
+      return;
+    }
+
+    // Handle shortcuts for navigating bookmarks with arrow keys
+    const isArrowUp = event.key === "ArrowUp";
+    const isArrowDown = event.key === "ArrowDown";
+    if (isArrowUp || isArrowDown) {
+      event.preventDefault();
+
+      // Detect current bookmark list item
+      const path = event.composedPath();
+      const currentItem = path.find(
+        (item) => item.hasAttribute && item.hasAttribute("ld-bookmark-item"),
+      );
+
+      // Find next item
+      let nextItem;
+      if (currentItem) {
+        nextItem = isArrowUp
+          ? currentItem.previousElementSibling
+          : currentItem.nextElementSibling;
+      } else {
+        // Select first item
+        nextItem = document.querySelector("[ld-bookmark-item]");
+      }
+      // Focus first link
+      if (nextItem) {
+        nextItem.querySelector("a").focus();
+      }
+    }
+
+    // Handle shortcut for toggling all notes
+    if (event.key === "e") {
+      const list = document.querySelector(".bookmark-list");
+      if (list) {
+        list.classList.toggle("show-notes");
+      }
+    }
+
+    // Handle shortcut for focusing search input
+    if (event.key === "s") {
+      const searchInput = document.querySelector('input[type="search"]');
+
+      if (searchInput) {
+        searchInput.focus();
+        event.preventDefault();
+      }
+    }
+
+    // Handle shortcut for adding new bookmark
+    if (event.key === "n") {
+      window.location.assign("/bookmarks/new");
+    }
+  }
+}
+
+registerBehavior("ld-global-shortcuts", GlobalShortcuts);

bookmarks/frontend/behaviors/index.js

@@ -0,0 +1,36 @@
+const behaviorRegistry = {};
+
+export function registerBehavior(name, behavior) {
+  behaviorRegistry[name] = behavior;
+  applyBehaviors(document, [name]);
+}
+
+export function applyBehaviors(container, behaviorNames = null) {
+  if (!behaviorNames) {
+    behaviorNames = Object.keys(behaviorRegistry);
+  }
+
+  behaviorNames.forEach((behaviorName) => {
+    const behavior = behaviorRegistry[behaviorName];
+    const elements = container.querySelectorAll(`[${behaviorName}]`);
+
+    elements.forEach((element) => {
+      element.__behaviors = element.__behaviors || [];
+      const hasBehavior = element.__behaviors.some(
+        (b) => b instanceof behavior,
+      );
+
+      if (hasBehavior) {
+        return;
+      }
+
+      const behaviorInstance = new behavior(element);
+      element.__behaviors.push(behaviorInstance);
+    });
+  });
+}
+
+export function swap(element, html) {
+  element.innerHTML = html;
+  applyBehaviors(element);
+}

bookmarks/frontend/behaviors/tag-autocomplete.js

@@ -0,0 +1,26 @@
+import { registerBehavior } from "./index";
+import TagAutoCompleteComponent from "../components/TagAutocomplete.svelte";
+import { ApiClient } from "../api";
+
+class TagAutocomplete {
+  constructor(element) {
+    const wrapper = document.createElement("div");
+    const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || "";
+    const apiClient = new ApiClient(apiBaseUrl);
+
+    new TagAutoCompleteComponent({
+      target: wrapper,
+      props: {
+        id: element.id,
+        name: element.name,
+        value: element.value,
+        apiClient: apiClient,
+        variant: element.getAttribute("variant"),
+      },
+    });
+
+    element.replaceWith(wrapper);
+  }
+}
+
+registerBehavior("ld-tag-autocomplete", TagAutocomplete);

bookmarks/frontend/components/SearchAutoComplete.svelte

@@ -0,0 +1,272 @@
+<script>
+  import {SearchHistory} from "./SearchHistory";
+  import {clampText, debounce, getCurrentWord, getCurrentWordBounds} from "../util";
+
+  const searchHistory = new SearchHistory()
+
+  export let name;
+  export let placeholder;
+  export let value;
+  export let tags;
+  export let mode = '';
+  export let apiClient;
+  export let filters;
+
+  let isFocus = false;
+  let isOpen = false;
+  let suggestions = []
+  let selectedIndex = undefined;
+  let input = null;
+
+  // Track current search query after loading the page
+  searchHistory.pushCurrent()
+  updateSuggestions()
+
+  function handleFocus() {
+    isFocus = true;
+  }
+
+  function handleBlur() {
+    isFocus = false;
+    close();
+  }
+
+  function handleInput(e) {
+    value = e.target.value
+    debouncedLoadSuggestions()
+  }
+
+  function handleKeyDown(e) {
+    // Enter
+    if (isOpen && selectedIndex !== undefined && (e.keyCode === 13 || e.keyCode === 9)) {
+      const suggestion = suggestions.total[selectedIndex];
+      if (suggestion) completeSuggestion(suggestion);
+      e.preventDefault();
+    }
+    // Escape
+    if (e.keyCode === 27) {
+      close();
+      e.preventDefault();
+    }
+    // Up arrow
+    if (e.keyCode === 38) {
+      updateSelection(-1);
+      e.preventDefault();
+    }
+    // Down arrow
+    if (e.keyCode === 40) {
+      if (!isOpen) {
+        loadSuggestions()
+      } else {
+        updateSelection(1);
+      }
+      e.preventDefault();
+    }
+  }
+
+  function open() {
+    isOpen = true;
+  }
+
+  function close() {
+    isOpen = false;
+    updateSuggestions()
+    selectedIndex = undefined
+  }
+
+  function hasSuggestions() {
+    return suggestions.total.length > 0
+  }
+
+  async function loadSuggestions() {
+
+    let suggestionIndex = 0
+
+    function nextIndex() {
+      return suggestionIndex++
+    }
+
+    // Tag suggestions
+    let tagSuggestions = []
+    const currentWord = getCurrentWord(input)
+    if (currentWord && currentWord.length > 1 && currentWord[0] === '#') {
+      const searchTag = currentWord.substring(1, currentWord.length)
+      tagSuggestions = (tags || []).filter(tagName => tagName.toLowerCase().indexOf(searchTag.toLowerCase()) === 0)
+        .slice(0, 5)
+        .map(tagName => ({
+          type: 'tag',
+          index: nextIndex(),
+          label: `#${tagName}`,
+          tagName: tagName
+        }))
+    }
+
+    // Recent search suggestions
+    const search = searchHistory.getRecentSearches(value, 5).map(value => ({
+      type: 'search',
+      index: nextIndex(),
+      label: value,
+      value
+    }))
+
+    // Bookmark suggestions
+    let bookmarks = []
+
+    if (value && value.length >= 3) {
+      const path = mode ? `/${mode}` : ''
+      const suggestionFilters = {
+        ...filters,
+        q: value
+      }
+      const fetchedBookmarks = await apiClient.listBookmarks(suggestionFilters, {limit: 5, offset: 0, path})
+      bookmarks = fetchedBookmarks.map(bookmark => {
+        const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
+        const label = clampText(fullLabel, 60)
+        return {
+          type: 'bookmark',
+          index: nextIndex(),
+          label,
+          bookmark
+        }
+      })
+    }
+
+    updateSuggestions(search, bookmarks, tagSuggestions)
+
+    if (hasSuggestions()) {
+      open()
+    } else {
+      close()
+    }
+  }
+
+  const debouncedLoadSuggestions = debounce(loadSuggestions)
+
+  function updateSuggestions(search, bookmarks, tagSuggestions) {
+    search = search || []
+    bookmarks = bookmarks || []
+    tagSuggestions = tagSuggestions || []
+    suggestions = {
+      search,
+      bookmarks,
+      tags: tagSuggestions,
+      total: [
+        ...tagSuggestions,
+        ...search,
+        ...bookmarks,
+      ]
+    }
+  }
+
+  function completeSuggestion(suggestion) {
+    if (suggestion.type === 'search') {
+      value = suggestion.value
+      close()
+    }
+    if (suggestion.type === 'bookmark') {
+      window.open(suggestion.bookmark.url, '_blank')
+      close()
+    }
+    if (suggestion.type === 'tag') {
+      const bounds = getCurrentWordBounds(input);
+      const inputValue = input.value;
+      input.value = inputValue.substring(0, bounds.start) + `#${suggestion.tagName} ` + inputValue.substring(bounds.end);
+      close()
+    }
+  }
+
+  function updateSelection(dir) {
+
+    const length = suggestions.total.length;
+
+    if (length === 0) return
+
+    if (selectedIndex === undefined) {
+      selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0)
+      return
+    }
+
+    let newIndex = selectedIndex + dir;
+
+    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
+    if (newIndex >= length) newIndex = 0;
+
+    selectedIndex = newIndex;
+  }
+</script>
+
+<div class="form-autocomplete">
+  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
+    <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
+           bind:this={input}
+           on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
+  </div>
+
+  <ul class="menu" class:open={isOpen}>
+    {#if suggestions.tags.length > 0}
+      <li class="menu-item group-item">Tags</li>
+    {/if}
+    {#each suggestions.tags as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          <div class="tile tile-centered">
+            <div class="tile-content">
+              {suggestion.label}
+            </div>
+          </div>
+        </a>
+      </li>
+    {/each}
+
+    {#if suggestions.search.length > 0}
+      <li class="menu-item group-item">Recent Searches</li>
+    {/if}
+    {#each suggestions.search as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          <div class="tile tile-centered">
+            <div class="tile-content">
+              {suggestion.label}
+            </div>
+          </div>
+        </a>
+      </li>
+    {/each}
+
+    {#if suggestions.bookmarks.length > 0}
+      <li class="menu-item group-item">Bookmarks</li>
+    {/if}
+    {#each suggestions.bookmarks as suggestion}
+      <li class="menu-item" class:selected={selectedIndex === suggestion.index}>
+        <a href="#" on:mousedown|preventDefault={() => completeSuggestion(suggestion)}>
+          <div class="tile tile-centered">
+            <div class="tile-content">
+              {suggestion.label}
+            </div>
+          </div>
+        </a>
+      </li>
+    {/each}
+  </ul>
+</div>
+
+<style>
+    .menu {
+        display: none;
+        max-height: 400px;
+        overflow: auto;
+    }
+
+    .menu.open {
+        display: block;
+    }
+
+    .form-autocomplete-input {
+        padding: 0;
+    }
+
+    .form-autocomplete-input.is-focused {
+        z-index: 2;
+    }
+
+</style>

bookmarks/frontend/components/SearchHistory.js

@@ -0,0 +1,52 @@
+const SEARCH_HISTORY_KEY = "searchHistory";
+const MAX_ENTRIES = 30;
+
+export class SearchHistory {
+  getHistory() {
+    const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY);
+    return historyJson
+      ? JSON.parse(historyJson)
+      : {
+          recent: [],
+        };
+  }
+
+  pushCurrent() {
+    // Skip if browser is not compatible
+    if (!window.URLSearchParams) return;
+    const urlParams = new URLSearchParams(window.location.search);
+    const searchParam = urlParams.get("q");
+
+    if (!searchParam) return;
+
+    this.push(searchParam);
+  }
+
+  push(search) {
+    const history = this.getHistory();
+
+    history.recent.unshift(search);
+
+    // Remove duplicates and clamp to max entries
+    history.recent = history.recent.reduce((acc, cur) => {
+      if (acc.length >= MAX_ENTRIES) return acc;
+      if (acc.indexOf(cur) >= 0) return acc;
+      acc.push(cur);
+      return acc;
+    }, []);
+
+    const newHistoryJson = JSON.stringify(history);
+    localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson);
+  }
+
+  getRecentSearches(query, max) {
+    const history = this.getHistory();
+
+    return history.recent
+      .filter(
+        (search) =>
+          !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0,
+      )
+      .slice(0, max);
+  }
+}

bookmarks/frontend/components/TagAutocomplete.svelte

@@ -0,0 +1,170 @@
+<script>
+  import {getCurrentWord, getCurrentWordBounds} from "../util";
+
+  export let id;
+  export let name;
+  export let value;
+  export let apiClient;
+  export let variant = 'default';
+
+  let tags = [];
+  let isFocus = false;
+  let isOpen = false;
+  let input = null;
+  let suggestionList = null;
+
+  let suggestions = [];
+  let selectedIndex = 0;
+
+  init();
+
+  async function init() {
+    // For now we cache all tags on load as the template did before
+    try {
+      tags = await apiClient.getTags({limit: 1000, offset: 0});
+      tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
+    } catch (e) {
+      console.warn('TagAutocomplete: Error loading tag list');
+    }
+  }
+
+  function handleFocus() {
+    isFocus = true;
+  }
+
+  function handleBlur() {
+    isFocus = false;
+    close();
+  }
+
+  function handleInput(e) {
+    input = e.target;
+
+    const word = getCurrentWord(input);
+
+    suggestions = word
+      ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
+      : [];
+
+    if (word && suggestions.length > 0) {
+      open();
+    } else {
+      close();
+    }
+  }
+
+  function handleKeyDown(e) {
+    if (isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
+      const suggestion = suggestions[selectedIndex];
+      complete(suggestion);
+      e.preventDefault();
+    }
+    if (e.keyCode === 27) {
+      close();
+      e.preventDefault();
+    }
+    if (e.keyCode === 38) {
+      updateSelection(-1);
+      e.preventDefault();
+    }
+    if (e.keyCode === 40) {
+      updateSelection(1);
+      e.preventDefault();
+    }
+  }
+
+  function open() {
+    isOpen = true;
+    selectedIndex = 0;
+  }
+
+  function close() {
+    isOpen = false;
+    suggestions = [];
+    selectedIndex = 0;
+  }
+
+  function complete(suggestion) {
+    const bounds = getCurrentWordBounds(input);
+    const value = input.value;
+    input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
+
+    close();
+  }
+
+  function updateSelection(dir) {
+
+    const length = suggestions.length;
+    let newIndex = selectedIndex + dir;
+
+    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
+    if (newIndex >= length) newIndex = 0;
+
+    selectedIndex = newIndex;
+
+    // Scroll to selected list item
+    setTimeout(() => {
+      if (suggestionList) {
+        const selectedListItem = suggestionList.querySelector('li.selected');
+        if (selectedListItem) {
+          selectedListItem.scrollIntoView({block: 'center'});
+        }
+      }
+    }, 0);
+  }
+</script>
+
+<div class="form-autocomplete" class:small={variant === 'small'}>
+  <!-- autocomplete input container -->
+  <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
+    <!-- autocomplete real input box -->
+    <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
+           class="form-input" type="text" autocomplete="off" autocapitalize="off"
+           on:input={handleInput} on:keydown={handleKeyDown}
+           on:focus={handleFocus} on:blur={handleBlur}>
+  </div>
+
+  <!-- autocomplete suggestion list -->
+  <ul class="menu" class:open={isOpen && suggestions.length > 0}
+      bind:this={suggestionList}>
+    <!-- menu list items -->
+    {#each suggestions as tag,i}
+      <li class="menu-item" class:selected={selectedIndex === i}>
+        <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
+          <div class="tile tile-centered">
+            <div class="tile-content">
+              {tag.name}
+            </div>
+          </div>
+        </a>
+      </li>
+    {/each}
+  </ul>
+</div>
+
+<style>
+    .menu {
+        display: none;
+        max-height: 200px;
+        overflow: auto;
+    }
+
+    .menu.open {
+        display: block;
+    }
+
+    .form-autocomplete.small .form-autocomplete-input {
+        height: 1.4rem;
+        min-height: 1.4rem;
+    }
+
+    .form-autocomplete.small .form-autocomplete-input input {
+        margin: 0;
+        padding: 0;
+        font-size: 0.7rem;
+    }
+
+    .form-autocomplete.small .menu .menu-item {
+        font-size: 0.7rem;
+    }
+</style>

bookmarks/frontend/index.js

@@ -0,0 +1,14 @@
+import TagAutoComplete from "./components/TagAutocomplete.svelte";
+import SearchAutoComplete from "./components/SearchAutoComplete.svelte";
+import { ApiClient } from "./api";
+import "./behaviors/bookmark-page";
+import "./behaviors/bulk-edit";
+import "./behaviors/confirm-button";
+import "./behaviors/global-shortcuts";
+import "./behaviors/tag-autocomplete";
+
+export default {
+  ApiClient,
+  TagAutoComplete,
+  SearchAutoComplete,
+};

bookmarks/frontend/util.js

@@ -0,0 +1,37 @@
+export function debounce(callback, delay = 250) {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      callback(...args);
+    }, delay);
+  };
+}
+
+export function clampText(text, maxChars = 30) {
+  if (!text || text.length <= 30) return text;
+
+  return text.substr(0, maxChars) + "...";
+}
+
+export function getCurrentWordBounds(input) {
+  const text = input.value;
+  const end = input.selectionStart;
+  let start = end;
+
+  let currentChar = text.charAt(start - 1);
+
+  while (currentChar && currentChar !== " " && start > 0) {
+    start--;
+    currentChar = text.charAt(start - 1);
+  }
+
+  return { start, end };
+}
+
+export function getCurrentWord(input) {
+  const bounds = getCurrentWordBounds(input);
+
+  return input.value.substring(bounds.start, bounds.end);
+}

bookmarks/management/commands/enable_wal.py

@@ -0,0 +1,24 @@
+import logging
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.db import connections
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Enable WAL journal mode when using an SQLite database"
+
+    def handle(self, *args, **options):
+        if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3':
+            return
+
+        connection = connections['default']
+        with connection.cursor() as cursor:
+            cursor.execute("PRAGMA journal_mode")
+            current_mode = cursor.fetchone()[0]
+            logger.info(f'Current journal mode: {current_mode}')
+            if current_mode != 'wal':
+                cursor.execute("PRAGMA journal_mode=wal;")
+                logger.info('Switched to WAL journal mode')

bookmarks/middlewares.py

@@ -1,6 +1,24 @@
 from django.conf import settings
 from django.contrib.auth.middleware import RemoteUserMiddleware
 
+from bookmarks.models import UserProfile
+
 
 class CustomRemoteUserMiddleware(RemoteUserMiddleware):
     header = settings.LD_AUTH_PROXY_USERNAME_HEADER
+
+
+class UserProfileMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.user.is_authenticated:
+            request.user_profile = request.user.profile
+        else:
+            request.user_profile = UserProfile()
+            request.user_profile.enable_favicons = True
+
+        response = self.get_response(request)
+
+        return response

bookmarks/migrations/0020_userprofile_tag_search.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-04-10 01:55
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0019_userprofile_enable_favicons'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='tag_search',
+            field=models.CharField(choices=[('strict', 'Strict'), ('lax', 'Lax')], default='strict', max_length=10),
+        ),
+    ]

bookmarks/migrations/0021_userprofile_display_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-05-18 07:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0020_userprofile_tag_search'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='display_url',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0022_bookmark_notes.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-05-19 10:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0021_userprofile_display_url'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='bookmark',
+            name='notes',
+            field=models.TextField(blank=True),
+        ),
+    ]

bookmarks/migrations/0023_userprofile_permanent_notes.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.9 on 2023-05-20 08:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0022_bookmark_notes'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='permanent_notes',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0024_userprofile_enable_public_sharing.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.9 on 2023-08-14 07:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0023_userprofile_permanent_notes'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='enable_public_sharing',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/models.py

@@ -50,6 +50,7 @@ class Bookmark(models.Model):
     url = models.CharField(max_length=2048, validators=[BookmarkURLValidator()])
     title = models.CharField(max_length=512, blank=True)
     description = models.TextField(blank=True)
+    notes = models.TextField(blank=True)
     website_title = models.CharField(max_length=512, blank=True, null=True)
     website_description = models.TextField(blank=True, null=True)
     web_archive_snapshot_url = models.CharField(max_length=2048, blank=True)
@@ -110,6 +111,7 @@ class BookmarkForm(forms.ModelForm):
             'tag_string',
             'title',
             'description',
+            'notes',
             'website_title',
             'website_description',
             'unread',
@@ -117,6 +119,10 @@ class BookmarkForm(forms.ModelForm):
             'auto_close',
         ]
 
+    @property
+    def has_notes(self):
+        return self.instance and self.instance.notes
+
 
 class BookmarkFilters:
     def __init__(self, request: WSGIRequest):
@@ -153,6 +159,12 @@ class UserProfile(models.Model):
         (WEB_ARCHIVE_INTEGRATION_DISABLED, 'Disabled'),
         (WEB_ARCHIVE_INTEGRATION_ENABLED, 'Enabled'),
     ]
+    TAG_SEARCH_STRICT = 'strict'
+    TAG_SEARCH_LAX = 'lax'
+    TAG_SEARCH_CHOICES = [
+        (TAG_SEARCH_STRICT, 'Strict'),
+        (TAG_SEARCH_LAX, 'Lax'),
+    ]
     user = models.OneToOneField(get_user_model(), related_name='profile', on_delete=models.CASCADE)
     theme = models.CharField(max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO)
     bookmark_date_display = models.CharField(max_length=10, choices=BOOKMARK_DATE_DISPLAY_CHOICES, blank=False,
@@ -161,14 +173,20 @@ class UserProfile(models.Model):
                                             default=BOOKMARK_LINK_TARGET_BLANK)
     web_archive_integration = models.CharField(max_length=10, choices=WEB_ARCHIVE_INTEGRATION_CHOICES, blank=False,
                                                default=WEB_ARCHIVE_INTEGRATION_DISABLED)
+    tag_search = models.CharField(max_length=10, choices=TAG_SEARCH_CHOICES, blank=False,
+                                  default=TAG_SEARCH_STRICT)
     enable_sharing = models.BooleanField(default=False, null=False)
+    enable_public_sharing = models.BooleanField(default=False, null=False)
     enable_favicons = models.BooleanField(default=False, null=False)
+    display_url = models.BooleanField(default=False, null=False)
+    permanent_notes = models.BooleanField(default=False, null=False)
 
 
 class UserProfileForm(forms.ModelForm):
     class Meta:
         model = UserProfile
-        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'enable_sharing', 'enable_favicons']
+        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'tag_search',
+                  'enable_sharing', 'enable_public_sharing', 'enable_favicons', 'display_url', 'permanent_notes']
 
 
 @receiver(post_save, sender=get_user_model())

bookmarks/queries.py

@@ -1,29 +1,32 @@
 from typing import Optional
 
 from django.contrib.auth.models import User
-from django.db.models import Q, QuerySet
+from django.db.models import Q, QuerySet, Exists, OuterRef
 
-from bookmarks.models import Bookmark, Tag
+from bookmarks.models import Bookmark, Tag, UserProfile
 from bookmarks.utils import unique
 
 
-def query_bookmarks(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+def query_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, profile, query_string) \
         .filter(is_archived=False)
 
 
-def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+def query_archived_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, profile, query_string) \
         .filter(is_archived=True)
 
 
-def query_shared_bookmarks(user: Optional[User], query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
-        .filter(shared=True) \
-        .filter(owner__profile__enable_sharing=True)
+def query_shared_bookmarks(user: Optional[User], profile: UserProfile, query_string: str,
+                           public_only: bool) -> QuerySet:
+    conditions = Q(shared=True) & Q(owner__profile__enable_sharing=True)
+    if public_only:
+        conditions = conditions & Q(owner__profile__enable_public_sharing=True)
+
+    return _base_bookmarks_query(user, profile, query_string).filter(conditions)
 
 
-def _base_bookmarks_query(user: Optional[User], query_string: str) -> QuerySet:
+def _base_bookmarks_query(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
     query_set = Bookmark.objects
 
     # Filter for user
@@ -35,13 +38,17 @@ def _base_bookmarks_query(user: Optional[User], query_string: str) -> QuerySet:
 
     # Filter for search terms and tags
     for term in query['search_terms']:
-        query_set = query_set.filter(
-            Q(title__contains=term)
-            | Q(description__contains=term)
-            | Q(website_title__contains=term)
-            | Q(website_description__contains=term)
-            | Q(url__contains=term)
-        )
+        conditions = Q(title__icontains=term) \
+                     | Q(description__icontains=term) \
+                     | Q(notes__icontains=term) \
+                     | Q(website_title__icontains=term) \
+                     | Q(website_description__icontains=term) \
+                     | Q(url__icontains=term)
+
+        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
+            conditions = conditions | Exists(Bookmark.objects.filter(id=OuterRef('id'), tags__name__iexact=term))
+
+        query_set = query_set.filter(conditions)
 
     for tag_name in query['tag_names']:
         query_set = query_set.filter(
@@ -65,32 +72,33 @@ def _base_bookmarks_query(user: Optional[User], query_string: str) -> QuerySet:
     return query_set
 
 
-def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_bookmarks(user, query_string)
+def query_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_bookmarks(user, profile, query_string)
 
     query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
 
     return query_set.distinct()
 
 
-def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_archived_bookmarks(user, query_string)
+def query_archived_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_archived_bookmarks(user, profile, query_string)
 
     query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
 
     return query_set.distinct()
 
 
-def query_shared_bookmark_tags(user: Optional[User], query_string: str) -> QuerySet:
-    bookmarks_query = query_shared_bookmarks(user, query_string)
+def query_shared_bookmark_tags(user: Optional[User], profile: UserProfile, query_string: str,
+                               public_only: bool) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(user, profile, query_string, public_only)
 
     query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
 
     return query_set.distinct()
 
 
-def query_shared_bookmark_users(query_string: str) -> QuerySet:
-    bookmarks_query = query_shared_bookmarks(None, query_string)
+def query_shared_bookmark_users(profile: UserProfile, query_string: str, public_only: bool) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(None, profile, query_string, public_only)
 
     query_set = User.objects.filter(bookmark__in=bookmarks_query)
 

bookmarks/services/bookmarks.py

@@ -122,6 +122,7 @@ def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_us
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
     to_bookmark.title = from_bookmark.title
     to_bookmark.description = from_bookmark.description
+    to_bookmark.notes = from_bookmark.notes
     to_bookmark.unread = from_bookmark.unread
     to_bookmark.shared = from_bookmark.shared
 

bookmarks/services/exporter.py

@@ -1,3 +1,4 @@
+import html
 from typing import List
 
 from bookmarks.models import Bookmark
@@ -28,13 +29,14 @@ def append_list_start(doc: BookmarkDocument):
 
 def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
     url = bookmark.url
-    title = bookmark.resolved_title
-    desc = bookmark.resolved_description
+    title = html.escape(bookmark.resolved_title or '')
+    desc = html.escape(bookmark.resolved_description or '')
     tags = ','.join(bookmark.tag_names)
     toread = '1' if bookmark.unread else '0'
+    private = '0' if bookmark.shared else '1'
     added = int(bookmark.date_added.timestamp())
 
-    doc.append(f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="0" TOREAD="{toread}" TAGS="{tags}">{title}</A>')
+    doc.append(f'<DT><A HREF="{url}" ADD_DATE="{added}" PRIVATE="{private}" TOREAD="{toread}" TAGS="{tags}">{title}</A>')
 
     if desc:
         doc.append(f'<DD>{desc}')

bookmarks/services/favicon_loader.py

@@ -1,6 +1,7 @@
+import logging
+import mimetypes
 import os.path
 import re
-import shutil
 import time
 from pathlib import Path
 from urllib.parse import urlparse
@@ -10,25 +11,46 @@ from django.conf import settings
 
 max_file_age = 60 * 60 * 24  # 1 day
 
+logger = logging.getLogger(__name__)
+
+# register mime type for .ico files, which is not included in the default
+# mimetypes of the Docker image
+mimetypes.add_type('image/x-icon', '.ico')
+
 
 def _ensure_favicon_folder():
     Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)
 
 
 def _url_to_filename(url: str) -> str:
-    name = re.sub(r'\W+', '_', url)
-    return f'{name}.png'
+    return re.sub(r'\W+', '_', url)
 
 
-def _get_base_url(url: str) -> str:
+def _get_url_parameters(url: str) -> dict:
     parsed_uri = urlparse(url)
-    return f'{parsed_uri.scheme}://{parsed_uri.hostname}'
+    return {
+        # https://example.com/foo?bar -> https://example.com
+        'url': f'{parsed_uri.scheme}://{parsed_uri.hostname}',
+        # https://example.com/foo?bar -> example.com
+        'domain': parsed_uri.hostname,
+    }
 
 
 def _get_favicon_path(favicon_file: str) -> Path:
     return Path(os.path.join(settings.LD_FAVICON_FOLDER, favicon_file))
 
 
+def _check_existing_favicon(favicon_name: str):
+    # return existing file if a file with the same name, ignoring extension,
+    # exists and is not stale
+    for filename in os.listdir(settings.LD_FAVICON_FOLDER):
+        file_base_name, _ = os.path.splitext(filename)
+        if file_base_name == favicon_name:
+            favicon_path = _get_favicon_path(filename)
+            return filename if not _is_stale(favicon_path) else None
+    return None
+
+
 def _is_stale(path: Path) -> bool:
     stat = path.stat()
     file_age = time.time() - stat.st_mtime
@@ -36,22 +58,26 @@ def _is_stale(path: Path) -> bool:
 
 
 def load_favicon(url: str) -> str:
-    # Get base URL so that we can reuse favicons for multiple bookmarks with the same host
-    base_url = _get_base_url(url)
-    favicon_name = _url_to_filename(base_url)
-    favicon_path = _get_favicon_path(favicon_name)
+    url_parameters = _get_url_parameters(url)
 
-    # Load icon if it doesn't exist yet or has become stale
-    if not favicon_path.exists() or _is_stale(favicon_path):
-        # Create favicon folder if not exists
-        _ensure_favicon_folder()
+    # Create favicon folder if not exists
+    _ensure_favicon_folder()
+    # Use scheme+hostname as favicon filename to reuse icon for all pages on the same domain
+    favicon_name = _url_to_filename(url_parameters['url'])
+    favicon_file = _check_existing_favicon(favicon_name)
+
+    if not favicon_file:
         # Load favicon from provider, save to file
-        favicon_url = settings.LD_FAVICON_PROVIDER.format(url=base_url)
-        response = requests.get(favicon_url, stream=True)
+        favicon_url = settings.LD_FAVICON_PROVIDER.format(**url_parameters)
+        logger.debug(f'Loading favicon from: {favicon_url}')
+        with requests.get(favicon_url, stream=True) as response:
+            content_type = response.headers['Content-Type']
+            file_extension = mimetypes.guess_extension(content_type)
+            favicon_file = f'{favicon_name}{file_extension}'
+            favicon_path = _get_favicon_path(favicon_file)
+            with open(favicon_path, 'wb') as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+        logger.debug(f'Saved favicon as: {favicon_path}')
 
-        with open(favicon_path, 'wb') as file:
-            shutil.copyfileobj(response.raw, file)
-
-        del response
-
-    return favicon_name
+    return favicon_file

bookmarks/services/importer.py

@@ -20,6 +20,11 @@ class ImportResult:
     failed: int = 0
 
 
+@dataclass
+class ImportOptions:
+    map_private_flag: bool = False
+
+
 class TagCache:
     def __init__(self, user: User):
         self.user = user
@@ -50,7 +55,7 @@ class TagCache:
         self.cache[tag.name.lower()] = tag
 
 
-def import_netscape_html(html: str, user: User):
+def import_netscape_html(html: str, user: User, options: ImportOptions = ImportOptions()) -> ImportResult:
     result = ImportResult()
     import_start = timezone.now()
 
@@ -70,7 +75,7 @@ def import_netscape_html(html: str, user: User):
     # Split bookmarks to import into batches, to keep memory usage for bulk operations manageable
     batches = _get_batches(netscape_bookmarks, 200)
     for batch in batches:
-        _import_batch(batch, user, tag_cache, result)
+        _import_batch(batch, user, options, tag_cache, result)
 
     # Create snapshots for newly imported bookmarks
     tasks.schedule_bookmarks_without_snapshots(user)
@@ -114,7 +119,11 @@ def _get_batches(items: List, batch_size: int):
     return batches
 
 
-def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_cache: TagCache, result: ImportResult):
+def _import_batch(netscape_bookmarks: List[NetscapeBookmark],
+                  user: User,
+                  options: ImportOptions,
+                  tag_cache: TagCache,
+                  result: ImportResult):
     # Query existing bookmarks
     batch_urls = [bookmark.href for bookmark in netscape_bookmarks]
     existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)
@@ -135,7 +144,7 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
             else:
                 is_update = True
             # Copy data from parsed bookmark
-            _copy_bookmark_data(netscape_bookmark, bookmark)
+            _copy_bookmark_data(netscape_bookmark, bookmark, options)
             # Validate bookmark fields, exclude owner to prevent n+1 database query,
             # also there is no specific validation on owner
             bookmark.clean_fields(exclude=['owner'])
@@ -152,8 +161,14 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
             result.failed = result.failed + 1
 
     # Bulk update bookmarks in DB
-    Bookmark.objects.bulk_update(bookmarks_to_update,
-                                 ['url', 'date_added', 'date_modified', 'unread', 'title', 'description', 'owner'])
+    Bookmark.objects.bulk_update(bookmarks_to_update, ['url',
+                                                       'date_added',
+                                                       'date_modified',
+                                                       'unread',
+                                                       'shared',
+                                                       'title',
+                                                       'description',
+                                                       'owner'])
     # Bulk insert new bookmarks into DB
     Bookmark.objects.bulk_create(bookmarks_to_create)
 
@@ -187,7 +202,7 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
     BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)
 
 
-def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark):
+def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark, options: ImportOptions):
     bookmark.url = netscape_bookmark.href
     if netscape_bookmark.date_added:
         bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
@@ -199,3 +214,5 @@ def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark)
         bookmark.title = netscape_bookmark.title
     if netscape_bookmark.description:
         bookmark.description = netscape_bookmark.description
+    if options.map_private_flag and not netscape_bookmark.private:
+        bookmark.shared = True

bookmarks/services/parser.py

@@ -11,6 +11,7 @@ class NetscapeBookmark:
     date_added: str
     tag_string: str
     to_read: bool
+    private: bool
 
 
 class BookmarkParser(HTMLParser):
@@ -26,6 +27,7 @@ class BookmarkParser(HTMLParser):
         self.title = ''
         self.description = ''
         self.toread = ''
+        self.private = ''
 
     def handle_starttag(self, tag: str, attrs: list):
         name = 'handle_start_' + tag.lower()
@@ -58,7 +60,9 @@ class BookmarkParser(HTMLParser):
             description='',
             date_added=self.add_date,
             tag_string=self.tags,
-            to_read=self.toread == '1'
+            to_read=self.toread == '1',
+            # Mark as private by default, also when attribute is not specified
+            private=self.private != '0',
         )
 
     def handle_a_data(self, data):
@@ -79,6 +83,7 @@ class BookmarkParser(HTMLParser):
         self.title = ''
         self.description = ''
         self.toread = ''
+        self.private = ''
 
 
 def parse(html: str) -> List[NetscapeBookmark]:

bookmarks/services/tasks.py

@@ -130,12 +130,12 @@ def _load_favicon_task(bookmark_id: int):
 
     logger.info(f'Load favicon for bookmark. url={bookmark.url}')
 
-    new_favicon = favicon_loader.load_favicon(bookmark.url)
+    new_favicon_file = favicon_loader.load_favicon(bookmark.url)
 
-    if new_favicon != bookmark.favicon_file:
-        bookmark.favicon_file = new_favicon
+    if new_favicon_file != bookmark.favicon_file:
+        bookmark.favicon_file = new_favicon_file
         bookmark.save(update_fields=['favicon_file'])
-        logger.info(f'Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon}')
+        logger.info(f'Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon_file}')
 
 
 def schedule_bookmarks_without_favicons(user: User):

bookmarks/services/website_loader.py

@@ -71,8 +71,10 @@ def load_page(url: str):
             logger.debug(f'Loaded chunk (iteration={iteration}, total={size / 1024})')
 
             # Stop reading if we have parsed end of head tag
-            if '</head>'.encode('utf-8') in content:
+            end_of_head = '</head>'.encode('utf-8')
+            if end_of_head in content:
                 logger.debug(f'Found closing head tag after {size} bytes')
+                content = content.split(end_of_head)[0] + end_of_head
                 break
             # Stop reading if we exceed limit
             if size > MAX_CONTENT_LIMIT:

bookmarks/static/bookmark_list.js

@@ -1,127 +0,0 @@
-(function () {
-  function setupBulkEdit() {
-    const bulkEditToggle = document.getElementById('bulk-edit-mode')
-    const bulkEditBar = document.querySelector('.bulk-edit-bar')
-    const singleToggles = document.querySelectorAll('.bulk-edit-toggle input')
-    const allToggle = document.querySelector('.bulk-edit-all-toggle input')
-
-    function isAllSelected() {
-      let result = true
-
-      singleToggles.forEach(function (toggle) {
-        result = result && toggle.checked
-      })
-
-      return result
-    }
-
-    function selectAll() {
-      singleToggles.forEach(function (toggle) {
-        toggle.checked = true
-      })
-    }
-
-    function deselectAll() {
-      singleToggles.forEach(function (toggle) {
-        toggle.checked = false
-      })
-    }
-
-    // Toggle all
-    allToggle.addEventListener('change', function (e) {
-      if (e.target.checked) {
-        selectAll()
-      } else {
-        deselectAll()
-      }
-    })
-
-    // Toggle single
-    singleToggles.forEach(function (toggle) {
-      toggle.addEventListener('change', function () {
-        allToggle.checked = isAllSelected()
-      })
-    })
-
-    // Allow overflow when bulk edit mode is active to be able to display tag auto complete menu
-    let bulkEditToggleTimeout
-    if (bulkEditToggle.checked) {
-      bulkEditBar.style.overflow = 'visible';
-    }
-    bulkEditToggle.addEventListener('change', function (e) {
-      if (bulkEditToggleTimeout) {
-        clearTimeout(bulkEditToggleTimeout);
-        bulkEditToggleTimeout = null;
-      }
-      if (e.target.checked) {
-        bulkEditToggleTimeout = setTimeout(function () {
-          bulkEditBar.style.overflow = 'visible';
-        }, 500);
-      } else {
-        bulkEditBar.style.overflow = 'hidden';
-      }
-    });
-  }
-
-  function setupBulkEditTagAutoComplete() {
-    const wrapper = document.createElement('div');
-    const tagInput = document.getElementById('bulk-edit-tags-input');
-    const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || '';
-    const apiClient = new linkding.ApiClient(apiBaseUrl)
-
-    new linkding.TagAutoComplete({
-      target: wrapper,
-      props: {
-        id: 'bulk-edit-tags-input',
-        name: tagInput.name,
-        value: tagInput.value,
-        apiClient: apiClient,
-        variant: 'small'
-      }
-    });
-
-    tagInput.parentElement.replaceChild(wrapper, tagInput);
-  }
-
-  function setupListNavigation() {
-    // Add logic for navigating bookmarks with arrow keys
-    document.addEventListener('keydown', event => {
-      // Skip if event occurred within an input element
-      // or does not use arrow keys
-      const targetNodeName = event.target.nodeName;
-      const isInputTarget = targetNodeName === 'INPUT'
-        || targetNodeName === 'SELECT'
-        || targetNodeName === 'TEXTAREA';
-      const isArrowUp = event.key === 'ArrowUp';
-      const isArrowDown = event.key === 'ArrowDown';
-
-      if (isInputTarget || !(isArrowUp || isArrowDown)) {
-        return;
-      }
-      event.preventDefault();
-
-      // Detect current bookmark list item
-      const path = event.composedPath();
-      const currentItem = path.find(item => item.hasAttribute && item.hasAttribute('data-is-bookmark-item'));
-
-      // Find next item
-      let nextItem;
-      if (currentItem) {
-        nextItem = isArrowUp
-          ? currentItem.previousElementSibling
-          : currentItem.nextElementSibling;
-      } else {
-        // Select first item
-        nextItem = document.querySelector('li[data-is-bookmark-item]');
-      }
-      // Focus first link
-      if (nextItem) {
-        nextItem.querySelector('a').focus();
-      }
-    });
-  }
-
-  setupBulkEdit();
-  setupBulkEditTagAutoComplete();
-  setupListNavigation();
-})()

bookmarks/static/shared.js

@@ -1,83 +0,0 @@
-(function () {
-
-    function initConfirmationButtons() {
-        const buttonEls = document.querySelectorAll('.btn-confirmation');
-
-        function showConfirmation(buttonEl) {
-            const cancelEl = document.createElement(buttonEl.nodeName);
-            cancelEl.innerText = 'Cancel';
-            cancelEl.className = 'btn btn-link btn-sm btn-confirmation-action mr-1';
-            cancelEl.addEventListener('click', function () {
-                container.remove();
-                buttonEl.style = '';
-            });
-
-            const confirmEl = document.createElement(buttonEl.nodeName);
-            confirmEl.innerText = 'Confirm';
-            confirmEl.className = 'btn btn-link btn-delete btn-sm btn-confirmation-action';
-
-            if (buttonEl.nodeName === 'BUTTON') {
-                confirmEl.type = buttonEl.type;
-                confirmEl.name = buttonEl.name;
-                confirmEl.value = buttonEl.value;
-            }
-            if (buttonEl.nodeName === 'A') {
-                confirmEl.href = buttonEl.href;
-            }
-
-            const container = document.createElement('span');
-            container.className = 'confirmation'
-            container.appendChild(cancelEl);
-            container.appendChild(confirmEl);
-            buttonEl.parentElement.insertBefore(container, buttonEl);
-            buttonEl.style = 'display: none';
-        }
-
-        buttonEls.forEach(function (linkEl) {
-            linkEl.addEventListener('click', function (e) {
-                e.preventDefault();
-                showConfirmation(linkEl);
-            });
-        });
-    }
-
-    function initGlobalShortcuts() {
-        // Focus search button
-        document.addEventListener('keydown', function (event) {
-            // Filter for shortcut key
-            if (event.key !== 's') return;
-            // Skip if event occurred within an input element
-            const targetNodeName = event.target.nodeName;
-            const isInputTarget = targetNodeName === 'INPUT'
-                || targetNodeName === 'SELECT'
-                || targetNodeName === 'TEXTAREA';
-
-            if (isInputTarget) return;
-
-            const searchInput = document.querySelector('input[type="search"]');
-
-            if (searchInput) {
-                searchInput.focus();
-                event.preventDefault();
-            }
-        });
-
-        // Add new bookmark
-        document.addEventListener('keydown', function(event) {
-            // Filter for new entry shortcut key
-            if (event.key !== 'n') return;
-            // Skip if event occurred within an input element
-            const targetNodeName = event.target.nodeName;
-            const isInputTarget = targetNodeName === 'INPUT'
-                || targetNodeName === 'SELECT'
-                || targetNodeName === 'TEXTAREA';
-
-            if (isInputTarget) return;
-
-            window.location.assign("/bookmarks/new");
-        });
-    }
-
-    initConfirmationButtons();
-    initGlobalShortcuts();
-})()

bookmarks/styles/base.scss

@@ -72,6 +72,12 @@ a:visited:hover {
   color: $link-color-dark;
 }
 
+code {
+  color: $gray-color-dark;
+  background-color: $code-bg-color;
+  box-shadow: 1px 1px 0 $code-shadow-color;
+}
+
 // Increase spacing between columns
 .container > .columns > .column:not(:first-child) {
   padding-left: 2rem;
@@ -102,3 +108,12 @@ a:visited:hover {
     font-weight: bold;
   }
 }
+
+// Increase input font size on small viewports to prevent zooming on focus the input
+// on mobile devices. 430px relates to the "normalized" iPhone 14 Pro Max
+// viewport size
+@media screen and (max-width: 430px) {
+  .form-input {
+    font-size: 16px;
+  }
+}

bookmarks/styles/bookmarks.scss

@@ -1,3 +1,4 @@
+/* Bookmark search box */
 .bookmarks-page .search {
   $searchbox-width: 180px;
   $searchbox-width-md: 300px;
@@ -37,17 +38,20 @@
   }
 }
 
-.bookmarks-page .content-area-header {
-  span.btn {
-    margin-left: 8px;
-  }
-}
-
+/* Bookmark list */
 ul.bookmark-list {
-
   list-style: none;
   margin: 0;
   padding: 0;
+}
+
+/* Bookmarks */
+li[ld-bookmark-item] {
+  position: relative;
+
+  [ld-bulk-edit-checkbox].form-checkbox {
+    display: none;
+  }
 
   .title a {
     display: inline-block;
@@ -64,6 +68,10 @@ ul.bookmark-list {
     vertical-align: text-top;
   }
 
+  .url-display {
+    color: $secondary-link-color;
+  }
+
   .description {
     color: $gray-color-dark;
 
@@ -72,31 +80,41 @@ ul.bookmark-list {
     }
   }
 
-  .actions > *:not(:last-child) {
-    margin-right: 0.1rem;
+  .actions {
+    display: flex;
+    align-items: baseline;
+    flex-wrap: wrap;
+    gap: 0.4rem;
   }
 
-  .actions .date-label a {
-    color: $gray-color;
-  }
+  .actions {
+    a, button.btn-link {
+      color: $gray-color;
+      padding: 0;
+      height: auto;
+      vertical-align: unset;
+      border: none;
+      transition: none;
+      text-decoration: none;
 
-  .actions .btn-link {
-    color: $gray-color;
-    padding: 0;
-    height: auto;
-    vertical-align: unset;
-    border: none;
-
-    &:focus,
-    &:hover,
-    &:active,
-    &.active {
-      color: $gray-color-dark;
+      &:focus,
+      &:hover,
+      &:active,
+      &.active {
+        color: $gray-color-dark;
+      }
     }
-  }
 
-  .bulk-edit-toggle {
-    display: none;
+    .separator {
+      align-self: flex-start;
+    }
+
+    .toggle-notes {
+      align-self: center;
+      display: flex;
+      align-items: center;
+      gap: 0.1rem;
+    }
   }
 }
 
@@ -176,16 +194,79 @@ ul.bookmark-list {
       font-weight: bold;
     }
   }
+
+  details.notes textarea {
+    box-sizing: border-box;
+  }
 }
 
-/* Bookmark actions / bulk edit */
+/* Bookmark notes */
+ul.bookmark-list {
+  .notes {
+    display: none;
+    max-height: 300px;
+    margin: 4px 0;
+    overflow: auto;
+  }
+
+  &.show-notes .notes,
+  li.show-notes .notes {
+    display: block;
+  }
+}
+
+/* Bookmark notes markdown styles */
+ul.bookmark-list .notes-content {
+  & {
+    padding: 0.4rem 0.6rem;
+  }
+
+  p, ul, ol, pre, blockquote {
+    margin: 0 0 0.4rem 0;
+  }
+
+  > *:first-child {
+    margin-top: 0;
+  }
+
+  > *:last-child {
+    margin-bottom: 0;
+  }
+
+  ul, ol {
+    margin-left: 0.8rem;
+  }
+
+  ul li, ol li {
+    margin-top: 0.2rem;
+  }
+
+  pre {
+    padding: 0.2rem 0.4rem;
+    background-color: $code-bg-color;
+    border-radius: 0.2rem;
+  }
+
+  pre code {
+    background: none;
+    box-shadow: none;
+    padding: 0;
+  }
+
+  > pre:first-child:last-child {
+    padding: 0;
+    background: none;
+    border-radius: 0;
+  }
+}
+
+/* Bookmark bulk edit */
 $bulk-edit-toggle-width: 16px;
 $bulk-edit-toggle-offset: 8px;
 $bulk-edit-bar-offset: $bulk-edit-toggle-width + (2 * $bulk-edit-toggle-offset);
 $bulk-edit-transition-duration: 400ms;
 
-.bookmarks-page form.bookmark-actions {
-
+[ld-bulk-edit] {
   .bulk-edit-bar {
     margin-top: -17px;
     margin-bottom: 16px;
@@ -195,56 +276,27 @@ $bulk-edit-transition-duration: 400ms;
     transition: max-height $bulk-edit-transition-duration;
   }
 
-  .bulk-edit-actions {
-    display: flex;
-    align-items: baseline;
-    padding: 4px 0;
-    border-top: solid 1px $border-color;
-
-    button:hover {
-      text-decoration: underline;
-    }
-
-    > label.form-checkbox {
-      min-height: 1rem;
-    }
-
-    > button {
-      padding: 0;
-      margin-left: 8px;
-    }
-
-    > span {
-      margin-left: 8px;
-    }
-
-    > input, .form-autocomplete {
-      width: auto;
-      margin-left: 4px;
-      max-width: 200px;
-      -webkit-appearance: none;
-    }
-
-    span.confirmation {
-      display: flex;
-    }
-
-    span.confirmation button {
-      padding: 0;
-    }
+  &.active .bulk-edit-bar {
+    max-height: 37px;
+    border-bottom: solid 1px $border-color;
   }
 
-  .bulk-edit-all-toggle {
+  /* remove overflow after opening animation, otherwise tag autocomplete overlay gets cut off */
+  &.active:not(.activating) .bulk-edit-bar {
+    overflow: visible;
+  }
+
+  /* All checkbox */
+  [ld-bulk-edit-checkbox][all].form-checkbox {
+    display: block;
     width: $bulk-edit-toggle-width;
     margin: 0 0 0 $bulk-edit-toggle-offset;
     padding: 0;
+    min-height: 1rem;
   }
 
-  ul.bookmark-list li {
-    position: relative;
-  }
-
-  ul.bookmark-list li .bulk-edit-toggle {
+  /* Bookmark checkboxes */
+  li[ld-bookmark-item] [ld-bulk-edit-checkbox].form-checkbox {
     display: block;
     position: absolute;
     width: $bulk-edit-toggle-width;
@@ -256,22 +308,36 @@ $bulk-edit-transition-duration: 400ms;
     opacity: 0;
     transition: all $bulk-edit-transition-duration;
 
-    i {
+    .form-icon {
       top: 0.2rem;
     }
   }
-}
 
-#bulk-edit-mode {
-  display: none;
-}
+  &.active li[ld-bookmark-item] [ld-bulk-edit-checkbox].form-checkbox {
+    visibility: visible;
+    opacity: 1;
+  }
 
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-toggle {
-  visibility: visible;
-  opacity: 1;
-}
+  /* Actions */
+  .bulk-edit-actions {
+    display: flex;
+    align-items: baseline;
+    padding: 4px 0;
+    border-top: solid 1px $border-color;
+    gap: 8px;
 
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-bar {
-  max-height: 37px;
-  border-bottom: solid 1px $border-color;
+    button {
+      padding: 0 !important;
+    }
+
+    button:hover {
+      text-decoration: underline;
+    }
+
+    > input, .form-autocomplete {
+      width: auto;
+      max-width: 200px;
+      -webkit-appearance: none;
+    }
+  }
 }

bookmarks/styles/shared.scss

@@ -14,9 +14,15 @@ section.content-area {
 }
 
 // Confirm button component
-.btn-confirmation-action {
+span.confirmation {
+  display: flex;
+  align-items: baseline;
+}
+
+span.confirmation .btn.btn-link {
   color: $error-color !important;
+
   &:hover {
     text-decoration: underline;
   }
-}
+}

bookmarks/styles/variables-dark.scss

@@ -21,8 +21,13 @@ $link-color: $primary-color !default;
 $link-color-dark: darken($link-color, 5%) !default;
 $link-color-light: $link-color !default;
 
+$secondary-link-color: rgba(168, 177, 255, 0.73);
+
 $alternative-color: #59bdb9;
 $alternative-color-dark: #73f1eb;
 
+$code-bg-color: rgba(255, 255, 255, 0.1);
+$code-shadow-color: rgba(255, 255, 255, 0.2);
+
 /* Dark theme specific */
 $dt-primary-button-color: #5761cb !default;

bookmarks/styles/variables-light.scss

@@ -2,3 +2,8 @@ $html-font-size: 18px !default;
 
 $alternative-color: #05a6a3;
 $alternative-color-dark: darken($alternative-color, 5%);
+
+$secondary-link-color: rgba(87, 85, 217, 0.64);
+
+$code-bg-color: rgba(0, 0, 0, 0.05);
+$code-shadow-color: rgba(0, 0, 0, 0.15);

bookmarks/templates/bookmarks/archive.html

@@ -4,43 +4,42 @@
 {% load bookmarks %}
 
 {% block content %}
-
-  {% include 'bookmarks/bulk_edit/state.html' %}
-
-  <div class="bookmarks-page columns">
+  <div class="bookmarks-page columns"
+       ld-bulk-edit
+       ld-bookmark-page
+       bookmarks-url="{% url 'bookmarks:partials.bookmark_list.archived' %}"
+       tags-url="{% url 'bookmarks:partials.tag_cloud.archived' %}">
 
     {# Bookmark list #}
     <section class="content-area column col-8 col-md-12">
       <div class="content-area-header">
         <h2>Archived bookmarks</h2>
         <div class="spacer"></div>
-        {% bookmark_search filters tags mode='archived' %}
+        {% bookmark_search bookmark_list.filters tag_cloud.tags mode='archived' %}
         {% include 'bookmarks/bulk_edit/toggle.html' %}
       </div>
 
-      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
+      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ bookmark_list.return_url }}"
             method="post">
         {% csrf_token %}
         {% include 'bookmarks/bulk_edit/bar.html' with mode='archive' %}
 
-        {% if empty %}
-          {% include 'bookmarks/empty_bookmarks.html' %}
-        {% else %}
-          {% bookmark_list bookmarks return_url link_target %}
-        {% endif %}
+        <div class="bookmark-list-container">
+          {% include 'bookmarks/bookmark_list.html' %}
+        </div>
       </form>
     </section>
 
-    {# Tag list #}
+    {# Tag cloud #}
     <section class="content-area column col-4 hide-md">
       <div class="content-area-header">
         <h2>Tags</h2>
       </div>
-      {% tag_cloud tags selected_tags %}
+      <div class="tag-cloud-container">
+        {% include 'bookmarks/tag_cloud.html' %}
+      </div>
     </section>
   </div>
 
   <script src="{% static "bundle.js" %}"></script>
-  <script src="{% static "shared.js" %}"></script>
-  <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -1,28 +1,39 @@
 {% load static %}
 {% load shared %}
 {% load pagination %}
-{% htmlmin %}
-  <ul class="bookmark-list">
-    {% for bookmark in bookmarks %}
-      <li data-is-bookmark-item>
-        <label class="form-checkbox bulk-edit-toggle">
+
+{% if bookmark_list.is_empty %}
+  {% include 'bookmarks/empty_bookmarks.html' %}
+{% else %}
+  <ul class="bookmark-list{% if bookmark_list.show_notes %} show-notes{% endif %}">
+    {% for bookmark in bookmark_list.bookmarks_page %}
+      <li ld-bookmark-item>
+        <label ld-bulk-edit-checkbox class="form-checkbox">
           <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
           <i class="form-icon"></i>
         </label>
         <div class="title">
-          <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener"
+          <a href="{{ bookmark.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
              class="{% if bookmark.unread %}text-italic{% endif %}">
-            {% if bookmark.favicon_file and request.user.profile.enable_favicons %}
+            {% if bookmark.favicon_file and bookmark_list.show_favicons %}
               <img src="{% static bookmark.favicon_file %}" alt="">
             {% endif %}
             {{ bookmark.resolved_title }}
           </a>
         </div>
+        {% if bookmark_list.show_url %}
+          <div class="url-path truncate">
+            <a href="{{ bookmark.url }}" target="{{ bookmark_list.link_target }}" rel="noopener"
+               class="url-display text-sm">
+              {{ bookmark.url }}
+            </a>
+          </div>
+        {% endif %}
         <div class="description truncate">
           {% if bookmark.tag_names %}
             <span>
               {% for tag_name in bookmark.tag_names %}
-                <a href="?{% append_to_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
+                <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
               {% endfor %}
             </span>
           {% endif %}
@@ -31,41 +42,49 @@
             <span>{{ bookmark.resolved_description }}</span>
           {% endif %}
         </div>
-        <div class="actions">
-          {% if request.user.profile.bookmark_date_display == 'relative' %}
-            <span class="date-label text-gray text-sm">
+        {% if bookmark.notes %}
+          <div class="notes bg-gray text-gray-dark">
+            <div class="notes-content">
+              {% markdown bookmark.notes %}
+            </div>
+          </div>
+        {% endif %}
+        <div class="actions text-gray text-sm">
+          {% if bookmark_list.date_display == 'relative' %}
+            <span>
               {% if bookmark.web_archive_snapshot_url %}
                 <a href="{{ bookmark.web_archive_snapshot_url }}"
-                   title="Show snapshot on the Internet Archive Wayback Machine" target="{{ link_target }}"
+                   title="Show snapshot on the Internet Archive Wayback Machine"
+                   target="{{ bookmark_list.link_target }}"
                    rel="noopener">
               {% endif %}
               <span>{{ bookmark.date_added|humanize_relative_date }}</span>
               {% if bookmark.web_archive_snapshot_url %}
-                <span>∞</span>
+                ∞
                 </a>
               {% endif %}
             </span>
-            <span class="text-gray text-sm">|</span>
+            <span class="separator">|</span>
           {% endif %}
-          {% if request.user.profile.bookmark_date_display == 'absolute' %}
-            <span class="date-label text-gray text-sm">
+          {% if bookmark_list.date_display == 'absolute' %}
+            <span>
               {% if bookmark.web_archive_snapshot_url %}
                 <a href="{{ bookmark.web_archive_snapshot_url }}"
-                   title="Show snapshot on the Internet Archive Wayback Machine" target="{{ link_target }}"
+                   title="Show snapshot on the Internet Archive Wayback Machine"
+                   target="{{ bookmark_list.link_target }}"
                    rel="noopener">
               {% endif %}
               <span>{{ bookmark.date_added|humanize_absolute_date }}</span>
               {% if bookmark.web_archive_snapshot_url %}
-                <span>∞</span>
+                ∞
                 </a>
               {% endif %}
             </span>
-            <span class="text-gray text-sm">|</span>
+            <span class="separator">|</span>
           {% endif %}
           {% if bookmark.owner == request.user %}
             {# Bookmark owner actions #}
-            <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
-               class="btn btn-link btn-sm">Edit</a>
+            <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ bookmark_list.return_url }}">Edit</a>
             {% if bookmark.is_archived %}
               <button type="submit" name="unarchive" value="{{ bookmark.id }}"
                       class="btn btn-link btn-sm">Unarchive
@@ -75,28 +94,43 @@
                       class="btn btn-link btn-sm">Archive
               </button>
             {% endif %}
-            <button type="submit" name="remove" value="{{ bookmark.id }}"
-                    class="btn btn-link btn-sm btn-confirmation">Remove
+            <button ld-confirm-button type="submit" name="remove" value="{{ bookmark.id }}"
+                    class="btn btn-link btn-sm">Remove
             </button>
             {% if bookmark.unread %}
-              <span class="text-gray text-sm">|</span>
+              <span class="separator">|</span>
               <button type="submit" name="mark_as_read" value="{{ bookmark.id }}"
                       class="btn btn-link btn-sm">Mark as read
               </button>
             {% endif %}
           {% else %}
             {# Shared bookmark actions #}
-            <span class="text-gray text-sm">Shared by
-              <a class="text-gray"
-                 href="?{% replace_query_param user=bookmark.owner.username %}">{{ bookmark.owner.username }}</a>
+            <span>Shared by
+              <a href="?{% replace_query_param user=bookmark.owner.username %}">{{ bookmark.owner.username }}</a>
             </span>
           {% endif %}
+          {% if bookmark.notes and not bookmark_list.show_notes %}
+            <span class="separator">|</span>
+            <button class="btn btn-link btn-sm toggle-notes" title="Toggle notes">
+              <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-notes" width="16"
+                   height="16"
+                   viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round"
+                   stroke-linejoin="round">
+                <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+                <path d="M5 3m0 2a2 2 0 0 1 2 -2h10a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2z"></path>
+                <path d="M9 7l6 0"></path>
+                <path d="M9 11l6 0"></path>
+                <path d="M9 15l4 0"></path>
+              </svg>
+              <span>Notes</span>
+            </button>
+          {% endif %}
         </div>
       </li>
     {% endfor %}
   </ul>
 
   <div class="bookmark-pagination">
-    {% pagination bookmarks %}
+    {% pagination bookmark_list.bookmarks_page %}
   </div>
-{% endhtmlmin %}
+{% endif %}

bookmarks/templates/bookmarks/bulk_edit/bar.html

@@ -1,34 +1,34 @@
 {% load shared %}
 {% htmlmin %}
-<div class="bulk-edit-bar">
-  <div class="bulk-edit-actions bg-gray">
-    <label class="form-checkbox bulk-edit-all-toggle">
-      <input type="checkbox" style="display: none">
-      <i class="form-icon"></i>
-    </label>
-    {% if mode == 'archive' %}
-      <button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm btn-confirmation"
-              title="Unarchive selected bookmarks">Unarchive
+  <div class="bulk-edit-bar">
+    <div class="bulk-edit-actions bg-gray">
+      <label ld-bulk-edit-checkbox all class="form-checkbox">
+        <input type="checkbox" style="display: none">
+        <i class="form-icon"></i>
+      </label>
+      {% if mode == 'archive' %}
+        <button ld-confirm-button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm"
+                title="Unarchive selected bookmarks">Unarchive
+        </button>
+      {% else %}
+        <button ld-confirm-button type="submit" name="bulk_archive" class="btn btn-link btn-sm"
+                title="Archive selected bookmarks">Archive
+        </button>
+      {% endif %}
+      <span class="text-sm text-gray-dark">•</span>
+      <button ld-confirm-button type="submit" name="bulk_delete" class="btn btn-link btn-sm"
+              title="Delete selected bookmarks">Delete
       </button>
-    {% else %}
-      <button type="submit" name="bulk_archive" class="btn btn-link btn-sm btn-confirmation"
-              title="Archive selected bookmarks">Archive
+      <span class="text-sm text-gray-dark">•</span>
+      <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
+      <input ld-tag-autocomplete variant="small"
+             name="bulk_tag_string" class="form-input input-sm" placeholder="&nbsp;">
+      <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
+              title="Add tags to selected bookmarks">Add
       </button>
-    {% endif %}
-    <span class="text-sm text-gray-dark">•</span>
-    <button type="submit" name="bulk_delete" class="btn btn-link btn-sm btn-confirmation"
-            title="Delete selected bookmarks">Delete
-    </button>
-    <span class="text-sm text-gray-dark">•</span>
-    <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
-    <input id="bulk-edit-tags-input" name="bulk_tag_string" class="form-input input-sm"
-           placeholder="&nbsp;">
-    <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
-            title="Add tags to selected bookmarks">Add
-    </button>
-    <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
-            title="Remove tags from selected bookmarks">Remove
-    </button>
+      <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
+              title="Remove tags from selected bookmarks">Remove
+      </button>
+    </div>
   </div>
-</div>
 {% endhtmlmin %}

bookmarks/templates/bookmarks/bulk_edit/state.html

@@ -1 +0,0 @@
-<input id="bulk-edit-mode" type="checkbox">

bookmarks/templates/bookmarks/bulk_edit/toggle.html

@@ -1,9 +1,7 @@
-<label for="bulk-edit-mode" class="hide-sm">
-    <span class="btn" title="Bulk edit">
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
-             height="20px">
-            <path
-                d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
-        </svg>
-    </span>
-</label>
+<button ld-bulk-edit-active-toggle class="btn hide-sm ml-2" title="Bulk edit">
+  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
+       height="20px">
+    <path
+        d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
+  </svg>
+</button>

bookmarks/templates/bookmarks/form.html

@@ -21,7 +21,7 @@
   </div>
   <div class="form-group">
     <label for="{{ form.tag_string.id_for_label }}" class="form-label">Tags</label>
-    {{ form.tag_string|add_class:"form-input"|attr:"autocomplete:off" }}
+    {{ form.tag_string|add_class:"form-input"|attr:"ld-tag-autocomplete"|attr:"autocomplete:off"|attr:"autocapitalize:off" }}
     <div class="form-input-hint">
       Enter any number of tags separated by space and <strong>without</strong> the hash (#). If a tag does not
       exist it will be
@@ -67,6 +67,19 @@
     </div>
     {{ form.description.errors }}
   </div>
+  <div class="form-group">
+    <details class="notes"{% if form.has_notes %} open{% endif %}>
+      <summary>
+        <span class="form-label d-inline-block">Notes</span>
+      </summary>
+      <label for="{{ form.notes.id_for_label }}" class="text-assistive">Notes</label>
+      {{ form.notes|add_class:"form-input"|attr:"rows:8" }}
+      <div class="form-input-hint">
+        Additional notes, supports Markdown.
+      </div>
+      {{ form.notes.errors }}
+    </details>
+  </div>
   <div class="form-group">
     <label for="{{ form.unread.id_for_label }}" class="form-checkbox">
       {{ form.unread }}
@@ -77,7 +90,7 @@
       Unread bookmarks can be filtered for, and marked as read after you had a chance to look at them.
     </div>
   </div>
-  {% if request.user.profile.enable_sharing %}
+  {% if request.user_profile.enable_sharing %}
     <div class="form-group">
       <label for="{{ form.shared.id_for_label }}" class="form-checkbox">
         {{ form.shared }}
@@ -85,7 +98,11 @@
         <span>Share</span>
       </label>
       <div class="form-input-hint">
-        Share this bookmark with other users.
+        {% if request.user_profile.enable_public_sharing %}
+          Share this bookmark with other registered users and anonymous users.
+        {% else %}
+          Share this bookmark with other registered users.
+        {% endif %}
       </div>
     </div>
   {% endif %}
@@ -101,23 +118,6 @@
 
   {# Replace tag input with auto-complete component #}
   <script src="{% static "bundle.js" %}"></script>
-  <script type="application/javascript">
-    const wrapper = document.createElement('div');
-    const tagInput = document.getElementById('{{ form.tag_string.id_for_label }}');
-    const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
-
-    new linkding.TagAutoComplete({
-      target: wrapper,
-      props: {
-        id: '{{ form.tag_string.id_for_label }}',
-        name: '{{ form.tag_string.name }}',
-        value: tagInput.value,
-        apiClient: apiClient
-      }
-    });
-
-    tagInput.parentElement.replaceChild(wrapper, tagInput);
-  </script>
   <script type="application/javascript">
     /**
      * - Pre-fill title and description placeholders with metadata from website as soon as URL changes
@@ -128,6 +128,8 @@
       const urlInput = document.getElementById('{{ form.url.id_for_label }}');
       const titleInput = document.getElementById('{{ form.title.id_for_label }}');
       const descriptionInput = document.getElementById('{{ form.description.id_for_label }}');
+      const notesDetails = document.querySelector('form details.notes');
+      const notesInput = document.getElementById('{{ form.notes.id_for_label }}');
       const tagsInput = document.getElementById('{{ form.tag_string.id_for_label }}');
       const unreadCheckbox = document.getElementById('{{ form.unread.id_for_label }}');
       const sharedCheckbox = document.getElementById('{{ form.shared.id_for_label }}');
@@ -149,11 +151,17 @@
       }
 
       function updateInput(input, value) {
-          input.value = value;
+        if (!input) {
+          return;
+        }
+        input.value = value;
       }
 
       function updateCheckbox(input, value) {
-          input.checked = value;
+        if (!input) {
+          return;
+        }
+        input.checked = value;
       }
 
       function checkUrl() {
@@ -179,8 +187,10 @@
 
             if (existingBookmark && !editedBookmarkId) {
               bookmarkExistsHint.style['display'] = 'block';
+              notesDetails.open = !!existingBookmark.notes;
               updateInput(titleInput, existingBookmark.title);
               updateInput(descriptionInput, existingBookmark.description);
+              updateInput(notesInput, existingBookmark.notes);
               updateInput(tagsInput, existingBookmark.tag_names.join(" "));
               updateCheckbox(unreadCheckbox, existingBookmark.unread);
               updateCheckbox(sharedCheckbox, existingBookmark.shared);
@@ -201,6 +211,9 @@
         });
       }
 
+      setupEditAutoValueButton(titleInput);
+      setupEditAutoValueButton(descriptionInput);
+
       // Fetch initial website data if we have a URL, and we are not editing an existing bookmark
       // For existing bookmarks we get the website metadata through hidden inputs
       if (urlInput.value && !editedBookmarkId) {
@@ -213,9 +226,6 @@
         updatePlaceholder(titleInput, websiteTitleInput.value);
         updatePlaceholder(descriptionInput, websiteDescriptionInput.value);
       }
-
-      setupEditAutoValueButton(titleInput);
-      setupEditAutoValueButton(descriptionInput);
     })();
   </script>
 </div>

bookmarks/templates/bookmarks/index.html

@@ -4,43 +4,42 @@
 {% load bookmarks %}
 
 {% block content %}
-
-  {% include 'bookmarks/bulk_edit/state.html' %}
-
-  <div class="bookmarks-page columns">
+  <div class="bookmarks-page columns"
+       ld-bulk-edit
+       ld-bookmark-page
+       bookmarks-url="{% url 'bookmarks:partials.bookmark_list.active' %}"
+       tags-url="{% url 'bookmarks:partials.tag_cloud.active' %}">
 
     {# Bookmark list #}
     <section class="content-area column col-8 col-md-12">
       <div class="content-area-header">
         <h2>Bookmarks</h2>
         <div class="spacer"></div>
-        {% bookmark_search filters tags %}
+        {% bookmark_search bookmark_list.filters tag_cloud.tags %}
         {% include 'bookmarks/bulk_edit/toggle.html' %}
       </div>
 
-      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
+      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ bookmark_list.return_url }}"
             method="post">
         {% csrf_token %}
         {% include 'bookmarks/bulk_edit/bar.html' with mode='default' %}
 
-        {% if empty %}
-          {% include 'bookmarks/empty_bookmarks.html' %}
-        {% else %}
-          {% bookmark_list bookmarks return_url link_target %}
-        {% endif %}
+        <div class="bookmark-list-container">
+          {% include 'bookmarks/bookmark_list.html' %}
+        </div>
       </form>
     </section>
 
-    {# Tag list #}
+    {# Tag cloud #}
     <section class="content-area column col-4 hide-md">
       <div class="content-area-header">
         <h2>Tags</h2>
       </div>
-      {% tag_cloud tags selected_tags %}
+      <div class="tag-cloud-container">
+        {% include 'bookmarks/tag_cloud.html' %}
+      </div>
     </section>
   </div>
 
   <script src="{% static "bundle.js" %}"></script>
-  <script src="{% static "shared.js" %}"></script>
-  <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/layout.html

@@ -8,6 +8,8 @@
   <meta charset="UTF-8">
   <link rel="icon" href="{% static 'favicon.png' %}"/>
   <link rel="apple-touch-icon" href="{% static 'apple-touch-icon.png' %}">
+  <link rel="manifest" href="{% url 'bookmarks:manifest' %}">
+  <meta name="apple-mobile-web-app-capable" content="yes">
   <meta name="viewport" content="width=device-width, initial-scale=1.0, minimal-ui">
   <meta name="description" content="Self-hosted bookmark service">
   <meta name="robots" content="index,follow">
@@ -15,9 +17,9 @@
   <title>linkding</title>
   {# Include SASS styles, files are resolved from bookmarks/styles #}
   {# Include specific theme variant based on user profile setting #}
-  {% if request.user.profile.theme == 'light' %}
+  {% if request.user_profile.theme == 'light' %}
     <link href="{% sass_src 'theme-light.scss' %}" rel="stylesheet" type="text/css"/>
-  {% elif request.user.profile.theme == 'dark' %}
+  {% elif request.user_profile.theme == 'dark' %}
     <link href="{% sass_src 'theme-dark.scss' %}" rel="stylesheet" type="text/css"/>
   {% else %}
     {# Use auto theme as fallback #}
@@ -27,7 +29,7 @@
           media="(prefers-color-scheme: light)"/>
   {% endif %}
 </head>
-<body>
+<body ld-global-shortcuts>
 <header>
   {% if has_toasts %}
     <div class="toasts container grid-lg">
@@ -49,11 +51,16 @@
         <h1>linkding</h1>
       </a>
     </section>
-    {# Only show nav items menu when logged in #}
     {% if request.user.is_authenticated %}
+      {# Only show nav items menu when logged in #}
       <section class="navbar-section">
         {% include 'bookmarks/nav_menu.html' %}
       </section>
+    {% elif has_public_shares %}
+      {# Otherwise show link to shared bookmarks if there are publicly shared bookmarks #}
+      <section class="navbar-section">
+        <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared bookmarks</a>
+      </section>
     {% endif %}
   </div>
 </header>

bookmarks/templates/bookmarks/nav_menu.html

@@ -20,7 +20,7 @@
       <li>
         <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
       </li>
-      {% if request.user.profile.enable_sharing %}
+      {% if request.user_profile.enable_sharing %}
         <li>
           <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
         </li>
@@ -59,7 +59,7 @@
       <li style="padding-left: 1rem">
         <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
       </li>
-      {% if request.user.profile.enable_sharing %}
+      {% if request.user_profile.enable_sharing %}
         <li style="padding-left: 1rem">
           <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
         </li>

bookmarks/templates/bookmarks/shared.html

@@ -4,26 +4,26 @@
 {% load bookmarks %}
 
 {% block content %}
-
-  <div class="bookmarks-page columns">
+  <div class="bookmarks-page columns"
+       ld-bookmark-page
+       bookmarks-url="{% url 'bookmarks:partials.bookmark_list.shared' %}"
+       tags-url="{% url 'bookmarks:partials.tag_cloud.shared' %}">
 
     {# Bookmark list #}
     <section class="content-area column col-8 col-md-12">
       <div class="content-area-header">
         <h2>Shared bookmarks</h2>
         <div class="spacer"></div>
-        {% bookmark_search filters tags mode='shared' %}
+        {% bookmark_search bookmark_list.filters tag_cloud.tags mode='shared' %}
       </div>
 
-      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
+      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ bookmark_list.return_url }}"
             method="post">
         {% csrf_token %}
 
-        {% if empty %}
-          {% include 'bookmarks/empty_bookmarks.html' %}
-        {% else %}
-          {% bookmark_list bookmarks return_url link_target %}
-        {% endif %}
+        <div class="bookmark-list-container">
+          {% include 'bookmarks/bookmark_list.html' %}
+        </div>
       </form>
     </section>
 
@@ -39,10 +39,11 @@
       <div class="content-area-header">
         <h2>Tags</h2>
       </div>
-      {% tag_cloud tags selected_tags %}
+      <div class="tag-cloud-container">
+        {% include 'bookmarks/tag_cloud.html' %}
+      </div>
     </section>
   </div>
 
   <script src="{% static "bundle.js" %}"></script>
-  <script src="{% static "shared.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/tag_cloud.html

@@ -1,10 +1,10 @@
 {% load shared %}
 {% htmlmin %}
   <div class="tag-cloud">
-    {% if has_selected_tags %}
+    {% if tag_cloud.has_selected_tags %}
       <p class="selected-tags">
-        {% for tag in selected_tags %}
-          <a href="?{% remove_from_query_param q=tag.name|hash_tag %}"
+        {% for tag in tag_cloud.selected_tags %}
+          <a href="?{% remove_tag_from_query tag.name %}"
              class="text-bold mr-2">
             <span>-{{ tag.name }}</span>
           </a>
@@ -12,19 +12,19 @@
       </p>
     {% endif %}
     <div class="unselected-tags">
-      {% for group in groups %}
+      {% for group in tag_cloud.groups %}
         <p class="group">
           {% for tag in group.tags %}
             {# Highlight first char of first tag in group #}
             {% if forloop.counter == 1 %}
-              <a href="?{% append_to_query_param q=tag.name|hash_tag %}"
+              <a href="?{% add_tag_to_query tag.name %}"
                  class="mr-2" data-is-tag-item>
                 <span
                     class="highlight-char">{{ tag.name|first_char }}</span><span>{{ tag.name|remaining_chars:1 }}</span>
               </a>
             {% else %}
               {# Render remaining tags normally #}
-              <a href="?{% append_to_query_param q=tag.name|hash_tag %}"
+              <a href="?{% add_tag_to_query tag.name %}"
                  class="mr-2" data-is-tag-item>
                 <span>{{ tag.name }}</span>
               </a>

bookmarks/templates/settings/general.html

@@ -29,6 +29,25 @@
             be hidden.
           </div>
         </div>
+        <div class="form-group">
+          <label for="{{ form.display_url.id_for_label }}" class="form-checkbox">
+            {{ form.display_url }}
+            <i class="form-icon"></i> Show bookmark URL
+          </label>
+          <div class="form-input-hint">
+            When enabled, this setting displays the bookmark URL below the title.
+          </div>
+        </div>
+        <div class="form-group">
+          <label for="{{ form.permanent_notes.id_for_label }}" class="form-checkbox">
+            {{ form.permanent_notes }}
+            <i class="form-icon"></i> Show notes permanently
+          </label>
+          <div class="form-input-hint">
+            Whether to show bookmark notes permanently, without having to toggle them individually.
+            Alternatively the keyboard shortcut <code>e</code> can be used to temporarily show all notes.
+          </div>
+        </div>
         <div class="form-group">
           <label for="{{ form.bookmark_link_target.id_for_label }}" class="form-label">Open bookmarks in</label>
           {{ form.bookmark_link_target|add_class:"form-select col-2 col-sm-12" }}
@@ -36,6 +55,16 @@
             Whether to open bookmarks a new page or in the same page.
           </div>
         </div>
+        <div class="form-group">
+          <label for="{{ form.tag_search.id_for_label }}" class="form-label">Tag search</label>
+          {{ form.tag_search|add_class:"form-select col-2 col-sm-12" }}
+          <div class="form-input-hint">
+            In strict mode, tags must be prefixed with a hash character (#).
+            In lax mode, tags can also be searched without the hash character.
+            Note that tags without the hash character are indistinguishable from search terms, which means the search
+            result will also include bookmarks where a search term matches otherwise.
+          </div>
+        </div>
         <div class="form-group">
           <label for="{{ form.enable_favicons.id_for_label }}" class="form-checkbox">
             {{ form.enable_favicons }}
@@ -45,11 +74,11 @@
             Automatically loads favicons for bookmarked websites and displays them next to each bookmark.
             By default, this feature uses a <b>Google service</b> to download favicons.
             If you don't want to use this service, check the <a
-              href="https://github.com/sissbruecker/linkding/blob/master/docs/Options.md" target="_blank">options
-            documentation</a> on how to configure a custom favicon provider.
+              href="https://github.com/sissbruecker/linkding/blob/master/docs/Options.md#ld_favicon_provider"
+              target="_blank">options documentation</a> on how to configure a custom favicon provider.
             Icons are downloaded in the background, and it may take a while for them to show up.
           </div>
-          {% if request.user.profile.enable_favicons and enable_refresh_favicons %}
+          {% if request.user_profile.enable_favicons and enable_refresh_favicons %}
             <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
           {% endif %}
           {% if refresh_favicons_success_message %}
@@ -84,6 +113,17 @@
             Disabling this feature will hide all previously shared bookmarks from other users.
           </div>
         </div>
+        <div class="form-group">
+          <label for="{{ form.enable_public_sharing.id_for_label }}" class="form-checkbox">
+            {{ form.enable_public_sharing }}
+            <i class="form-icon"></i> Enable public bookmark sharing
+          </label>
+          <div class="form-input-hint">
+            Makes shared bookmarks publicly accessible, without requiring a login.
+            That means that anyone with a link to this instance can view shared bookmarks via the <a
+              href="{% url 'bookmarks:shared' %}">shared bookmarks page</a>.
+          </div>
+        </div>
         <div class="form-group">
           <input type="submit" name="update_profile" value="Save" class="btn btn-primary mt-2">
           {% if update_profile_success_message %}
@@ -104,6 +144,16 @@
         added and existing ones are updated.</p>
       <form method="post" enctype="multipart/form-data" action="{% url 'bookmarks:settings.import' %}">
         {% csrf_token %}
+        <div class="form-group">
+          <label for="import_map_private_flag" class="form-checkbox">
+            <input type="checkbox" id="import_map_private_flag" name="map_private_flag">
+            <i class="form-icon"></i> Import public bookmarks as shared
+          </label>
+          <div class="form-input-hint">
+            When importing bookmarks from a service that supports marking bookmarks as public or private (using the <code>PRIVATE</code> attribute), enabling this option will import all bookmarks that are marked as not private as shared bookmarks.
+            Otherwise, all bookmarks will be imported as private bookmarks.
+          </div>
+        </div>
         <div class="form-group">
           <div class="input-group col-8 col-md-12">
             <input class="form-input" type="file" name="import_file">
@@ -131,6 +181,10 @@
     <section class="content-area">
       <h2>Export</h2>
       <p>Export all bookmarks in Netscape HTML format.</p>
+      <p>
+        Note that exporting bookmark notes is currently not supported due to limitations of the format.
+        For proper backups please use a database backup as described in the documentation.
+      </p>
       <a class="btn btn-primary" href="{% url 'bookmarks:settings.export' %}">Download (.html)</a>
       {% if export_error %}
         <div class="has-error">
@@ -168,4 +222,22 @@
     </section>
   </div>
 
+  <script>
+    // Automatically disable public bookmark sharing if bookmark sharing is disabled
+    const enableSharing = document.getElementById("{{ form.enable_sharing.id_for_label }}");
+    const enablePublicSharing = document.getElementById("{{ form.enable_public_sharing.id_for_label }}");
+
+    function updatePublicSharing() {
+      if (enableSharing.checked) {
+        enablePublicSharing.disabled = false;
+      } else {
+        enablePublicSharing.disabled = true;
+        enablePublicSharing.checked = false;
+      }
+    }
+
+    updatePublicSharing();
+    enableSharing.addEventListener("change", updatePublicSharing);
+  </script>
+
 {% endblock %}

bookmarks/templatetags/bookmarks.py

@@ -1,10 +1,8 @@
-from typing import List, Set
+from typing import List
 
 from django import template
-from django.core.paginator import Page
 
 from bookmarks.models import BookmarkForm, BookmarkFilters, Tag, build_tag_string, User
-from bookmarks.utils import unique
 
 register = template.Library()
 
@@ -20,60 +18,6 @@ def bookmark_form(context, form: BookmarkForm, cancel_url: str, bookmark_id: int
     }
 
 
-class TagGroup:
-    def __init__(self, char):
-        self.tags = []
-        self.char = char
-
-
-def create_tag_groups(tags: Set[Tag]):
-    # Ensure groups, as well as tags within groups, are ordered alphabetically
-    sorted_tags = sorted(tags, key=lambda x: str.lower(x.name))
-    group = None
-    groups = []
-
-    # Group tags that start with a different character than the previous one
-    for tag in sorted_tags:
-        tag_char = tag.name[0].lower()
-
-        if not group or group.char != tag_char:
-            group = TagGroup(tag_char)
-            groups.append(group)
-
-        group.tags.append(tag)
-
-    return groups
-
-
-@register.inclusion_tag('bookmarks/tag_cloud.html', name='tag_cloud', takes_context=True)
-def tag_cloud(context, tags: List[Tag], selected_tags: List[Tag]):
-    # Only display each tag name once, ignoring casing
-    # This covers cases where the tag cloud contains shared tags with duplicate names
-    # Also means that the cloud can not make assumptions that it will necessarily contain
-    # all tags of the current user
-    unique_tags = unique(tags, key=lambda x: str.lower(x.name))
-    unique_selected_tags = unique(selected_tags, key=lambda x: str.lower(x.name))
-
-    has_selected_tags = len(unique_selected_tags) > 0
-    unselected_tags = set(unique_tags).symmetric_difference(unique_selected_tags)
-    groups = create_tag_groups(unselected_tags)
-    return {
-        'groups': groups,
-        'selected_tags': unique_selected_tags,
-        'has_selected_tags': has_selected_tags,
-    }
-
-
-@register.inclusion_tag('bookmarks/bookmark_list.html', name='bookmark_list', takes_context=True)
-def bookmark_list(context, bookmarks: Page, return_url: str, link_target: str = '_blank'):
-    return {
-        'request': context['request'],
-        'bookmarks': bookmarks,
-        'return_url': return_url,
-        'link_target': link_target,
-    }
-
-
 @register.inclusion_tag('bookmarks/search.html', name='bookmark_search', takes_context=True)
 def bookmark_search(context, filters: BookmarkFilters, tags: [Tag], mode: str = ''):
     tag_names = [tag.name for tag in tags]

bookmarks/templatetags/shared.py

@@ -1,8 +1,13 @@
 import re
 
+import bleach
+import markdown
+from bleach_allowlist import markdown_tags, markdown_attrs
 from django import template
+from django.utils.safestring import mark_safe
 
 from bookmarks import utils
+from bookmarks.models import UserProfile
 
 register = template.Library()
 
@@ -19,36 +24,39 @@ def update_query_string(context, **kwargs):
 
 
 @register.simple_tag(takes_context=True)
-def append_to_query_param(context, **kwargs):
-    query = context.request.GET.copy()
+def add_tag_to_query(context, tag_name: str):
+    params = context.request.GET.copy()
 
-    # Append to or create query param
-    for key in kwargs:
-        if query.__contains__(key):
-            value = query.__getitem__(key) + ' '
-        else:
-            value = ''
-        value = value + kwargs[key]
-        query.__setitem__(key, value)
+    # Append to or create query string
+    if params.__contains__('q'):
+        query_string = params.__getitem__('q') + ' '
+    else:
+        query_string = ''
+    query_string = query_string + '#' + tag_name
+    params.__setitem__('q', query_string)
 
-    return query.urlencode()
+    return params.urlencode()
 
 
 @register.simple_tag(takes_context=True)
-def remove_from_query_param(context, **kwargs):
-    query = context.request.GET.copy()
+def remove_tag_from_query(context, tag_name: str):
+    params = context.request.GET.copy()
+    if params.__contains__('q'):
+        # Split query string into parts
+        query_string = params.__getitem__('q')
+        query_parts = query_string.split()
+        # Remove tag with hash
+        tag_name_with_hash = '#' + tag_name
+        query_parts = [part for part in query_parts if str.lower(part) != str.lower(tag_name_with_hash)]
+        # When using lax tag search, also remove tag without hash
+        profile = context.request.user_profile
+        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
+            query_parts = [part for part in query_parts if str.lower(part) != str.lower(tag_name)]
+        # Rebuild query string
+        query_string = ' '.join(query_parts)
+        params.__setitem__('q', query_string)
 
-    # Remove item from query param
-    for key in kwargs:
-        if query.__contains__(key):
-            value = query.__getitem__(key)
-            parts = value.split()
-            part_to_remove = kwargs[key]
-            updated_parts = [part for part in parts if str.lower(part) != str.lower(part_to_remove)]
-            updated_value = ' '.join(updated_parts)
-            query.__setitem__(key, updated_value)
-
-    return query.urlencode()
+    return params.urlencode()
 
 
 @register.simple_tag(takes_context=True)
@@ -109,3 +117,19 @@ class HtmlMinNode(template.Node):
         output = re.sub(r'\s+', ' ', output)
 
         return output
+
+
+@register.simple_tag(name="markdown", takes_context=True)
+def render_markdown(context, markdown_text):
+    # naive approach to reusing the renderer for a single request
+    # works for bookmark list for now
+    if not ('markdown_renderer' in context):
+        renderer = markdown.Markdown(extensions=['fenced_code', 'nl2br'])
+        context['markdown_renderer'] = renderer
+    else:
+        renderer = context['markdown_renderer']
+
+    as_html = renderer.convert(markdown_text)
+    sanitized_html = bleach.clean(as_html, markdown_tags, markdown_attrs)
+
+    return mark_safe(sanitized_html)

bookmarks/tests/helpers.py

@@ -1,5 +1,6 @@
 import random
 import logging
+import datetime
 from typing import List
 
 from bs4 import BeautifulSoup
@@ -30,10 +31,12 @@ class BookmarkFactoryMixin:
                        url: str = '',
                        title: str = '',
                        description: str = '',
+                       notes: str = '',
                        website_title: str = '',
                        website_description: str = '',
                        web_archive_snapshot_url: str = '',
                        favicon_file: str = '',
+                       added: datetime = None,
                        ):
         if not title:
             title = get_random_string(length=32)
@@ -44,13 +47,16 @@ class BookmarkFactoryMixin:
         if not url:
             unique_id = get_random_string(length=32)
             url = 'https://example.com/' + unique_id
+        if added is None:
+            added = timezone.now()
         bookmark = Bookmark(
             url=url,
             title=title,
             description=description,
+            notes=notes,
             website_title=website_title,
             website_description=website_description,
-            date_added=timezone.now(),
+            date_added=added,
             date_modified=timezone.now(),
             owner=user,
             is_archived=is_archived,
@@ -65,6 +71,44 @@ class BookmarkFactoryMixin:
         bookmark.save()
         return bookmark
 
+    def setup_numbered_bookmarks(self,
+                                 count: int,
+                                 prefix: str = '',
+                                 suffix: str = '',
+                                 tag_prefix: str = '',
+                                 archived: bool = False,
+                                 shared: bool = False,
+                                 with_tags: bool = False,
+                                 user: User = None):
+        user = user or self.get_or_create_test_user()
+
+        if not prefix:
+            if archived:
+                prefix = 'Archived Bookmark'
+            elif shared:
+                prefix = 'Shared Bookmark'
+            else:
+                prefix = 'Bookmark'
+
+        if not tag_prefix:
+            if archived:
+                tag_prefix = 'Archived Tag'
+            elif shared:
+                tag_prefix = 'Shared Tag'
+            else:
+                tag_prefix = 'Tag'
+
+        for i in range(1, count + 1):
+            title = f'{prefix} {i}{suffix}'
+            tags = []
+            if with_tags:
+                tag_name = f'{tag_prefix} {i}{suffix}'
+                tags = [self.setup_tag(name=tag_name)]
+            self.setup_bookmark(title=title, is_archived=archived, shared=shared, tags=tags, user=user)
+
+    def get_numbered_bookmark(self, title: str):
+        return Bookmark.objects.get(title=title)
+
     def setup_tag(self, user: User = None, name: str = ''):
         if user is None:
             user = self.get_or_create_test_user()
@@ -74,11 +118,12 @@ class BookmarkFactoryMixin:
         tag.save()
         return tag
 
-    def setup_user(self, name: str = None, enable_sharing: bool = False):
+    def setup_user(self, name: str = None, enable_sharing: bool = False, enable_public_sharing: bool = False):
         if not name:
             name = get_random_string(length=32)
         user = User.objects.create_user(name, 'user@example.com', 'password123')
         user.profile.enable_sharing = enable_sharing
+        user.profile.enable_public_sharing = enable_public_sharing
         user.profile.save()
         return user
 
@@ -122,13 +167,15 @@ class BookmarkHtmlTag:
                  description: str = '',
                  add_date: str = '',
                  tags: str = '',
-                 to_read: bool = False):
+                 to_read: bool = False,
+                 private: bool = True):
         self.href = href
         self.title = title
         self.description = description
         self.add_date = add_date
         self.tags = tags
         self.to_read = to_read
+        self.private = private
 
 
 class ImportTestMixin:
@@ -138,7 +185,8 @@ class ImportTestMixin:
         <A {f'HREF="{tag.href}"' if tag.href else ''}
            {f'ADD_DATE="{tag.add_date}"' if tag.add_date else ''}
            {f'TAGS="{tag.tags}"' if tag.tags else ''}
-           TOREAD="{1 if tag.to_read else 0}">
+           TOREAD="{1 if tag.to_read else 0}"
+           PRIVATE="{1 if tag.private else 0}">
            {tag.title if tag.title else ''}
         </A>
         {f'<DD>{tag.description}' if tag.description else ''}

bookmarks/tests/test_anonymous_view.py

@@ -0,0 +1,26 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class AnonymousViewTestCase(TestCase, BookmarkFactoryMixin):
+    def assertSharedBookmarksLinkCount(self, response, count):
+        url = reverse('bookmarks:shared')
+        self.assertContains(response, f'<a href="{url}" class="btn btn-link">Shared bookmarks</a>',
+                            count=count)
+
+    def test_publicly_shared_bookmarks_link(self):
+        # should not render link if no public shares exist
+        user = self.setup_user(enable_sharing=True)
+        self.setup_bookmark(user=user, shared=True)
+
+        response = self.client.get(reverse('login'))
+        self.assertSharedBookmarksLinkCount(response, 0)
+
+        # should render link if public shares exist
+        user.profile.enable_public_sharing = True
+        user.profile.save()
+
+        response = self.client.get(reverse('login'))
+        self.assertSharedBookmarksLinkCount(response, 1)

bookmarks/tests/test_bookmark_archived_view.py

@@ -16,7 +16,7 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin
 
     def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
-        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+        self.assertContains(response, '<li ld-bookmark-item>', count=len(bookmarks))
 
         for bookmark in bookmarks:
             self.assertInHTML(
@@ -158,6 +158,37 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin
 
         self.assertSelectedTags(response, [tags[0], tags[1]])
 
+    def test_should_not_display_search_terms_from_query_as_selected_tags_in_strict_mode(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(title=tags[0].name, tags=tags, is_archived=True)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[1]])
+
+    def test_should_display_search_terms_from_query_as_selected_tags_in_lax_mode(self):
+        self.user.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.user.profile.save()
+
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags, is_archived=True)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
     def test_should_open_bookmarks_in_new_page_by_default(self):
         visible_bookmarks = [
             self.setup_bookmark(is_archived=True),

bookmarks/tests/test_bookmark_archived_view_performance.py

@@ -27,7 +27,7 @@ class BookmarkArchivedViewPerformanceTestCase(TransactionTestCase, BookmarkFacto
         context = CaptureQueriesContext(self.get_connection())
         with context:
             response = self.client.get(reverse('bookmarks:archived'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks)
 
         number_of_queries = context.final_queries
 
@@ -39,4 +39,4 @@ class BookmarkArchivedViewPerformanceTestCase(TransactionTestCase, BookmarkFacto
         # assert num queries doesn't increase
         with self.assertNumQueries(number_of_queries):
             response = self.client.get(reverse('bookmarks:archived'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmark_edit_view.py

@@ -20,6 +20,7 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
             'tag_string': 'editedtag1 editedtag2',
             'title': 'edited title',
             'description': 'edited description',
+            'notes': 'edited notes',
             'unread': False,
             'shared': False,
         }
@@ -37,6 +38,7 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, form_data['url'])
         self.assertEqual(bookmark.title, form_data['title'])
         self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.notes, form_data['notes'])
         self.assertEqual(bookmark.unread, form_data['unread'])
         self.assertEqual(bookmark.shared, form_data['shared'])
         self.assertEqual(bookmark.tags.count(), 2)
@@ -74,7 +76,8 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
         tag1 = self.setup_tag()
         tag2 = self.setup_tag()
         bookmark = self.setup_bookmark(tags=[tag1, tag2], title='edited title', description='edited description',
-                                       website_title='website title', website_description='website description')
+                                       notes='edited notes', website_title='website title',
+                                       website_description='website description')
 
         response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
         html = response.content.decode()
@@ -86,8 +89,8 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
 
         tag_string = build_tag_string(bookmark.tag_names, ' ')
         self.assertInHTML(f'''
-            <input type="text" name="tag_string" value="{tag_string}" 
-                    autocomplete="off" class="form-input" id="id_tag_string">
+            <input ld-tag-autocomplete type="text" name="tag_string" value="{tag_string}" 
+                    autocomplete="off" autocapitalize="off" class="form-input" id="id_tag_string">
         ''', html)
 
         self.assertInHTML(f'''
@@ -101,6 +104,12 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
             </textarea>
         ''', html)
 
+        self.assertInHTML(f'''
+            <textarea name="notes" cols="40" rows="8" class="form-input" id="id_notes">
+                {bookmark.notes}
+            </textarea>
+        ''', html)
+
         self.assertInHTML(f'''
             <input type="hidden" name="website_title"  id="id_website_title"
                     value="{bookmark.website_title}">
@@ -184,3 +193,15 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
               <span>Share</span>
             </label>            
         ''', html, count=1)
+
+    def test_should_hide_notes_if_there_are_no_notes(self):
+        bookmark = self.setup_bookmark()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+        self.assertContains(response, '<details class="notes">', count=1)
+
+    def test_should_show_notes_if_there_are_notes(self):
+        bookmark = self.setup_bookmark(notes='test notes')
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+        self.assertContains(response, '<details class="notes" open>', count=1)

bookmarks/tests/test_bookmark_index_view.py

@@ -17,7 +17,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
-        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+        self.assertContains(response, '<li ld-bookmark-item>', count=len(bookmarks))
 
         for bookmark in bookmarks:
             self.assertInHTML(
@@ -155,7 +155,38 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         ]
         self.setup_bookmark(tags=tags)
 
-        response = self.client.get(reverse('bookmarks:index') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+        response = self.client.get(reverse('bookmarks:index') + f'?q=%23{tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
+    def test_should_not_display_search_terms_from_query_as_selected_tags_in_strict_mode(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(title=tags[0].name, tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[1]])
+
+    def test_should_display_search_terms_from_query_as_selected_tags_in_lax_mode(self):
+        self.user.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.user.profile.save()
+
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
 
         self.assertSelectedTags(response, [tags[0], tags[1]])
 
@@ -196,8 +227,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         return_url = urllib.parse.quote_plus(url)
 
         self.assertInHTML(f'''
-            <a href="{edit_url}?return_url={return_url}"
-               class="btn btn-link btn-sm">Edit</a>        
+            <a href="{edit_url}?return_url={return_url}">Edit</a>        
         ''', html)
 
         # with query params
@@ -208,6 +238,5 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
         return_url = urllib.parse.quote_plus(url)
 
         self.assertInHTML(f'''
-            <a href="{edit_url}?return_url={return_url}"
-               class="btn btn-link btn-sm">Edit</a>        
+            <a href="{edit_url}?return_url={return_url}">Edit</a>        
         ''', html)

bookmarks/tests/test_bookmark_index_view_performance.py

@@ -27,7 +27,7 @@ class BookmarkIndexViewPerformanceTestCase(TransactionTestCase, BookmarkFactoryM
         context = CaptureQueriesContext(self.get_connection())
         with context:
             response = self.client.get(reverse('bookmarks:index'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks)
 
         number_of_queries = context.final_queries
 
@@ -39,4 +39,4 @@ class BookmarkIndexViewPerformanceTestCase(TransactionTestCase, BookmarkFactoryM
         # assert num queries doesn't increase
         with self.assertNumQueries(number_of_queries):
             response = self.client.get(reverse('bookmarks:index'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmark_new_view.py

@@ -19,6 +19,7 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
             'tag_string': 'tag1 tag2',
             'title': 'test title',
             'description': 'test description',
+            'notes': 'test notes',
             'unread': False,
             'shared': False,
             'auto_close': '',
@@ -37,6 +38,7 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, form_data['url'])
         self.assertEqual(bookmark.title, form_data['title'])
         self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.notes, form_data['notes'])
         self.assertEqual(bookmark.unread, form_data['unread'])
         self.assertEqual(bookmark.shared, form_data['shared'])
         self.assertEqual(bookmark.tags.count(), 2)
@@ -74,6 +76,25 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
             'id="id_url">',
             html)
 
+    def test_should_prefill_title_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?title=Example%20Title')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="text" name="title" value="Example Title" '
+            'class="form-input" maxlength="512" autocomplete="off" '
+            'id="id_title">',
+            html)
+
+    def test_should_prefill_description_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?description=Example%20Site%20Description')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<textarea name="description" class="form-input" cols="40" '
+            'rows="2" id="id_description">Example Site Description</textarea>',
+            html)
+
     def test_should_enable_auto_close_when_specified_in_url_parameter(self):
         response = self.client.get(
             reverse('bookmarks:new') + '?auto_close')
@@ -138,3 +159,33 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
               <span>Share</span>
             </label>            
         ''', html, count=1)
+
+    def test_should_show_respective_share_hint(self):
+        self.user.profile.enable_sharing = True
+        self.user.profile.save()
+
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+        self.assertInHTML('''
+          <div class="form-input-hint">
+              Share this bookmark with other registered users.
+          </div>
+        ''', html)
+
+        self.user.profile.enable_public_sharing = True
+        self.user.profile.save()
+
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+        self.assertInHTML('''
+          <div class="form-input-hint">
+              Share this bookmark with other registered users and anonymous users.
+          </div>
+        ''', html)
+
+
+def test_should_hide_notes_if_there_are_no_notes(self):
+    bookmark = self.setup_bookmark()
+    response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+    self.assertContains(response, '<details class="notes">', count=1)

bookmarks/tests/test_bookmark_search_tag.py

@@ -10,6 +10,8 @@ class BookmarkSearchTagTest(TestCase, BookmarkFactoryMixin):
     def render_template(self, url: str, tags: QuerySet[Tag] = Tag.objects.all()):
         rf = RequestFactory()
         request = rf.get(url)
+        request.user = self.get_or_create_test_user()
+        request.user_profile = self.get_or_create_test_user().profile
         filters = BookmarkFilters(request)
         context = RequestContext(request, {
             'request': request,

bookmarks/tests/test_bookmark_shared_view.py

@@ -10,7 +10,7 @@ from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
 
-    def setUp(self) -> None:
+    def authenticate(self) -> None:
         user = self.get_or_create_test_user()
         self.client.force_login(user)
 
@@ -22,7 +22,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
 
     def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
-        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+        self.assertContains(response, '<li ld-bookmark-item>', count=len(bookmarks))
 
         for bookmark in bookmarks:
             self.assertBookmarkCount(html, bookmark, 1, link_target)
@@ -65,6 +65,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
             ''', html, count=0)
 
     def test_should_list_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+        self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -89,6 +90,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
 
     def test_should_list_shared_bookmarks_from_selected_user(self):
+        self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -108,6 +110,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
 
     def test_should_list_bookmarks_matching_query(self):
+        self.authenticate()
         user = self.setup_user(enable_sharing=True)
         visible_bookmarks = [
             self.setup_bookmark(shared=True, title='searchvalue', user=user),
@@ -126,7 +129,29 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleBookmarks(response, visible_bookmarks)
         self.assertInvisibleBookmarks(response, invisible_bookmarks)
 
+    def test_should_list_only_publicly_shared_bookmarks_without_login(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user1),
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user2),
+        ]
+
+        response = self.client.get(reverse('bookmarks:shared'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
     def test_should_list_tags_for_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+        self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -158,6 +183,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertInvisibleTags(response, invisible_tags)
 
     def test_should_list_tags_for_shared_bookmarks_from_selected_user(self):
+        self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -180,6 +206,7 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertInvisibleTags(response, invisible_tags)
 
     def test_should_list_tags_for_bookmarks_matching_query(self):
+        self.authenticate()
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -207,7 +234,32 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
 
+    def test_should_list_only_tags_for_publicly_shared_bookmarks_without_login(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        visible_tags = [
+            self.setup_tag(user=user1),
+            self.setup_tag(user=user1),
+        ]
+        invisible_tags = [
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user2),
+        ]
+
+        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[0]])
+        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[1]])
+
+        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[0]])
+        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[1]])
+
+        response = self.client.get(reverse('bookmarks:shared'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
     def test_should_list_users_with_shared_bookmarks_if_sharing_is_enabled(self):
+        self.authenticate()
         expected_visible_users = [
             self.setup_user(enable_sharing=True),
             self.setup_user(enable_sharing=True),
@@ -226,30 +278,53 @@ class BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleUserOptions(response, expected_visible_users)
         self.assertInvisibleUserOptions(response, expected_invisible_users)
 
+    def test_should_list_only_users_with_publicly_shared_bookmarks_without_login(self):
+        expected_visible_users = [
+            self.setup_user(enable_sharing=True, enable_public_sharing=True),
+            self.setup_user(enable_sharing=True, enable_public_sharing=True),
+        ]
+        self.setup_bookmark(shared=True, user=expected_visible_users[0])
+        self.setup_bookmark(shared=True, user=expected_visible_users[1])
 
-def test_should_open_bookmarks_in_new_page_by_default(self):
-    visible_bookmarks = [
-        self.setup_bookmark(shared=True),
-        self.setup_bookmark(shared=True),
-        self.setup_bookmark(shared=True)
-    ]
+        expected_invisible_users = [
+            self.setup_user(enable_sharing=True),
+            self.setup_user(enable_sharing=True),
+        ]
+        self.setup_bookmark(shared=True, user=expected_invisible_users[0])
+        self.setup_bookmark(shared=True, user=expected_invisible_users[1])
 
-    response = self.client.get(reverse('bookmarks:shared'))
+        response = self.client.get(reverse('bookmarks:shared'))
+        self.assertVisibleUserOptions(response, expected_visible_users)
+        self.assertInvisibleUserOptions(response, expected_invisible_users)
 
-    self.assertVisibleBookmarks(response, visible_bookmarks, '_blank')
+    def test_should_open_bookmarks_in_new_page_by_default(self):
+        self.authenticate()
+        user = self.get_or_create_test_user()
+        user.profile.enable_sharing = True
+        user.profile.save()
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True),
+            self.setup_bookmark(shared=True),
+            self.setup_bookmark(shared=True)
+        ]
 
+        response = self.client.get(reverse('bookmarks:shared'))
 
-def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
-    user = self.get_or_create_test_user()
-    user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
-    user.profile.save()
+        self.assertVisibleBookmarks(response, visible_bookmarks, '_blank')
 
-    visible_bookmarks = [
-        self.setup_bookmark(shared=True),
-        self.setup_bookmark(shared=True),
-        self.setup_bookmark(shared=True)
-    ]
+    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
+        self.authenticate()
+        user = self.get_or_create_test_user()
+        user.profile.enable_sharing = True
+        user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
+        user.profile.save()
 
-    response = self.client.get(reverse('bookmarks:shared'))
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True),
+            self.setup_bookmark(shared=True),
+            self.setup_bookmark(shared=True)
+        ]
 
-    self.assertVisibleBookmarks(response, visible_bookmarks, '_self')
+        response = self.client.get(reverse('bookmarks:shared'))
+
+        self.assertVisibleBookmarks(response, visible_bookmarks, '_self')

bookmarks/tests/test_bookmark_shared_view_performance.py

@@ -28,7 +28,7 @@ class BookmarkSharedViewPerformanceTestCase(TransactionTestCase, BookmarkFactory
         context = CaptureQueriesContext(self.get_connection())
         with context:
             response = self.client.get(reverse('bookmarks:shared'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks)
 
         number_of_queries = context.final_queries
 
@@ -41,4 +41,4 @@ class BookmarkSharedViewPerformanceTestCase(TransactionTestCase, BookmarkFactory
         # assert num queries doesn't increase
         with self.assertNumQueries(number_of_queries):
             response = self.client.get(reverse('bookmarks:shared'))
-            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)
+            self.assertContains(response, '<li ld-bookmark-item>', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmarks_api.py

@@ -16,16 +16,18 @@ from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
 class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
 
     def setUp(self) -> None:
-        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
-        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
         self.tag1 = self.setup_tag()
         self.tag2 = self.setup_tag()
-        self.bookmark1 = self.setup_bookmark(tags=[self.tag1, self.tag2])
+        self.bookmark1 = self.setup_bookmark(tags=[self.tag1, self.tag2], notes='Test notes')
         self.bookmark2 = self.setup_bookmark()
         self.bookmark3 = self.setup_bookmark(tags=[self.tag2])
         self.archived_bookmark1 = self.setup_bookmark(is_archived=True, tags=[self.tag1, self.tag2])
         self.archived_bookmark2 = self.setup_bookmark(is_archived=True)
 
+    def authenticate(self):
+        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
+
     def assertBookmarkListEqual(self, data_list, bookmarks):
         expectations = []
         for bookmark in bookmarks:
@@ -36,6 +38,7 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
             expectation['url'] = bookmark.url
             expectation['title'] = bookmark.title
             expectation['description'] = bookmark.description
+            expectation['notes'] = bookmark.notes
             expectation['website_title'] = bookmark.website_title
             expectation['website_description'] = bookmark.website_description
             expectation['is_archived'] = bookmark.is_archived
@@ -52,24 +55,34 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertCountEqual(data_list, expectations)
 
     def test_list_bookmarks(self):
+        self.authenticate()
+
         response = self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual(response.data['results'], [self.bookmark1, self.bookmark2, self.bookmark3])
 
     def test_list_bookmarks_should_filter_by_query(self):
+        self.authenticate()
+
         response = self.get(reverse('bookmarks:bookmark-list') + '?q=#' + self.tag1.name,
                             expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual(response.data['results'], [self.bookmark1])
 
     def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
+        self.authenticate()
+
         response = self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1, self.archived_bookmark2])
 
     def test_list_archived_bookmarks_should_filter_by_query(self):
+        self.authenticate()
+
         response = self.get(reverse('bookmarks:bookmark-archived') + '?q=#' + self.tag1.name,
                             expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1])
 
     def test_list_shared_bookmarks(self):
+        self.authenticate()
+
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
         user3 = self.setup_user(enable_sharing=True)
@@ -88,7 +101,23 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         response = self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual(response.data['results'], shared_bookmarks)
 
+    def test_list_only_publicly_shared_bookmarks_when_not_logged_in(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        shared_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user1)
+        ]
+        self.setup_bookmark(shared=True, user=user2)
+        self.setup_bookmark(shared=True, user=user2)
+
+        response = self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], shared_bookmarks)
+
     def test_list_shared_bookmarks_should_filter_by_query_and_user(self):
+        self.authenticate()
+
         # Search by query
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
@@ -130,10 +159,13 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
 
     def test_create_bookmark(self):
+        self.authenticate()
+
         data = {
             'url': 'https://example.com/',
             'title': 'Test title',
             'description': 'Test description',
+            'notes': 'Test notes',
             'is_archived': False,
             'unread': False,
             'shared': False,
@@ -144,6 +176,7 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, data['url'])
         self.assertEqual(bookmark.title, data['title'])
         self.assertEqual(bookmark.description, data['description'])
+        self.assertEqual(bookmark.notes, data['notes'])
         self.assertFalse(bookmark.is_archived, data['is_archived'])
         self.assertFalse(bookmark.unread, data['unread'])
         self.assertFalse(bookmark.shared, data['shared'])
@@ -152,11 +185,14 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
 
     def test_create_bookmark_with_same_url_updates_existing_bookmark(self):
+        self.authenticate()
+
         original_bookmark = self.setup_bookmark()
         data = {
             'url': original_bookmark.url,
             'title': 'Updated title',
             'description': 'Updated description',
+            'notes': 'Updated notes',
             'unread': True,
             'shared': True,
             'is_archived': True,
@@ -168,6 +204,7 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, data['url'])
         self.assertEqual(bookmark.title, data['title'])
         self.assertEqual(bookmark.description, data['description'])
+        self.assertEqual(bookmark.notes, data['notes'])
         # Saving a duplicate bookmark should not modify archive flag - right?
         self.assertFalse(bookmark.is_archived)
         self.assertEqual(bookmark.unread, data['unread'])
@@ -177,6 +214,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
 
     def test_create_bookmark_replaces_whitespace_in_tag_names(self):
+        self.authenticate()
+
         data = {
             'url': 'https://example.com/',
             'title': 'Test title',
@@ -189,10 +228,14 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertListEqual(tag_names, ['tag-1', 'tag-2'])
 
     def test_create_bookmark_minimal_payload(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
 
     def test_create_archived_bookmark(self):
+        self.authenticate()
+
         data = {
             'url': 'https://example.com/',
             'title': 'Test title',
@@ -211,41 +254,55 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
 
     def test_create_bookmark_is_not_archived_by_default(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertFalse(bookmark.is_archived)
 
     def test_create_unread_bookmark(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/', 'unread': True}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertTrue(bookmark.unread)
 
     def test_create_bookmark_is_not_unread_by_default(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertFalse(bookmark.unread)
 
     def test_create_shared_bookmark(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/', 'shared': True}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertTrue(bookmark.shared)
 
     def test_create_bookmark_is_not_shared_by_default(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertFalse(bookmark.shared)
 
     def test_get_bookmark(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         response = self.get(url, expected_status_code=status.HTTP_200_OK)
         self.assertBookmarkListEqual([response.data], [self.bookmark1])
 
     def test_update_bookmark(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.put(url, data, expected_status_code=status.HTTP_200_OK)
@@ -253,11 +310,15 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.url, data['url'])
 
     def test_update_bookmark_fails_without_required_fields(self):
+        self.authenticate()
+
         data = {'title': 'https://example.com/'}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.put(url, data, expected_status_code=status.HTTP_400_BAD_REQUEST)
 
     def test_update_bookmark_with_minimal_payload_clears_all_fields(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/'}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.put(url, data, expected_status_code=status.HTTP_200_OK)
@@ -265,9 +326,12 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.url, data['url'])
         self.assertEqual(updated_bookmark.title, '')
         self.assertEqual(updated_bookmark.description, '')
+        self.assertEqual(updated_bookmark.notes, '')
         self.assertEqual(updated_bookmark.tag_names, [])
 
     def test_update_bookmark_unread_flag(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/', 'unread': True}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.put(url, data, expected_status_code=status.HTTP_200_OK)
@@ -275,6 +339,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.unread, True)
 
     def test_update_bookmark_shared_flag(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com/', 'shared': True}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.put(url, data, expected_status_code=status.HTTP_200_OK)
@@ -282,6 +348,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.shared, True)
 
     def test_patch_bookmark(self):
+        self.authenticate()
+
         data = {'url': 'https://example.com'}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.patch(url, data, expected_status_code=status.HTTP_200_OK)
@@ -300,6 +368,12 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.bookmark1.refresh_from_db()
         self.assertEqual(self.bookmark1.description, data['description'])
 
+        data = {'notes': 'Updated notes'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertEqual(self.bookmark1.notes, data['notes'])
+
         data = {'unread': True}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.patch(url, data, expected_status_code=status.HTTP_200_OK)
@@ -332,6 +406,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertListEqual(tag_names, ['updated-tag-1', 'updated-tag-2'])
 
     def test_patch_with_empty_payload_does_not_modify_bookmark(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.patch(url, {}, expected_status_code=status.HTTP_200_OK)
         updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
@@ -341,23 +417,31 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertListEqual(updated_bookmark.tag_names, self.bookmark1.tag_names)
 
     def test_delete_bookmark(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)
         self.assertEqual(len(Bookmark.objects.filter(id=self.bookmark1.id)), 0)
 
     def test_archive(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-archive', args=[self.bookmark1.id])
         self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
         bookmark = Bookmark.objects.get(id=self.bookmark1.id)
         self.assertTrue(bookmark.is_archived)
 
     def test_unarchive(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-unarchive', args=[self.archived_bookmark1.id])
         self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
         bookmark = Bookmark.objects.get(id=self.archived_bookmark1.id)
         self.assertFalse(bookmark.is_archived)
 
     def test_check_returns_no_bookmark_if_url_is_not_bookmarked(self):
+        self.authenticate()
+
         url = reverse('bookmarks:bookmark-check')
         check_url = urllib.parse.quote_plus('https://example.com')
         response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
@@ -366,6 +450,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertIsNone(bookmark_data)
 
     def test_check_returns_scraped_metadata_if_url_is_not_bookmarked(self):
+        self.authenticate()
+
         with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
             expected_metadata = WebsiteMetadata(
                 'https://example.com',
@@ -385,6 +471,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
             self.assertIsNotNone(expected_metadata.description, metadata['description'])
 
     def test_check_returns_bookmark_if_url_is_bookmarked(self):
+        self.authenticate()
+
         bookmark = self.setup_bookmark(url='https://example.com',
                                        title='Example title',
                                        description='Example description')
@@ -401,6 +489,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.description, bookmark_data['description'])
 
     def test_check_returns_existing_metadata_if_url_is_bookmarked(self):
+        self.authenticate()
+
         bookmark = self.setup_bookmark(url='https://example.com',
                                        website_title='Existing title',
                                        website_description='Existing description')
@@ -418,6 +508,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
             self.assertIsNotNone(bookmark.website_description, metadata['description'])
 
     def test_can_only_access_own_bookmarks(self):
+        self.authenticate()
+
         other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
         inaccessible_bookmark = self.setup_bookmark(user=other_user)
         inaccessible_shared_bookmark = self.setup_bookmark(user=other_user, shared=True)

bookmarks/tests/test_bookmarks_api_permissions.py

@@ -0,0 +1,113 @@
+import urllib.parse
+
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.authtoken.models import Token
+
+from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
+
+
+class BookmarksApiPermissionsTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
+    def authenticate(self) -> None:
+        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
+
+    def test_list_bookmarks_requires_authentication(self):
+        self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
+
+    def test_list_archived_bookmarks_requires_authentication(self):
+        self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
+
+    def test_list_shared_bookmarks_does_not_require_authentication(self):
+        self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+
+        self.authenticate()
+        self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+
+    def test_create_bookmark_requires_authentication(self):
+        data = {
+            'url': 'https://example.com/',
+            'title': 'Test title',
+            'description': 'Test description',
+            'notes': 'Test notes',
+            'is_archived': False,
+            'unread': False,
+            'shared': False,
+            'tag_names': ['tag1', 'tag2']
+        }
+
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+
+    def test_get_bookmark_requires_authentication(self):
+        bookmark = self.setup_bookmark()
+        url = reverse('bookmarks:bookmark-detail', args=[bookmark.id])
+
+        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.get(url, expected_status_code=status.HTTP_200_OK)
+
+    def test_update_bookmark_requires_authentication(self):
+        bookmark = self.setup_bookmark()
+        data = {'url': 'https://example.com/'}
+        url = reverse('bookmarks:bookmark-detail', args=[bookmark.id])
+
+        self.put(url, data, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.put(url, data, expected_status_code=status.HTTP_200_OK)
+
+    def test_patch_bookmark_requires_authentication(self):
+        bookmark = self.setup_bookmark()
+        data = {'url': 'https://example.com'}
+        url = reverse('bookmarks:bookmark-detail', args=[bookmark.id])
+
+        self.patch(url, data, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+
+    def test_delete_bookmark_requires_authentication(self):
+        bookmark = self.setup_bookmark()
+        url = reverse('bookmarks:bookmark-detail', args=[bookmark.id])
+
+        self.delete(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+
+    def test_archive_requires_authentication(self):
+        bookmark = self.setup_bookmark()
+        url = reverse('bookmarks:bookmark-archive', args=[bookmark.id])
+
+        self.post(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+
+    def test_unarchive_requires_authentication(self):
+        bookmark = self.setup_bookmark(is_archived=True)
+        url = reverse('bookmarks:bookmark-unarchive', args=[bookmark.id])
+
+        self.post(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+
+    def test_check_requires_authentication(self):
+        url = reverse('bookmarks:bookmark-check')
+        check_url = urllib.parse.quote_plus('https://example.com')
+
+        self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_401_UNAUTHORIZED)
+
+        self.authenticate()
+        self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)

bookmarks/tests/test_bookmarks_list_tag.py

@@ -1,254 +0,0 @@
-from dateutil.relativedelta import relativedelta
-from django.core.paginator import Paginator
-from django.template import Template, RequestContext
-from django.test import TestCase, RequestFactory
-from django.urls import reverse
-from django.utils import timezone, formats
-
-from bookmarks.models import Bookmark, UserProfile, User
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
-
-    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank', unread: bool = False):
-        self.assertInHTML(
-            f'''
-            <a href="{bookmark.url}" 
-                target="{link_target}" 
-                rel="noopener" 
-                class="{'text-italic' if unread else ''}">{bookmark.resolved_title}</a>
-            ''',
-            html
-        )
-
-    def assertDateLabel(self, html: str, label_content: str):
-        self.assertInHTML(f'''
-        <span class="date-label text-gray text-sm">
-            <span>{label_content}</span>
-        </span>
-        <span class="text-gray text-sm">|</span>
-        ''', html)
-
-    def assertWebArchiveLink(self, html: str, label_content: str, url: str, link_target: str = '_blank'):
-        self.assertInHTML(f'''
-        <span class="date-label text-gray text-sm">
-            <a href="{url}"
-               title="Show snapshot on the Internet Archive Wayback Machine" target="{link_target}" rel="noopener">
-                <span>{label_content}</span>
-                <span>∞</span>
-            </a>
-        </span>
-        <span class="text-gray text-sm">|</span>
-        ''', html)
-
-    def assertBookmarkActions(self, html: str, bookmark: Bookmark):
-        self.assertBookmarkActionsCount(html, bookmark, count=1)
-
-    def assertNoBookmarkActions(self, html: str, bookmark: Bookmark):
-        self.assertBookmarkActionsCount(html, bookmark, count=0)
-
-    def assertBookmarkActionsCount(self, html: str, bookmark: Bookmark, count=1):
-        # Edit link
-        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
-        self.assertInHTML(f'''
-            <a href="{edit_url}?return_url=/test"
-               class="btn btn-link btn-sm">Edit</a>
-        ''', html, count=count)
-        # Archive link
-        self.assertInHTML(f'''
-            <button type="submit" name="archive" value="{bookmark.id}"
-               class="btn btn-link btn-sm">Archive</button>
-        ''', html, count=count)
-        # Delete link
-        self.assertInHTML(f'''
-            <button type="submit" name="remove" value="{bookmark.id}"
-               class="btn btn-link btn-sm btn-confirmation">Remove</button>
-        ''', html, count=count)
-
-    def assertShareInfo(self, html: str, bookmark: Bookmark):
-        self.assertShareInfoCount(html, bookmark, 1)
-
-    def assertNoShareInfo(self, html: str, bookmark: Bookmark):
-        self.assertShareInfoCount(html, bookmark, 0)
-
-    def assertShareInfoCount(self, html: str, bookmark: Bookmark, count=1):
-        self.assertInHTML(f'''
-            <span class="text-gray text-sm">Shared by 
-                <a class="text-gray" href="?user={bookmark.owner.username}">{bookmark.owner.username}</a>
-            </span>
-        ''', html, count=count)
-
-    def assertFaviconVisible(self, html: str, bookmark: Bookmark):
-        self.assertFaviconCount(html, bookmark, 1)
-
-    def assertFaviconHidden(self, html: str, bookmark: Bookmark):
-        self.assertFaviconCount(html, bookmark, 0)
-
-    def assertFaviconCount(self, html: str, bookmark: Bookmark, count=1):
-        self.assertInHTML(f'''
-            <img src="/static/{bookmark.favicon_file}" alt="">
-            ''', html, count=count)
-
-    def render_template(self, bookmarks: [Bookmark], template: Template, url: str = '/test') -> str:
-        rf = RequestFactory()
-        request = rf.get(url)
-        request.user = self.get_or_create_test_user()
-        paginator = Paginator(bookmarks, 10)
-        page = paginator.page(1)
-
-        context = RequestContext(request, {'bookmarks': page, 'return_url': '/test'})
-        return template.render(context)
-
-    def render_default_template(self, bookmarks: [Bookmark], url: str = '/test') -> str:
-        template = Template(
-            '{% load bookmarks %}'
-            '{% bookmark_list bookmarks return_url %}'
-        )
-        return self.render_template(bookmarks, template, url)
-
-    def render_template_with_link_target(self, bookmarks: [Bookmark], link_target: str) -> str:
-        template = Template(
-            f'''
-            {{% load bookmarks %}}
-            {{% bookmark_list bookmarks return_url '{link_target}' %}}
-            '''
-        )
-        return self.render_template(bookmarks, template)
-
-    def setup_date_format_test(self, date_display_setting: str, web_archive_url: str = ''):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = web_archive_url
-        bookmark.save()
-        user = self.get_or_create_test_user()
-        user.profile.bookmark_date_display = date_display_setting
-        user.profile.save()
-        return bookmark
-
-    def test_should_respect_absolute_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE)
-        html = self.render_default_template([bookmark])
-        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
-
-        self.assertDateLabel(html, formatted_date)
-
-    def test_should_render_web_archive_link_with_absolute_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE,
-                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
-        html = self.render_default_template([bookmark])
-        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
-
-        self.assertWebArchiveLink(html, formatted_date, bookmark.web_archive_snapshot_url)
-
-    def test_should_respect_relative_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE)
-        html = self.render_default_template([bookmark])
-
-        self.assertDateLabel(html, '1 week ago')
-
-    def test_should_render_web_archive_link_with_relative_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE,
-                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
-        html = self.render_default_template([bookmark])
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url)
-
-    def test_bookmark_link_target_should_be_blank_by_default(self):
-        bookmark = self.setup_bookmark()
-
-        html = self.render_default_template([bookmark])
-
-        self.assertBookmarksLink(html, bookmark, link_target='_blank')
-
-    def test_bookmark_link_target_should_respect_link_target_parameter(self):
-        bookmark = self.setup_bookmark()
-
-        html = self.render_template_with_link_target([bookmark], '_self')
-
-        self.assertBookmarksLink(html, bookmark, link_target='_self')
-
-    def test_bookmark_link_target_should_respect_unread_flag(self):
-        bookmark = self.setup_bookmark()
-        html = self.render_template_with_link_target([bookmark], '_self')
-        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=False)
-
-        bookmark = self.setup_bookmark(unread=True)
-        html = self.render_template_with_link_target([bookmark], '_self')
-        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=True)
-
-    def test_web_archive_link_target_should_be_blank_by_default(self):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = 'https://example.com'
-        bookmark.save()
-
-        html = self.render_default_template([bookmark])
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_blank')
-
-    def test_web_archive_link_target_respect_link_target_parameter(self):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = 'https://example.com'
-        bookmark.save()
-
-        html = self.render_template_with_link_target([bookmark], '_self')
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_self')
-
-    def test_show_bookmark_actions_for_owned_bookmarks(self):
-        bookmark = self.setup_bookmark()
-        html = self.render_default_template([bookmark])
-
-        self.assertBookmarkActions(html, bookmark)
-        self.assertNoShareInfo(html, bookmark)
-
-    def test_show_share_info_for_non_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(user=other_user)
-        html = self.render_default_template([bookmark])
-
-        self.assertNoBookmarkActions(html, bookmark)
-        self.assertShareInfo(html, bookmark)
-
-    def test_share_info_user_link_keeps_query_params(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(user=other_user)
-        html = self.render_default_template([bookmark], url='/test?q=foo')
-
-        self.assertInHTML(f'''
-            <span class="text-gray text-sm">Shared by 
-                <a class="text-gray" href="?q=foo&user={bookmark.owner.username}">{bookmark.owner.username}</a>
-            </span>
-        ''', html)
-
-    def test_favicon_should_be_visible_when_favicons_enabled(self):
-        profile = self.get_or_create_test_user().profile
-        profile.enable_favicons = True
-        profile.save()
-
-        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
-        html = self.render_default_template([bookmark])
-
-        self.assertFaviconVisible(html, bookmark)
-
-    def test_favicon_should_be_hidden_when_there_is_no_icon(self):
-        profile = self.get_or_create_test_user().profile
-        profile.enable_favicons = True
-        profile.save()
-
-        bookmark = self.setup_bookmark(favicon_file='')
-        html = self.render_default_template([bookmark])
-
-        self.assertFaviconHidden(html, bookmark)
-
-    def test_favicon_should_be_hidden_when_favicons_disabled(self):
-        profile = self.get_or_create_test_user().profile
-        profile.enable_favicons = False
-        profile.save()
-
-        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
-        html = self.render_default_template([bookmark])
-
-        self.assertFaviconHidden(html, bookmark)

bookmarks/tests/test_bookmarks_list_template.py

@@ -0,0 +1,442 @@
+from typing import Type
+
+from dateutil.relativedelta import relativedelta
+from django.contrib.auth.models import AnonymousUser
+from django.http import HttpResponse
+from django.template import Template, RequestContext
+from django.test import TestCase, RequestFactory
+from django.urls import reverse
+from django.utils import timezone, formats
+
+from bookmarks.middlewares import UserProfileMiddleware
+from bookmarks.models import Bookmark, UserProfile, User
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.views.partials import contexts
+
+
+class BookmarkListTemplateTest(TestCase, BookmarkFactoryMixin):
+
+    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
+        unread = bookmark.unread
+        favicon_img = f'<img src="/static/{bookmark.favicon_file}" alt="">' if bookmark.favicon_file else ''
+        self.assertInHTML(
+            f'''
+            <a href="{bookmark.url}" 
+                target="{link_target}" 
+                rel="noopener" 
+                class="{'text-italic' if unread else ''}">
+                {favicon_img}
+                {bookmark.resolved_title}
+            </a>
+            ''',
+            html
+        )
+
+    def assertDateLabel(self, html: str, label_content: str):
+        self.assertInHTML(f'''
+        <span>
+            <span>{label_content}</span>
+        </span>
+        <span class="separator">|</span>
+        ''', html)
+
+    def assertWebArchiveLink(self, html: str, label_content: str, url: str, link_target: str = '_blank'):
+        self.assertInHTML(f'''
+        <span>
+            <a href="{url}"
+               title="Show snapshot on the Internet Archive Wayback Machine" target="{link_target}" rel="noopener">
+                <span>{label_content}</span>
+                ∞
+            </a>
+        </span>
+        <span class="separator">|</span>
+        ''', html)
+
+    def assertBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=1)
+
+    def assertNoBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=0)
+
+    def assertBookmarkActionsCount(self, html: str, bookmark: Bookmark, count=1):
+        # Edit link
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url=%2Fbookmarks">Edit</a>
+        ''', html, count=count)
+        # Archive link
+        self.assertInHTML(f'''
+            <button type="submit" name="archive" value="{bookmark.id}"
+               class="btn btn-link btn-sm">Archive</button>
+        ''', html, count=count)
+        # Delete link
+        self.assertInHTML(f'''
+            <button ld-confirm-button type="submit" name="remove" value="{bookmark.id}"
+               class="btn btn-link btn-sm">Remove</button>
+        ''', html, count=count)
+
+    def assertShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 1)
+
+    def assertNoShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 0)
+
+    def assertShareInfoCount(self, html: str, bookmark: Bookmark, count=1):
+        self.assertInHTML(f'''
+            <span>Shared by 
+                <a href="?user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html, count=count)
+
+    def assertFaviconVisible(self, html: str, bookmark: Bookmark):
+        self.assertFaviconCount(html, bookmark, 1)
+
+    def assertFaviconHidden(self, html: str, bookmark: Bookmark):
+        self.assertFaviconCount(html, bookmark, 0)
+
+    def assertFaviconCount(self, html: str, bookmark: Bookmark, count=1):
+        self.assertInHTML(f'''
+            <img src="/static/{bookmark.favicon_file}" alt="">
+            ''', html, count=count)
+
+    def assertBookmarkURLCount(self, html: str, bookmark: Bookmark, link_target: str = '_blank', count=0):
+        self.assertInHTML(f'''
+        <div class="url-path truncate">
+          <a href="{bookmark.url}" target="{link_target}" rel="noopener" 
+          class="url-display text-sm">
+            {bookmark.url}
+          </a>
+        </div>
+        ''', html, count)
+
+    def assertBookmarkURLVisible(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkURLCount(html, bookmark, count=1)
+
+    def assertBookmarkURLHidden(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
+        self.assertBookmarkURLCount(html, bookmark, count=0)
+
+    def assertNotes(self, html: str, notes_html: str, count=1):
+        self.assertInHTML(f'''
+        <div class="notes bg-gray text-gray-dark">
+          <div class="notes-content">
+            {notes_html}
+          </div>
+        </div>
+        ''', html, count=count)
+
+    def assertNotesToggle(self, html: str, count=1):
+        self.assertInHTML(f'''
+          <button class="btn btn-link btn-sm toggle-notes" title="Toggle notes">
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-notes" width="16" height="16"
+                 viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round"
+                 stroke-linejoin="round">
+              <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+              <path d="M5 3m0 2a2 2 0 0 1 2 -2h10a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2z"></path>
+              <path d="M9 7l6 0"></path>
+              <path d="M9 11l6 0"></path>
+              <path d="M9 15l4 0"></path>
+            </svg>
+            <span>Notes</span>
+          </button>        
+          ''', html, count=count)
+
+    def render_template(self,
+                        url='/bookmarks',
+                        context_type: Type[contexts.BookmarkListContext] = contexts.ActiveBookmarkListContext,
+                        user: User | AnonymousUser = None) -> str:
+        rf = RequestFactory()
+        request = rf.get(url)
+        request.user = user or self.get_or_create_test_user()
+        middleware = UserProfileMiddleware(lambda r: HttpResponse())
+        middleware(request)
+
+        bookmark_list_context = context_type(request)
+        context = RequestContext(request, {'bookmark_list': bookmark_list_context})
+
+        template = Template(
+            "{% include 'bookmarks/bookmark_list.html' %}"
+        )
+        return template.render(context)
+
+    def setup_date_format_test(self, date_display_setting: str, web_archive_url: str = ''):
+        bookmark = self.setup_bookmark()
+        bookmark.date_added = timezone.now() - relativedelta(days=8)
+        bookmark.web_archive_snapshot_url = web_archive_url
+        bookmark.save()
+        user = self.get_or_create_test_user()
+        user.profile.bookmark_date_display = date_display_setting
+        user.profile.save()
+        return bookmark
+
+    def test_should_respect_absolute_date_setting(self):
+        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE)
+        html = self.render_template()
+        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
+
+        self.assertDateLabel(html, formatted_date)
+
+    def test_should_render_web_archive_link_with_absolute_date_setting(self):
+        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE,
+                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
+        html = self.render_template()
+        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
+
+        self.assertWebArchiveLink(html, formatted_date, bookmark.web_archive_snapshot_url)
+
+    def test_should_respect_relative_date_setting(self):
+        self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE)
+        html = self.render_template()
+
+        self.assertDateLabel(html, '1 week ago')
+
+    def test_should_render_web_archive_link_with_relative_date_setting(self):
+        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE,
+                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
+        html = self.render_template()
+
+        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url)
+
+    def test_bookmark_link_target_should_be_blank_by_default(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarksLink(html, bookmark, link_target='_blank')
+
+    def test_bookmark_link_target_should_respect_user_profile(self):
+        profile = self.get_or_create_test_user().profile
+        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarksLink(html, bookmark, link_target='_self')
+
+    def test_web_archive_link_target_should_be_blank_by_default(self):
+        bookmark = self.setup_bookmark()
+        bookmark.date_added = timezone.now() - relativedelta(days=8)
+        bookmark.web_archive_snapshot_url = 'https://example.com'
+        bookmark.save()
+
+        html = self.render_template()
+
+        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_blank')
+
+    def test_web_archive_link_target_should_respect_user_profile(self):
+        profile = self.get_or_create_test_user().profile
+        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        bookmark.date_added = timezone.now() - relativedelta(days=8)
+        bookmark.web_archive_snapshot_url = 'https://example.com'
+        bookmark.save()
+
+        html = self.render_template()
+
+        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_self')
+
+    def test_should_respect_unread_flag(self):
+        bookmark = self.setup_bookmark(unread=True)
+        html = self.render_template()
+
+        self.assertBookmarksLink(html, bookmark)
+
+    def test_show_bookmark_actions_for_owned_bookmarks(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarkActions(html, bookmark)
+        self.assertNoShareInfo(html, bookmark)
+
+    def test_show_share_info_for_non_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        other_user.profile.enable_sharing = True
+        other_user.profile.save()
+
+        bookmark = self.setup_bookmark(user=other_user, shared=True)
+        html = self.render_template(context_type=contexts.SharedBookmarkListContext)
+
+        self.assertNoBookmarkActions(html, bookmark)
+        self.assertShareInfo(html, bookmark)
+
+    def test_share_info_user_link_keeps_query_params(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        other_user.profile.enable_sharing = True
+        other_user.profile.save()
+
+        bookmark = self.setup_bookmark(user=other_user, shared=True, title='foo')
+        html = self.render_template(url='/bookmarks?q=foo', context_type=contexts.SharedBookmarkListContext)
+
+        self.assertInHTML(f'''
+            <span>Shared by 
+                <a href="?q=foo&user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html)
+
+    def test_favicon_should_be_visible_when_favicons_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = True
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
+        html = self.render_template()
+
+        self.assertFaviconVisible(html, bookmark)
+
+    def test_favicon_should_be_hidden_when_there_is_no_icon(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = True
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='')
+        html = self.render_template()
+
+        self.assertFaviconHidden(html, bookmark)
+
+    def test_favicon_should_be_hidden_when_favicons_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = False
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
+        html = self.render_template()
+
+        self.assertFaviconHidden(html, bookmark)
+
+    def test_bookmark_url_should_be_hidden_by_default(self):
+        profile = self.get_or_create_test_user().profile
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarkURLHidden(html, bookmark)
+
+    def test_show_bookmark_url_when_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.display_url = True
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarkURLVisible(html, bookmark)
+
+    def test_hide_bookmark_url_when_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.display_url = False
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertBookmarkURLHidden(html, bookmark)
+
+    def test_without_notes(self):
+        self.setup_bookmark()
+        html = self.render_template()
+
+        self.assertNotes(html, '', 0)
+        self.assertNotesToggle(html, 0)
+
+    def test_with_notes(self):
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        note_html = '<p>Test note</p>'
+        self.assertNotes(html, note_html, 1)
+
+    def test_note_renders_markdown(self):
+        self.setup_bookmark(notes='**Example:** `print("Hello world!")`')
+        html = self.render_template()
+
+        note_html = '<p><strong>Example:</strong> <code>print("Hello world!")</code></p>'
+        self.assertNotes(html, note_html, 1)
+
+    def test_note_cleans_html(self):
+        self.setup_bookmark(notes='<script>alert("test")</script>')
+        html = self.render_template()
+
+        note_html = '&lt;script&gt;alert("test")&lt;/script&gt;'
+        self.assertNotes(html, note_html, 1)
+
+    def test_notes_are_hidden_initially_by_default(self):
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertIn('<ul class="bookmark-list">', html)
+
+    def test_notes_are_hidden_initially_with_permanent_notes_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = False
+        profile.save()
+
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertIn('<ul class="bookmark-list">', html)
+
+    def test_notes_are_visible_initially_with_permanent_notes_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = True
+        profile.save()
+
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertIn('<ul class="bookmark-list show-notes">', html)
+
+    def test_toggle_notes_is_visible_by_default(self):
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertNotesToggle(html, 1)
+
+    def test_toggle_notes_is_visible_with_permanent_notes_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = False
+        profile.save()
+
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertNotesToggle(html, 1)
+
+    def test_toggle_notes_is_hidden_with_permanent_notes_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = True
+        profile.save()
+
+        self.setup_bookmark(notes='Test note')
+        html = self.render_template()
+
+        self.assertNotesToggle(html, 0)
+
+    def test_with_anonymous_user(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_sharing = True
+        profile.enable_public_sharing = True
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        bookmark.date_added = timezone.now() - relativedelta(days=8)
+        bookmark.web_archive_snapshot_url = 'https://web.archive.org/web/20230531200136/https://example.com'
+        bookmark.notes = '**Example:** `print("Hello world!")`'
+        bookmark.favicon_file = 'https_example_com.png'
+        bookmark.shared = True
+        bookmark.save()
+
+        html = self.render_template(context_type=contexts.SharedBookmarkListContext, user=AnonymousUser())
+        self.assertBookmarksLink(html, bookmark, link_target='_blank')
+        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_blank')
+        self.assertNoBookmarkActions(html, bookmark)
+        self.assertShareInfo(html, bookmark)
+        note_html = '<p><strong>Example:</strong> <code>print("Hello world!")</code></p>'
+        self.assertNotes(html, note_html, 1)
+        self.assertFaviconVisible(html, bookmark)
+
+    def test_empty_state(self):
+        html = self.render_template()
+
+        self.assertInHTML('<p class="empty-title h5">You have no bookmarks yet</p>', html)

bookmarks/tests/test_bookmarks_service.py

@@ -46,6 +46,7 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
         bookmark_data = Bookmark(url='https://example.com',
                                  title='Updated Title',
                                  description='Updated description',
+                                 notes='Updated notes',
                                  unread=True,
                                  shared=True,
                                  is_archived=True)
@@ -55,6 +56,7 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.id, original_bookmark.id)
         self.assertEqual(updated_bookmark.title, bookmark_data.title)
         self.assertEqual(updated_bookmark.description, bookmark_data.description)
+        self.assertEqual(updated_bookmark.notes, bookmark_data.notes)
         self.assertEqual(updated_bookmark.unread, bookmark_data.unread)
         self.assertEqual(updated_bookmark.shared, bookmark_data.shared)
         # Saving a duplicate bookmark should not modify archive flag - right?

bookmarks/tests/test_exporter.py

@@ -0,0 +1,54 @@
+from django.test import TestCase
+from django.utils import timezone
+
+from bookmarks.services import exporter
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class ExporterTestCase(TestCase, BookmarkFactoryMixin):
+    def test_export_bookmarks(self):
+        added = timezone.now()
+        timestamp = int(added.timestamp())
+
+        bookmarks = [
+            self.setup_bookmark(url='https://example.com/1', title='Title 1', added=added,
+                                description='Example description'),
+            self.setup_bookmark(url='https://example.com/2', title='Title 2', added=added,
+                                tags=[self.setup_tag(name='tag1'), self.setup_tag(name='tag2'),
+                                      self.setup_tag(name='tag3')]),
+            self.setup_bookmark(url='https://example.com/3', title='Title 3', added=added, unread=True),
+            self.setup_bookmark(url='https://example.com/4', title='Title 4', added=added, shared=True),
+
+        ]
+        html = exporter.export_netscape_html(bookmarks)
+
+        lines = [
+            f'<DT><A HREF="https://example.com/1" ADD_DATE="{timestamp}" PRIVATE="1" TOREAD="0" TAGS="">Title 1</A>',
+            '<DD>Example description',
+            f'<DT><A HREF="https://example.com/2" ADD_DATE="{timestamp}" PRIVATE="1" TOREAD="0" TAGS="tag1,tag2,tag3">Title 2</A>',
+            f'<DT><A HREF="https://example.com/3" ADD_DATE="{timestamp}" PRIVATE="1" TOREAD="1" TAGS="">Title 3</A>',
+            f'<DT><A HREF="https://example.com/4" ADD_DATE="{timestamp}" PRIVATE="0" TOREAD="0" TAGS="">Title 4</A>',
+        ]
+        self.assertIn('\n\r'.join(lines), html)
+
+    def test_escape_html_in_title_and_description(self):
+        bookmark = self.setup_bookmark(
+            title='<style>: The Style Information element',
+            description='The <style> HTML element contains style information for a document, or part of a document.'
+        )
+        html = exporter.export_netscape_html([bookmark])
+
+        self.assertIn('&lt;style&gt;: The Style Information element', html)
+        self.assertIn(
+            'The &lt;style&gt; HTML element contains style information for a document, or part of a document.',
+            html
+        )
+
+    def test_handle_empty_values(self):
+        bookmark = self.setup_bookmark()
+        bookmark.title = ''
+        bookmark.description = ''
+        bookmark.website_title = None
+        bookmark.website_description = None
+        bookmark.save()
+        exporter.export_netscape_html([bookmark])

bookmarks/tests/test_favicon_loader.py

@@ -2,25 +2,40 @@ import io
 import os.path
 import time
 from pathlib import Path
-from unittest import mock
+from unittest import mock, skip
 
 from django.conf import settings
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 from bookmarks.services import favicon_loader
 
 mock_icon_data = b'mock_icon'
 
 
+class MockStreamingResponse:
+    def __init__(self, data=mock_icon_data, content_type='image/png'):
+        self.chunks = [data]
+        self.headers = {'Content-Type': content_type}
+
+    def iter_content(self, **kwargs):
+        return self.chunks
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+
 class FaviconLoaderTestCase(TestCase):
     def setUp(self) -> None:
         self.ensure_favicon_folder()
         self.clear_favicon_folder()
 
-    def create_mock_response(self, icon_data=mock_icon_data):
+    def create_mock_response(self, icon_data=mock_icon_data, content_type='image/png'):
         mock_response = mock.Mock()
         mock_response.raw = io.BytesIO(icon_data)
-        return mock_response
+        return MockStreamingResponse(icon_data, content_type)
 
     def ensure_favicon_folder(self):
         Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)
@@ -93,12 +108,14 @@ class FaviconLoaderTestCase(TestCase):
         with mock.patch('requests.get') as mock_get:
             mock_get.return_value = self.create_mock_response()
 
-            favicon_loader.load_favicon('https://example.com')
+            favicon_file = favicon_loader.load_favicon('https://example.com')
             mock_get.assert_called()
+            self.assertEqual(favicon_file, 'https_example_com.png')
 
             mock_get.reset_mock()
-            favicon_loader.load_favicon('https://example.com')
+            updated_favicon_file = favicon_loader.load_favicon('https://example.com')
             mock_get.assert_not_called()
+            self.assertEqual(favicon_file, updated_favicon_file)
 
     def test_load_favicon_updates_stale_icon(self):
         with mock.patch('requests.get') as mock_get:
@@ -125,3 +142,35 @@ class FaviconLoaderTestCase(TestCase):
             favicon_loader.load_favicon('https://example.com')
             mock_get.assert_called()
             self.assertEqual(updated_mock_icon_data, self.get_icon_data('https_example_com.png'))
+
+    @override_settings(LD_FAVICON_PROVIDER='https://custom.icons.com/?url={url}')
+    def test_custom_provider_with_url_param(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+
+            favicon_loader.load_favicon('https://example.com/foo?bar=baz')
+            mock_get.assert_called_with('https://custom.icons.com/?url=https://example.com', stream=True)
+
+    @override_settings(LD_FAVICON_PROVIDER='https://custom.icons.com/?url={domain}')
+    def test_custom_provider_with_domain_param(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+
+            favicon_loader.load_favicon('https://example.com/foo?bar=baz')
+            mock_get.assert_called_with('https://custom.icons.com/?url=example.com', stream=True)
+
+    def test_guess_file_extension(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response(content_type='image/png')
+            favicon_loader.load_favicon('https://example.com')
+
+            self.assertTrue(self.icon_exists('https_example_com.png'))
+
+        self.clear_favicon_folder()
+        self.ensure_favicon_folder()
+
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response(content_type='image/x-icon')
+            favicon_loader.load_favicon('https://example.com')
+
+            self.assertTrue(self.icon_exists('https_example_com.ico'))

bookmarks/tests/test_importer.py

@@ -6,7 +6,7 @@ from django.utils import timezone
 
 from bookmarks.models import Bookmark, Tag, parse_tag_string
 from bookmarks.services import tasks
-from bookmarks.services.importer import import_netscape_html
+from bookmarks.services.importer import import_netscape_html, ImportOptions
 from bookmarks.tests.helpers import BookmarkFactoryMixin, ImportTestMixin, BookmarkHtmlTag, disable_logging
 from bookmarks.utils import parse_timestamp
 
@@ -22,6 +22,7 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
             self.assertEqual(bookmark.description, html_tag.description)
             self.assertEqual(bookmark.date_added, parse_timestamp(html_tag.add_date))
             self.assertEqual(bookmark.unread, html_tag.to_read)
+            self.assertEqual(bookmark.shared, not html_tag.private)
 
             tag_names = parse_tag_string(html_tag.tags)
 
@@ -66,35 +67,46 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
                             add_date='3', tags='bar-tag, other-tag'),
             BookmarkHtmlTag(href='https://example.com/unread', title='Unread title', description='Unread description',
                             add_date='3', to_read=True),
+            BookmarkHtmlTag(href='https://example.com/private', title='Private title', description='Private description',
+                            add_date='4', private=True),
         ]
         import_html = self.render_html(tags=html_tags)
         import_netscape_html(import_html, self.get_or_create_test_user())
 
+        # Check bookmarks
+        bookmarks = Bookmark.objects.all()
+        self.assertEqual(len(bookmarks), 5)
+        self.assertBookmarksImported(html_tags)
+
         # Change data, add some new data
         html_tags = [
             BookmarkHtmlTag(href='https://example.com', title='Updated Example title',
                             description='Updated Example description', add_date='111', tags='updated-example-tag'),
-            BookmarkHtmlTag(href='https://example.com/foo', title='Updated Foo title', description='Updated Foo description',
+            BookmarkHtmlTag(href='https://example.com/foo', title='Updated Foo title',
+                            description='Updated Foo description',
                             add_date='222', tags='new-tag'),
-            BookmarkHtmlTag(href='https://example.com/bar', title='Updated Bar title', description='Updated Bar description',
+            BookmarkHtmlTag(href='https://example.com/bar', title='Updated Bar title',
+                            description='Updated Bar description',
                             add_date='333', tags='updated-bar-tag, updated-other-tag'),
             BookmarkHtmlTag(href='https://example.com/unread', title='Unread title', description='Unread description',
                             add_date='3', to_read=False),
+            BookmarkHtmlTag(href='https://example.com/private', title='Private title', description='Private description',
+                            add_date='4', private=False),
             BookmarkHtmlTag(href='https://baz.com', add_date='444', tags='baz-tag')
         ]
 
         # Import updated data
         import_html = self.render_html(tags=html_tags)
-        result = import_netscape_html(import_html, self.get_or_create_test_user())
+        result = import_netscape_html(import_html, self.get_or_create_test_user(), ImportOptions(map_private_flag=True))
 
         # Check result
-        self.assertEqual(result.total, 5)
-        self.assertEqual(result.success, 5)
+        self.assertEqual(result.total, 6)
+        self.assertEqual(result.success, 6)
         self.assertEqual(result.failed, 0)
 
         # Check bookmarks
         bookmarks = Bookmark.objects.all()
-        self.assertEqual(len(bookmarks), 5)
+        self.assertEqual(len(bookmarks), 6)
         self.assertBookmarksImported(html_tags)
 
     def test_import_with_some_invalid_bookmarks(self):
@@ -254,6 +266,33 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
         self.assertEqual(import_result.success, 0)
         self.assertEqual(import_result.failed, 2)
 
+    def test_private_flag(self):
+        # does not map private flag if not enabled in options
+        test_html = self.render_html(tags_html='''
+        <DT><A HREF="https://example.com/1" ADD_DATE="1">Example title 1</A>
+        <DD>Example description 1</DD>
+        <DT><A HREF="https://example.com/2" ADD_DATE="1" PRIVATE="1">Example title 2</A>
+        <DD>Example description 2</DD>
+        <DT><A HREF="https://example.com/3" ADD_DATE="1" PRIVATE="0">Example title 3</A>
+        <DD>Example description 3</DD>
+        ''')
+        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())
+
+        self.assertEqual(Bookmark.objects.count(), 3)
+        self.assertEqual(Bookmark.objects.all()[0].shared, False)
+        self.assertEqual(Bookmark.objects.all()[1].shared, False)
+        self.assertEqual(Bookmark.objects.all()[2].shared, False)
+
+        # does map private flag if enabled in options
+        Bookmark.objects.all().delete()
+        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions(map_private_flag=True))
+        bookmark1 = Bookmark.objects.get(url='https://example.com/1')
+        bookmark2 = Bookmark.objects.get(url='https://example.com/2')
+        bookmark3 = Bookmark.objects.get(url='https://example.com/3')
+        self.assertEqual(bookmark1.shared, False)
+        self.assertEqual(bookmark2.shared, False)
+        self.assertEqual(bookmark3.shared, True)
+
     def test_schedule_snapshot_creation(self):
         user = self.get_or_create_test_user()
         test_html = self.render_html(tags_html='')

bookmarks/tests/test_metadata_view.py

@@ -0,0 +1,33 @@
+from django.test import TestCase, override_settings
+
+
+class MetadataViewTestCase(TestCase):
+
+    def test_default_manifest(self):
+        response = self.client.get("/manifest.json")
+
+        self.assertEqual(response.status_code, 200)
+
+        response_body = response.json()
+        expected_body = {
+            "short_name": "linkding",
+            "start_url": "bookmarks",
+            "display": "standalone",
+            "scope": "/"
+        }
+        self.assertDictEqual(response_body, expected_body)
+
+    @override_settings(LD_CONTEXT_PATH="linkding/")
+    def test_manifest_respects_context_path(self):
+        response = self.client.get("/manifest.json")
+
+        self.assertEqual(response.status_code, 200)
+
+        response_body = response.json()
+        expected_body = {
+            "short_name": "linkding",
+            "start_url": "bookmarks",
+            "display": "standalone",
+            "scope": "/linkding/"
+        }
+        self.assertDictEqual(response_body, expected_body)

bookmarks/tests/test_pagination_tag.py

@@ -1,13 +1,17 @@
 from django.core.paginator import Paginator
 from django.template import Template, RequestContext
-from django.test import SimpleTestCase, RequestFactory
+from django.test import TestCase, RequestFactory
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
-class PaginationTagTest(SimpleTestCase):
+class PaginationTagTest(TestCase, BookmarkFactoryMixin):
 
     def render_template(self, num_items: int, page_size: int, current_page: int, url: str = '/test') -> str:
         rf = RequestFactory()
         request = rf.get(url)
+        request.user = self.get_or_create_test_user()
+        request.user_profile = self.get_or_create_test_user().profile
         paginator = Paginator(range(0, num_items), page_size)
         page = paginator.page(current_page)
 

bookmarks/tests/test_parser.py

@@ -18,6 +18,7 @@ class ParserTestCase(TestCase, ImportTestMixin):
             self.assertEqual(bookmark.description, html_tag.description)
             self.assertEqual(bookmark.tag_string, html_tag.tags)
             self.assertEqual(bookmark.to_read, html_tag.to_read)
+            self.assertEqual(bookmark.private, html_tag.private)
 
     def test_parse_bookmarks(self):
         html_tags = [
@@ -123,3 +124,28 @@ class ParserTestCase(TestCase, ImportTestMixin):
         bookmarks = parse(html)
 
         self.assertTagsEqual(bookmarks, html_tags)
+
+    def test_private_flag(self):
+        # is private by default
+        html = self.render_html(tags_html='''
+        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
+        <DD>Example description</DD>
+        ''')
+        bookmarks = parse(html)
+        self.assertEqual(bookmarks[0].private, True)
+
+        # explicitly marked as private
+        html = self.render_html(tags_html='''
+        <DT><A HREF="https://example.com" ADD_DATE="1" PRIVATE="1">Example title</A>
+        <DD>Example description</DD>
+        ''')
+        bookmarks = parse(html)
+        self.assertEqual(bookmarks[0].private, True)
+
+        # explicitly marked as public
+        html = self.render_html(tags_html='''
+        <DT><A HREF="https://example.com" ADD_DATE="1" PRIVATE="0">Example title</A>
+        <DD>Example description</DD>
+        ''')
+        bookmarks = parse(html)
+        self.assertEqual(bookmarks[0].private, False)

bookmarks/tests/test_queries.py

@@ -5,7 +5,7 @@ from django.db.models import QuerySet
 from django.test import TestCase
 
 from bookmarks import queries
-from bookmarks.models import Bookmark
+from bookmarks.models import Bookmark, UserProfile
 from bookmarks.tests.helpers import BookmarkFactoryMixin, random_sentence
 from bookmarks.utils import unique
 
@@ -13,6 +13,8 @@ User = get_user_model()
 
 
 class QueriesTestCase(TestCase, BookmarkFactoryMixin):
+    def setUp(self):
+        self.profile = self.get_or_create_test_user().profile
 
     def setup_bookmark_search_data(self) -> None:
         tag1 = self.setup_tag(name='tag1')
@@ -27,9 +29,15 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.term1_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1'),
             self.setup_bookmark(title=random_sentence(including_word='term1')),
+            self.setup_bookmark(title=random_sentence(including_word='TERM1')),
             self.setup_bookmark(description=random_sentence(including_word='term1')),
+            self.setup_bookmark(description=random_sentence(including_word='TERM1')),
+            self.setup_bookmark(notes=random_sentence(including_word='term1')),
+            self.setup_bookmark(notes=random_sentence(including_word='TERM1')),
             self.setup_bookmark(website_title=random_sentence(including_word='term1')),
+            self.setup_bookmark(website_title=random_sentence(including_word='TERM1')),
             self.setup_bookmark(website_description=random_sentence(including_word='term1')),
+            self.setup_bookmark(website_description=random_sentence(including_word='TERM1')),
         ]
         self.term1_term2_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1/term2'),
@@ -49,6 +57,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_bookmark(website_title=random_sentence(), tags=[tag1]),
             self.setup_bookmark(website_description=random_sentence(), tags=[tag1]),
         ]
+        self.tag1_as_term_bookmarks = [
+            self.setup_bookmark(url='http://example.com/tag1'),
+            self.setup_bookmark(title=random_sentence(including_word='tag1')),
+            self.setup_bookmark(description=random_sentence(including_word='tag1')),
+            self.setup_bookmark(website_title=random_sentence(including_word='tag1')),
+            self.setup_bookmark(website_description=random_sentence(including_word='tag1')),
+        ]
         self.term1_tag1_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1', tags=[tag1]),
             self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1]),
@@ -76,9 +91,15 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.term1_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1', tags=[self.setup_tag()]),
             self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(title=random_sentence(including_word='TERM1'), tags=[self.setup_tag()]),
             self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(description=random_sentence(including_word='TERM1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(notes=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(notes=random_sentence(including_word='TERM1'), tags=[self.setup_tag()]),
             self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(website_title=random_sentence(including_word='TERM1'), tags=[self.setup_tag()]),
             self.setup_bookmark(website_description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(website_description=random_sentence(including_word='TERM1'), tags=[self.setup_tag()]),
         ]
         self.term1_term2_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1/term2', tags=[self.setup_tag()]),
@@ -102,6 +123,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_bookmark(website_title=random_sentence(), tags=[tag1, self.setup_tag()]),
             self.setup_bookmark(website_description=random_sentence(), tags=[tag1, self.setup_tag()]),
         ]
+        self.tag1_as_term_bookmarks = [
+            self.setup_bookmark(url='http://example.com/tag1'),
+            self.setup_bookmark(title=random_sentence(including_word='tag1')),
+            self.setup_bookmark(description=random_sentence(including_word='tag1')),
+            self.setup_bookmark(website_title=random_sentence(including_word='tag1')),
+            self.setup_bookmark(website_description=random_sentence(including_word='tag1')),
+        ]
         self.term1_tag1_bookmarks = [
             self.setup_bookmark(url='http://example.com/term1', tags=[tag1, self.setup_tag()]),
             self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
@@ -135,12 +163,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmarks_should_return_all_for_empty_query(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '')
+        query = queries.query_bookmarks(self.user, self.profile, '')
         self.assertQueryResult(query, [
             self.other_bookmarks,
             self.term1_bookmarks,
             self.term1_term2_bookmarks,
             self.tag1_bookmarks,
+            self.tag1_as_term_bookmarks,
             self.term1_tag1_bookmarks,
             self.tag2_bookmarks,
             self.tag1_tag2_bookmarks
@@ -149,7 +178,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmarks_should_search_single_term(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1')
+        query = queries.query_bookmarks(self.user, self.profile, 'term1')
         self.assertQueryResult(query, [
             self.term1_bookmarks,
             self.term1_term2_bookmarks,
@@ -159,63 +188,101 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmarks_should_search_multiple_terms(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term2 term1')
+        query = queries.query_bookmarks(self.user, self.profile, 'term2 term1')
 
         self.assertQueryResult(query, [self.term1_term2_bookmarks])
 
     def test_query_bookmarks_should_search_single_tag(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1')
+        query = queries.query_bookmarks(self.user, self.profile, '#tag1')
 
         self.assertQueryResult(query, [self.tag1_bookmarks, self.tag1_tag2_bookmarks, self.term1_tag1_bookmarks])
 
     def test_query_bookmarks_should_search_multiple_tags(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #tag2')
+        query = queries.query_bookmarks(self.user, self.profile, '#tag1 #tag2')
 
         self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
 
     def test_query_bookmarks_should_search_multiple_tags_ignoring_casing(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#Tag1 #TAG2')
+        query = queries.query_bookmarks(self.user, self.profile, '#Tag1 #TAG2')
 
         self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
 
     def test_query_bookmarks_should_search_terms_and_tags_combined(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag1')
+        query = queries.query_bookmarks(self.user, self.profile, 'term1 #tag1')
 
         self.assertQueryResult(query, [self.term1_tag1_bookmarks])
 
+    def test_query_bookmarks_in_strict_mode_should_not_search_tags_as_terms(self):
+        self.setup_bookmark_search_data()
+
+        self.profile.tag_search = UserProfile.TAG_SEARCH_STRICT
+        self.profile.save()
+
+        query = queries.query_bookmarks(self.user, self.profile, 'tag1')
+        self.assertQueryResult(query, [self.tag1_as_term_bookmarks])
+
+    def test_query_bookmarks_in_lax_mode_should_search_tags_as_terms(self):
+        self.setup_bookmark_search_data()
+
+        self.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.profile.save()
+
+        query = queries.query_bookmarks(self.user, self.profile, 'tag1')
+        self.assertQueryResult(query, [
+            self.tag1_bookmarks,
+            self.tag1_as_term_bookmarks,
+            self.tag1_tag2_bookmarks,
+            self.term1_tag1_bookmarks
+        ])
+
+        query = queries.query_bookmarks(self.user, self.profile, 'tag1 term1')
+        self.assertQueryResult(query, [
+            self.term1_tag1_bookmarks,
+        ])
+
+        query = queries.query_bookmarks(self.user, self.profile, 'tag1 tag2')
+        self.assertQueryResult(query, [
+            self.tag1_tag2_bookmarks,
+        ])
+
+        query = queries.query_bookmarks(self.user, self.profile, 'tag1 #tag2')
+        self.assertQueryResult(query, [
+            self.tag1_tag2_bookmarks,
+        ])
+
     def test_query_bookmarks_should_return_no_matches(self):
         self.setup_bookmark_search_data()
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term3')
+        query = queries.query_bookmarks(self.user, self.profile, 'term3')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 term3')
+        query = queries.query_bookmarks(self.user, self.profile, 'term1 term3')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag2')
+        query = queries.query_bookmarks(self.user, self.profile, 'term1 #tag2')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag3')
+        query = queries.query_bookmarks(self.user, self.profile, '#tag3')
         self.assertQueryResult(query, [])
 
         # Unused tag
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#unused_tag1')
+        query = queries.query_bookmarks(self.user, self.profile, '#unused_tag1')
         self.assertQueryResult(query, [])
 
         # Unused tag combined with tag that is used
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #unused_tag1')
+        query = queries.query_bookmarks(self.user, self.profile, '#tag1 #unused_tag1')
         self.assertQueryResult(query, [])
 
         # Unused tag combined with term that is used
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #unused_tag1')
+        query = queries.query_bookmarks(self.user, self.profile, 'term1 #unused_tag1')
         self.assertQueryResult(query, [])
 
     def test_query_bookmarks_should_not_return_archived_bookmarks(self):
@@ -225,7 +292,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True)
         self.setup_bookmark(is_archived=True)
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '')
+        query = queries.query_bookmarks(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[bookmark1, bookmark2]])
 
@@ -236,7 +303,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark()
 
-        query = queries.query_archived_bookmarks(self.get_or_create_test_user(), '')
+        query = queries.query_archived_bookmarks(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[bookmark1, bookmark2]])
 
@@ -251,7 +318,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(user=other_user)
         self.setup_bookmark(user=other_user)
 
-        query = queries.query_bookmarks(self.user, '')
+        query = queries.query_bookmarks(self.user, self.profile, '')
 
         self.assertQueryResult(query, [owned_bookmarks])
 
@@ -266,7 +333,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, user=other_user)
         self.setup_bookmark(is_archived=True, user=other_user)
 
-        query = queries.query_archived_bookmarks(self.user, '')
+        query = queries.query_archived_bookmarks(self.user, self.profile, '')
 
         self.assertQueryResult(query, [owned_bookmarks])
 
@@ -276,7 +343,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(tags=[tag])
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmarks(self.user, '!untagged')
+        query = queries.query_bookmarks(self.user, self.profile, '!untagged')
         self.assertCountEqual(list(query), [untagged_bookmark])
 
     def test_query_bookmarks_untagged_should_be_combinable_with_search_terms(self):
@@ -285,7 +352,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(title='term2')
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmarks(self.user, '!untagged term1')
+        query = queries.query_bookmarks(self.user, self.profile, '!untagged term1')
         self.assertCountEqual(list(query), [untagged_bookmark])
 
     def test_query_bookmarks_untagged_should_not_be_combinable_with_tags(self):
@@ -294,7 +361,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(tags=[tag])
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmarks(self.user, f'!untagged #{tag.name}')
+        query = queries.query_bookmarks(self.user, self.profile, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
 
     def test_query_archived_bookmarks_untagged_should_return_untagged_bookmarks_only(self):
@@ -303,7 +370,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, tags=[tag])
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmarks(self.user, '!untagged')
+        query = queries.query_archived_bookmarks(self.user, self.profile, '!untagged')
         self.assertCountEqual(list(query), [untagged_bookmark])
 
     def test_query_archived_bookmarks_untagged_should_be_combinable_with_search_terms(self):
@@ -312,7 +379,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, title='term2')
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmarks(self.user, '!untagged term1')
+        query = queries.query_archived_bookmarks(self.user, self.profile, '!untagged term1')
         self.assertCountEqual(list(query), [untagged_bookmark])
 
     def test_query_archived_bookmarks_untagged_should_not_be_combinable_with_tags(self):
@@ -321,7 +388,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, tags=[tag])
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmarks(self.user, f'!untagged #{tag.name}')
+        query = queries.query_archived_bookmarks(self.user, self.profile, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
 
     def test_query_bookmarks_unread_should_return_unread_bookmarks_only(self):
@@ -334,7 +401,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark()
 
-        query = queries.query_bookmarks(self.user, '!unread')
+        query = queries.query_bookmarks(self.user, self.profile, '!unread')
         self.assertCountEqual(list(query), unread_bookmarks)
 
     def test_query_archived_bookmarks_unread_should_return_unread_bookmarks_only(self):
@@ -347,13 +414,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True)
         self.setup_bookmark(is_archived=True)
 
-        query = queries.query_archived_bookmarks(self.user, '!unread')
+        query = queries.query_archived_bookmarks(self.user, self.profile, '!unread')
         self.assertCountEqual(list(query), unread_bookmarks)
 
     def test_query_bookmark_tags_should_return_all_tags_for_empty_query(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, '')
+        query = queries.query_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.other_bookmarks),
@@ -368,7 +435,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_single_term(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, 'term1')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term1')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.term1_bookmarks),
@@ -379,7 +446,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_multiple_terms(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, 'term2 term1')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term2 term1')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
@@ -388,7 +455,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_single_tag(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, '#tag1')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#tag1')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.tag1_bookmarks),
@@ -399,7 +466,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_multiple_tags(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, '#tag1 #tag2')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#tag1 #tag2')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
@@ -408,7 +475,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_multiple_tags_ignoring_casing(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, '#Tag1 #TAG2')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#Tag1 #TAG2')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
@@ -417,37 +484,75 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
     def test_query_bookmark_tags_should_search_term_and_tag_combined(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.user, 'term1 #tag1')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term1 #tag1')
 
         self.assertQueryResult(query, [
             self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
         ])
 
+    def test_query_bookmark_tags_in_strict_mode_should_not_search_tags_as_terms(self):
+        self.setup_tag_search_data()
+
+        self.profile.tag_search = UserProfile.TAG_SEARCH_STRICT
+        self.profile.save()
+
+        query = queries.query_bookmark_tags(self.user, self.profile, 'tag1')
+        self.assertQueryResult(query, self.get_tags_from_bookmarks(self.tag1_as_term_bookmarks))
+
+    def test_query_bookmark_tags_in_lax_mode_should_search_tags_as_terms(self):
+        self.setup_tag_search_data()
+
+        self.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.profile.save()
+
+        query = queries.query_bookmark_tags(self.user, self.profile, 'tag1')
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_bookmarks),
+            self.get_tags_from_bookmarks(self.tag1_as_term_bookmarks),
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks)
+        ])
+
+        query = queries.query_bookmark_tags(self.user, self.profile, 'tag1 term1')
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
+        ])
+
+        query = queries.query_bookmark_tags(self.user, self.profile, 'tag1 tag2')
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
+        query = queries.query_bookmark_tags(self.user, self.profile, 'tag1 #tag2')
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
     def test_query_bookmark_tags_should_return_no_matches(self):
         self.setup_tag_search_data()
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term3')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term3')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 term3')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term1 term3')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #tag2')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term1 #tag2')
         self.assertQueryResult(query, [])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag3')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#tag3')
         self.assertQueryResult(query, [])
 
         # Unused tag
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#unused_tag1')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#unused_tag1')
         self.assertQueryResult(query, [])
 
         # Unused tag combined with tag that is used
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag1 #unused_tag1')
+        query = queries.query_bookmark_tags(self.user, self.profile, '#tag1 #unused_tag1')
         self.assertQueryResult(query, [])
 
         # Unused tag combined with term that is used
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #unused_tag1')
+        query = queries.query_bookmark_tags(self.user, self.profile, 'term1 #unused_tag1')
         self.assertQueryResult(query, [])
 
     def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
@@ -457,7 +562,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark(is_archived=True, tags=[tag2])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[tag1]])
 
@@ -467,7 +572,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(tags=[tag])
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[tag]])
 
@@ -478,7 +583,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark(is_archived=True, tags=[tag2])
 
-        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[tag2]])
 
@@ -488,7 +593,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, tags=[tag])
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [[tag]])
 
@@ -503,7 +608,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
         self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
 
-        query = queries.query_bookmark_tags(self.user, '')
+        query = queries.query_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
 
@@ -518,7 +623,7 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
         self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
 
-        query = queries.query_archived_bookmark_tags(self.user, '')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, '')
 
         self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
 
@@ -529,13 +634,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(title='term1', tags=[tag])
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmark_tags(self.user, '!untagged')
+        query = queries.query_bookmark_tags(self.user, self.profile, '!untagged')
         self.assertCountEqual(list(query), [])
 
-        query = queries.query_bookmark_tags(self.user, '!untagged term1')
+        query = queries.query_bookmark_tags(self.user, self.profile, '!untagged term1')
         self.assertCountEqual(list(query), [])
 
-        query = queries.query_bookmark_tags(self.user, f'!untagged #{tag.name}')
+        query = queries.query_bookmark_tags(self.user, self.profile, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
 
     def test_query_archived_bookmark_tags_untagged_should_never_return_any_tags(self):
@@ -545,13 +650,13 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, title='term1', tags=[tag])
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmark_tags(self.user, '!untagged')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, '!untagged')
         self.assertCountEqual(list(query), [])
 
-        query = queries.query_archived_bookmark_tags(self.user, '!untagged term1')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, '!untagged term1')
         self.assertCountEqual(list(query), [])
 
-        query = queries.query_archived_bookmark_tags(self.user, f'!untagged #{tag.name}')
+        query = queries.query_archived_bookmark_tags(self.user, self.profile, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
 
     def test_query_shared_bookmarks(self):
@@ -574,16 +679,26 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(user=user4, shared=True, tags=[tag]),
 
         # Should return shared bookmarks from all users
-        query_set = queries.query_shared_bookmarks(None, '')
+        query_set = queries.query_shared_bookmarks(None, self.profile, '', False)
         self.assertQueryResult(query_set, [shared_bookmarks])
 
         # Should respect search query
-        query_set = queries.query_shared_bookmarks(None, 'test title')
+        query_set = queries.query_shared_bookmarks(None, self.profile, 'test title', False)
         self.assertQueryResult(query_set, [[shared_bookmarks[0]]])
 
-        query_set = queries.query_shared_bookmarks(None, '#' + tag.name)
+        query_set = queries.query_shared_bookmarks(None, self.profile, '#' + tag.name, False)
         self.assertQueryResult(query_set, [[shared_bookmarks[2]]])
 
+    def test_query_publicly_shared_bookmarks(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        bookmark1 = self.setup_bookmark(user=user1, shared=True)
+        self.setup_bookmark(user=user2, shared=True)
+
+        query_set = queries.query_shared_bookmarks(None, self.profile, '', True)
+        self.assertQueryResult(query_set, [[bookmark1]])
+
     def test_query_shared_bookmark_tags(self):
         user1 = self.setup_user(enable_sharing=True)
         user2 = self.setup_user(enable_sharing=True)
@@ -605,10 +720,24 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(user=user3, shared=False, tags=[self.setup_tag(user=user3)]),
         self.setup_bookmark(user=user4, shared=True, tags=[self.setup_tag(user=user4)]),
 
-        query_set = queries.query_shared_bookmark_tags(None, '')
+        query_set = queries.query_shared_bookmark_tags(None, self.profile, '', False)
 
         self.assertQueryResult(query_set, [shared_tags])
 
+    def test_query_publicly_shared_bookmark_tags(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        tag1 = self.setup_tag(user=user1)
+        tag2 = self.setup_tag(user=user2)
+
+        self.setup_bookmark(user=user1, shared=True, tags=[tag1]),
+        self.setup_bookmark(user=user2, shared=True, tags=[tag2]),
+
+        query_set = queries.query_shared_bookmark_tags(None, self.profile, '', True)
+
+        self.assertQueryResult(query_set, [[tag1]])
+
     def test_query_shared_bookmark_users(self):
         users_with_shared_bookmarks = [
             self.setup_user(enable_sharing=True),
@@ -630,9 +759,19 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(user=users_without_shared_bookmarks[2], shared=True),
 
         # Should return users with shared bookmarks
-        query_set = queries.query_shared_bookmark_users('')
+        query_set = queries.query_shared_bookmark_users(self.profile, '', False)
         self.assertQueryResult(query_set, [users_with_shared_bookmarks])
 
         # Should respect search query
-        query_set = queries.query_shared_bookmark_users('test title')
+        query_set = queries.query_shared_bookmark_users(self.profile, 'test title', False)
         self.assertQueryResult(query_set, [[users_with_shared_bookmarks[0]]])
+
+    def test_query_publicly_shared_bookmark_users(self):
+        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+
+        self.setup_bookmark(user=user1, shared=True)
+        self.setup_bookmark(user=user2, shared=True)
+
+        query_set = queries.query_shared_bookmark_users(self.profile, '', True)
+        self.assertQueryResult(query_set, [[user1]])

bookmarks/tests/test_settings_general_view.py

@@ -27,7 +27,11 @@ class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
             'bookmark_link_target': UserProfile.BOOKMARK_LINK_TARGET_BLANK,
             'web_archive_integration': UserProfile.WEB_ARCHIVE_INTEGRATION_DISABLED,
             'enable_sharing': False,
+            'enable_public_sharing': False,
             'enable_favicons': False,
+            'tag_search': UserProfile.TAG_SEARCH_STRICT,
+            'display_url': False,
+            'permanent_notes': False,
         }
 
         return {**form_data, **overrides}
@@ -51,7 +55,11 @@ class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
             'bookmark_link_target': UserProfile.BOOKMARK_LINK_TARGET_SELF,
             'web_archive_integration': UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED,
             'enable_sharing': True,
+            'enable_public_sharing': True,
             'enable_favicons': True,
+            'tag_search': UserProfile.TAG_SEARCH_LAX,
+            'display_url': True,
+            'permanent_notes': True,
         }
         response = self.client.post(reverse('bookmarks:settings.general'), form_data)
         html = response.content.decode()
@@ -64,7 +72,11 @@ class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(self.user.profile.bookmark_link_target, form_data['bookmark_link_target'])
         self.assertEqual(self.user.profile.web_archive_integration, form_data['web_archive_integration'])
         self.assertEqual(self.user.profile.enable_sharing, form_data['enable_sharing'])
+        self.assertEqual(self.user.profile.enable_public_sharing, form_data['enable_public_sharing'])
         self.assertEqual(self.user.profile.enable_favicons, form_data['enable_favicons'])
+        self.assertEqual(self.user.profile.tag_search, form_data['tag_search'])
+        self.assertEqual(self.user.profile.display_url, form_data['display_url'])
+        self.assertEqual(self.user.profile.permanent_notes, form_data['permanent_notes'])
         self.assertInHTML('''
                 <p class="form-input-hint">Profile updated</p>
             ''', html)

bookmarks/tests/test_settings_import_view.py

@@ -1,6 +1,7 @@
 from django.test import TestCase
 from django.urls import reverse
 
+from bookmarks.models import Bookmark
 from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
 
 
@@ -77,3 +78,30 @@ class SettingsImportViewTestCase(TestCase, BookmarkFactoryMixin):
             self.assertRedirects(response, reverse('bookmarks:settings.general'))
             self.assertFormSuccessHint(response, '2 bookmarks were successfully imported')
             self.assertFormErrorHint(response, '1 bookmarks could not be imported')
+
+    def test_should_respect_map_private_flag_option(self):
+        with open('bookmarks/tests/resources/simple_valid_import_file.html') as import_file:
+            self.client.post(
+                reverse('bookmarks:settings.import'),
+                {'import_file': import_file},
+                follow=True
+            )
+
+            self.assertEqual(Bookmark.objects.count(), 3)
+            self.assertEqual(Bookmark.objects.all()[0].shared, False)
+            self.assertEqual(Bookmark.objects.all()[1].shared, False)
+            self.assertEqual(Bookmark.objects.all()[2].shared, False)
+
+        Bookmark.objects.all().delete()
+
+        with open('bookmarks/tests/resources/simple_valid_import_file.html') as import_file:
+            self.client.post(
+                reverse('bookmarks:settings.import'),
+                {'import_file': import_file, 'map_private_flag': 'on'},
+                follow=True
+            )
+
+            self.assertEqual(Bookmark.objects.count(), 3)
+            self.assertEqual(Bookmark.objects.all()[0].shared, True)
+            self.assertEqual(Bookmark.objects.all()[1].shared, True)
+            self.assertEqual(Bookmark.objects.all()[2].shared, True)

bookmarks/tests/test_tag_cloud_tag.py

@@ -1,180 +0,0 @@
-from typing import List
-
-from django.template import Template, RequestContext
-from django.test import TestCase, RequestFactory
-
-from bookmarks.models import Tag
-from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
-
-
-class TagCloudTagTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
-    def render_template(self, tags: List[Tag], selected_tags: List[Tag] = None, url: str = '/test'):
-        if not selected_tags:
-            selected_tags = []
-
-        rf = RequestFactory()
-        request = rf.get(url)
-        context = RequestContext(request, {
-            'request': request,
-            'tags': tags,
-            'selected_tags': selected_tags,
-        })
-        template_to_render = Template(
-            '{% load bookmarks %}'
-            '{% tag_cloud tags selected_tags %}'
-        )
-        return template_to_render.render(context)
-
-    def assertTagGroups(self, rendered_template: str, groups: List[List[str]]):
-        soup = self.make_soup(rendered_template)
-        group_elements = soup.select('p.group')
-
-        self.assertEqual(len(group_elements), len(groups))
-
-        for group_index, tags in enumerate(groups, start=0):
-            group_element = group_elements[group_index]
-            link_elements = group_element.select('a')
-
-            self.assertEqual(len(link_elements), len(tags))
-
-            for tag_index, tag in enumerate(tags, start=0):
-                link_element = link_elements[tag_index]
-                self.assertEqual(link_element.text.strip(), tag)
-
-    def assertNumSelectedTags(self, rendered_template: str, count: int):
-        soup = self.make_soup(rendered_template)
-        link_elements = soup.select('p.selected-tags a')
-        self.assertEqual(len(link_elements), count)
-
-    def test_group_alphabetically(self):
-        tags = [
-            self.setup_tag(name='Cockatoo'),
-            self.setup_tag(name='Badger'),
-            self.setup_tag(name='Buffalo'),
-            self.setup_tag(name='Chihuahua'),
-            self.setup_tag(name='Alpaca'),
-            self.setup_tag(name='Coyote'),
-            self.setup_tag(name='Aardvark'),
-            self.setup_tag(name='Bumblebee'),
-            self.setup_tag(name='Armadillo'),
-        ]
-
-        rendered_template = self.render_template(tags)
-
-        self.assertTagGroups(rendered_template, [
-            [
-                'Aardvark',
-                'Alpaca',
-                'Armadillo',
-            ],
-            [
-                'Badger',
-                'Buffalo',
-                'Bumblebee',
-            ],
-            [
-                'Chihuahua',
-                'Cockatoo',
-                'Coyote',
-            ],
-        ])
-
-    def test_no_duplicate_tag_names(self):
-        tags = [
-            self.setup_tag(name='shared', user=self.setup_user()),
-            self.setup_tag(name='shared', user=self.setup_user()),
-            self.setup_tag(name='shared', user=self.setup_user()),
-        ]
-
-        rendered_template = self.render_template(tags)
-
-        self.assertTagGroups(rendered_template, [
-            [
-                'shared',
-            ],
-        ])
-
-    def test_selected_tags(self):
-        tags = [
-            self.setup_tag(name='tag1'),
-            self.setup_tag(name='tag2'),
-        ]
-
-        rendered_template = self.render_template(tags, tags, url='/test?q=%23tag1 %23tag2')
-
-        self.assertNumSelectedTags(rendered_template, 2)
-
-        self.assertInHTML('''
-            <a href="?q=%23tag2"
-               class="text-bold mr-2">
-                <span>-tag1</span>
-            </a>
-        ''', rendered_template)
-
-        self.assertInHTML('''
-            <a href="?q=%23tag1"
-               class="text-bold mr-2">
-                <span>-tag2</span>
-            </a>
-        ''', rendered_template)
-
-    def test_selected_tags_ignore_casing_when_removing_query_part(self):
-        tags = [
-            self.setup_tag(name='TEST'),
-        ]
-
-        rendered_template = self.render_template(tags, tags, url='/test?q=%23test')
-
-        self.assertInHTML('''
-            <a href="?q="
-               class="text-bold mr-2">
-                <span>-TEST</span>
-            </a>
-        ''', rendered_template)
-
-    def test_no_duplicate_selected_tags(self):
-        tags = [
-            self.setup_tag(name='shared', user=self.setup_user()),
-            self.setup_tag(name='shared', user=self.setup_user()),
-            self.setup_tag(name='shared', user=self.setup_user()),
-        ]
-
-        rendered_template = self.render_template(tags, tags, url='/test?q=%23shared')
-
-        self.assertInHTML('''
-            <a href="?q="
-               class="text-bold mr-2">
-                <span>-shared</span>
-            </a>
-        ''', rendered_template, count=1)
-
-    def test_selected_tag_url_keeps_other_search_terms(self):
-        tag = self.setup_tag(name='tag1')
-
-        rendered_template = self.render_template([tag], [tag], url='/test?q=term1 %23tag1 term2 %21untagged')
-
-        self.assertInHTML('''
-            <a href="?q=term1+term2+%21untagged"
-               class="text-bold mr-2">
-                <span>-tag1</span>
-            </a>
-        ''', rendered_template)
-
-    def test_selected_tags_are_excluded_from_groups(self):
-        tags = [
-            self.setup_tag(name='tag1'),
-            self.setup_tag(name='tag2'),
-            self.setup_tag(name='tag3'),
-            self.setup_tag(name='tag4'),
-            self.setup_tag(name='tag5'),
-        ]
-        selected_tags = [
-            tags[0],
-            tags[1],
-        ]
-
-        rendered_template = self.render_template(tags, selected_tags)
-
-        self.assertTagGroups(rendered_template, [
-            ['tag3', 'tag4', 'tag5']
-        ])