+15 -11

.builds/arch.yml

··· 2 2 sources: 3 3 - https://git.sr.ht/~pvsr/qbpm 4 4 - https://aur.archlinux.org/python-xdg-base-dirs.git 5 5 + - https://aur.archlinux.org/python-dacite.git 5 6 packages: 7 7 + - ruff 8 8 + - mypy 6 9 - python-pytest 7 10 tasks: 8 8 - - pytest: | 9 9 - cd qbpm 10 10 - pytest tests 11 11 - - xdg-base-dirs: | 12 12 - cd python-xdg-base-dirs 13 13 - makepkg -si --noconfirm 14 14 - - makepkg: | 15 15 - cd qbpm/contrib 16 16 - sed -i 's|^source.*|source=("git+file:///home/build/qbpm")|' PKGBUILD 17 17 - sudo pacman -Sy 18 18 - makepkg -si --noconfirm 11 11 + - format: ruff format --check qbpm 12 12 + - lint: ruff check qbpm 13 13 + - deps: | 14 14 + makepkg -si --noconfirm --dir python-xdg-base-dirs 15 15 + makepkg -si --noconfirm --dir python-dacite 16 16 + mkdir build 17 17 + cp qbpm/contrib/PKGBUILD build 18 18 + sed -i 's|^source.*|source=("git+file:///home/build/qbpm")|' build/PKGBUILD 19 19 + makepkg -s --noconfirm --dir build 20 20 + - types: mypy qbpm 21 21 + - tests: pytest qbpm/tests 22 22 + - install: makepkg -i --noconfirm --noextract --dir build 19 23 - run: | 20 24 mkdir -p ~/.config/qutebrowser 21 25 touch ~/.config/qutebrowser/config.py

+7 -6

.builds/nix.yml

··· 4 4 environment: 5 5 NIX_CONFIG: "experimental-features = nix-command flakes" 6 6 tasks: 7 7 - - check: | 8 8 - cd qbpm 9 9 - nix flake check --quiet 10 10 - - build: | 11 11 - cd qbpm 12 12 - nix build --quiet 7 7 + - build: nix build ./qbpm 8 8 + - install: nix profile install ./qbpm 9 9 + - run: | 10 10 + mkdir -p ~/.config/qutebrowser 11 11 + touch ~/.config/qutebrowser/config.py 12 12 + qbpm new profile 13 13 + qbpm list | grep profile

+1

.gitignore

··· 15 15 .direnv/ 16 16 .pre-commit-config.yaml 17 17 profiles/ 18 18 + .coverage

+59 -6

CHANGELOG.md

··· 1 1 + # 2.4 2 2 + - `qbpm choose`: an entry named `qutebrowser` that launches qutebrowser without a profile will no longer be included by default. Set `qutebrowser_in_choose = true` in `config.toml` to restore it 3 3 + - `config_py_template` is no longer required to be set if `config.toml` exists 4 4 + - if `config_py_template` is set to an empty string, no `config.py` will be generated 5 5 + 6 6 + # 2.3 7 7 + - new profiles will have a symlink to `$XDG_DATA_HOME/qutebrowser/qtwebengine_dictionaries` and thus have access to any spellchecking dictionaries have been installed for the main qutebrowser profile 8 8 + - `qbpm config` now has a `--help` flag 9 9 + 10 10 + # ~2.1~ 2.2 11 11 + - `config.toml` supports `application_name` for generated XDG desktop files 12 12 + - defaults to `{profile_name} (qutebrowser profile)`, you may want just `{profile_name}` 13 13 + - `qbpm desktop` can be used to replace existing desktop files 14 14 + - bumped to 2.2 because I pushed a 2.1 tag prematurely 15 15 + 16 16 + # 2.0 17 17 + ## config 18 18 + qbpm now reads configuration options from `$XDG_CONFIG_HOME/qbpm/config.toml`! 19 19 + - to install the default config file: 20 20 + - run `qbpm config path` and confirm that it prints out a path 21 21 + - run `qbpm config default > "$(qbpm config path)"` 22 22 + - supported configuration options: 23 23 + - `config_py_template`: control the contents of `config.py` in new profiles 24 24 + - `symlink_autoconfig`: symlink qutebrowser's `autoconfig.yml` in new profiles 25 25 + - `profile_directory` and `qutebrowser_config_directory` 26 26 + - equivalent to `--profile-dir` and `--qutebrowser-config-dir` 27 27 + - `generate_desktop_file` and `desktop_file_directory` 28 28 + - whether to generate XDG desktop entries for new profiles and where to put them 29 29 + - `menu`: equivalent to `--menu` for `qbpm choose` 30 30 + - `menu_prompt`: prompt shown in most menus 31 31 + - see default config file for more detailed documentation 32 32 + 33 33 + ## other 34 34 + - support for symlinking `autoconfig.yml` in addition to or instead of sourcing `config.py` 35 35 + - `qbpm new --overwrite`: back up existing config files by moving to e.g. `config.py.bak` 36 36 + - `contrib/qbpm.desktop`: add `MimeType` and `Keywords`, fix incorrect formatting of `Categories` 37 37 + - allow help text to be slightly wider to avoid awkward line breaks 38 38 + - macOS: fix detection of qutebrowser binary in `/Applications` 39 39 + 1 40 # 1.0rc4 2 2 - - built in support for more wayland menus: 3 3 - - walker 4 4 - - tofi 5 5 - - wmenu 41 41 + - `choose`: support `walker`, `tofi`, and `wmenu` 42 42 + - better detection of invalid/nonexistent profiles 6 43 7 44 # 1.0rc3 8 45 - breaking: stop sourcing files from `~/.config/qutebrowser/conf.d/` ··· 17 54 - make generated `.desktop` files match qutebrowser's more closely 18 55 19 56 # 1.0rc2: 20 20 - - `choose`: builtin support for `fzf` and `fuzzel` 21 21 - - moved argument handling to click 57 57 + - `choose`: support `fzf` and `fuzzel` 58 58 + - use `click `for CLI parsing 22 59 - `qbpm launch`'s `-n`/`--new` renamed to `-c`/`--create` 60 60 + - expand fish shell completions 61 61 + 62 62 + # 1.0rc1: 63 63 + - add a man page 64 64 + 65 65 + # 0.6 66 66 + - better error handling 67 67 + 68 68 + # 0.5 69 69 + - `choose`: support custom menu command 70 70 + - `choose`: support `dmenu-wl` and `wofi` 71 71 + 72 72 + # 0.4 73 73 + - `choose` subcommand (thanks, @mtoohey31!) 74 74 + - load autoconfig.yml by default 75 75 + - shell completions for fish

+25 -31

README.md

··· 1 1 # qutebrowser profile manager 2 2 3 3 [](https://builds.sr.ht/~pvsr/qbpm/commits/main?) 4 4 + [](https://pypi.python.org/pypi/qbpm) 4 5 5 6 qbpm (qutebrowser profile manager) is a tool for creating, managing, and running 6 7 [qutebrowser](https://github.com/qutebrowser/qutebrowser) profiles. Profile support ··· 18 19 instances of qutebrowser which can be opened and closed independently. 19 20 20 21 ## Usage 21 21 - Create a new profile called "python", edit its `config.py`, then launch it: 22 22 + To create a new profile called "python" and launch it with the python docs open: 22 23 ``` 23 24 $ qbpm new python 24 24 - $ qbpm edit python 25 25 $ qbpm launch python docs.python.org 26 26 - $ qbpm choose # run dmenu or another launcher to pick a profile 27 26 ``` 28 27 29 29 - `qbpm from-session` can copy the tabs of a [saved qutebrowser 30 30 - session](https://qutebrowser.org/doc/help/commands.html#session-save) to a new 31 31 - profile. If you have a window full of tabs related to planning a vacation, you 32 32 - could save it to a session called "vacation" using `:session-save -o vacation` 33 33 - in qutebrowser, then create a new profile with those tabs: 34 34 - ``` 35 35 - $ qbpm from-session vacation 36 36 - ``` 28 28 + Note that all arguments after `qbpm launch PROFILE` are passed to qutebrowser, 29 29 + so options can be passed too: `qbpm launch python --target window pypi.org`. 37 30 38 38 - The default profile directory is `$XDG_DATA_HOME/qutebrowser-profiles`, where 39 39 - `$XDG_DATA_HOME` is usually `~/.local/share`, but you can create and launch 40 40 - profiles from anywhere using `--profile-dir`/`-P`: 41 41 - ``` 42 42 - $ qbpm --profile-dir ~/dev/my-project new qb-profile 43 43 - $ cd ~/dev/my-project 44 44 - $ qbpm -P . launch qb-profile 45 45 - # or 46 46 - $ qutebrowser --basedir qb-profile 47 47 - ``` 31 31 + If you have multiple profiles you can use `qbpm choose` to bring up a list of 32 32 + profiles and select one to launch. Depending on what your system has available 33 33 + the menu may be `dmenu`, `fuzzel`, `fzf`, an applescript dialog, or one of many 34 34 + other menu programs qbpm can detect. Any dmenu-compatible menu can be used with 35 35 + `--menu`, e.g. `qbpm choose --menu 'fuzzel --dmenu'`. As with `qbpm launch`, 36 36 + extra arguments are passed to qutebrowser. 37 37 + 38 38 + Run `qbpm --help` to see other available commands. 39 39 + 40 40 + By default when you create a new profile a `.desktop` file is created that 41 41 + launches the profile. This launcher does not depend on qbpm at all, so if you 42 42 + want you can run `qbpm new` once and keep using the profile without needing 43 43 + qbpm installed on your system. 48 44 49 45 ## Installation 50 46 If you use Nix, you can install or run qbpm as a [Nix flake](https://nixos.wiki/wiki/Flakes). ··· 52 48 53 49 On Arch and derivatives, you can install the AUR package: [qbpm-git](https://aur.archlinux.org/packages/qbpm-git). 54 50 55 55 - Otherwise you'll need to install from source, directly or using a tool like [uv](https://docs.astral.sh/uv/guides/tools/). 56 56 - Using uv you can run qbpm without installing it using 57 57 - `uv tool run --with git+https://github.com/pvsr/qbpm qbpm`, or install to `~/.local/bin` with 58 58 - `uv tool install --with git+https://github.com/pvsr/qbpm qbpm`. 59 59 - The downside of a source installation is that the [man page](https://github.com/pvsr/qbpm/blob/main/qbpm.1.scd) 51 51 + Otherwise you can install directly from PyPI using [uv](https://docs.astral.sh/uv/guides/tools/), 52 52 + pip, or your preferred client. With uv it's `uv tool run qbpm` to run qbpm 53 53 + without installing and `uv tool install qbpm` to install to `~/.local/bin`. 54 54 + The downside of going through PyPI is that the [man page](https://github.com/pvsr/qbpm/blob/main/qbpm.1.scd) 60 55 and shell completions will not be installed automatically. 61 56 62 57 On Linux you can copy [`contrib/qbpm.desktop`](https://raw.githubusercontent.com/pvsr/qbpm/main/contrib/qbpm.desktop) ··· 66 61 ### MacOS 67 62 68 63 Nix and uv will install qbpm as a command-line application, but if you want a 69 69 - native Mac application you can clone this repository or copy the contents of 70 70 - [`contrib/qbpm.platypus`](https://raw.githubusercontent.com/pvsr/qbpm/main/contrib/qbpm.platypus) 71 71 - to a local file, install [platypus](https://sveinbjorn.org/platypus), 72 72 - and create a qbpm app by running `platypus -P qbpm.platypus /Applications/qbpm.app`. 73 73 - That will also make qbpm available as a default browser in `System Preferences > General > Default web browser`. 64 64 + native Mac application you can download [`contrib/qbpm.platypus`](https://raw.githubusercontent.com/pvsr/qbpm/main/contrib/qbpm.platypus), 65 65 + install [platypus](https://sveinbjorn.org/platypus), and create a qbpm app with 66 66 + `platypus -P qbpm.platypus /Applications/qbpm.app`. That will also make qbpm 67 67 + available as a default browser in `System Preferences > General > Default web browser`. 74 68 75 69 Note that there is currently [a qutebrowser bug](https://github.com/qutebrowser/qutebrowser/issues/3719) 76 70 that results in unnecessary `file:///*` tabs being opened.

+3 -3

contrib/PKGBUILD

··· 1 1 # Maintainer: Peter Rice <{first name}@peterrice.xyz> 2 2 3 3 pkgname=qbpm-git 4 4 - pkgver=1.0.rc2.r1 4 4 + pkgver=2.0.r5 5 5 pkgrel=1 6 6 pkgdesc="A profile manager for qutebrowser" 7 7 url="https://github.com/pvsr/qbpm" 8 8 - license=('GPL') 8 8 + license=('GPL-3.0-or-later') 9 9 sha512sums=('SKIP') 10 10 arch=('any') 11 11 - depends=('python' 'python-click' 'python-xdg-base-dirs') 11 11 + depends=('python' 'python-click' 'python-xdg-base-dirs' 'python-dacite') 12 12 makedepends=('git' 'python-build' 'python-installer' 'python-wheel' 'python-flit-core' 'scdoc') 13 13 provides=('qbpm') 14 14 source=("git+https://github.com/pvsr/qbpm")

+5 -3

contrib/qbpm.desktop

··· 1 1 [Desktop Entry] 2 2 - Type=Application 3 2 Name=qbpm 4 3 Icon=qutebrowser 5 5 - Exec=qbpm choose %u 6 6 - Categories=['Network'] 4 4 + Type=Application 5 5 + Categories=Network;WebBrowser; 6 6 + Exec=qbpm choose --untrusted-args %u 7 7 Terminal=False 8 8 StartupNotify=True 9 9 + MimeType=text/html;text/xml;application/xhtml+xml;application/xml;application/rdf+xml;image/gif;image/webp;image/jpeg;image/png;x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/qute; 10 10 + Keywords=Browser

+6 -40

flake.lock

··· 1 1 { 2 2 "nodes": { 3 3 - "flake-utils": { 4 4 - "inputs": { 5 5 - "systems": "systems" 6 6 - }, 7 7 - "locked": { 8 8 - "lastModified": 1731533236, 9 9 - "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", 10 10 - "owner": "numtide", 11 11 - "repo": "flake-utils", 12 12 - "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", 13 13 - "type": "github" 14 14 - }, 15 15 - "original": { 16 16 - "owner": "numtide", 17 17 - "repo": "flake-utils", 18 18 - "type": "github" 19 19 - } 20 20 - }, 21 3 "nixpkgs": { 22 4 "locked": { 23 23 - "lastModified": 1748929857, 24 24 - "narHash": "sha256-lcZQ8RhsmhsK8u7LIFsJhsLh/pzR9yZ8yqpTzyGdj+Q=", 5 5 + "lastModified": 1752950548, 6 6 + "narHash": "sha256-NS6BLD0lxOrnCiEOcvQCDVPXafX1/ek1dfJHX1nUIzc=", 25 7 "owner": "nixos", 26 8 "repo": "nixpkgs", 27 27 - "rev": "c2a03962b8e24e669fb37b7df10e7c79531ff1a4", 9 9 + "rev": "c87b95e25065c028d31a94f06a62927d18763fdf", 28 10 "type": "github" 29 11 }, 30 12 "original": { ··· 41 23 ] 42 24 }, 43 25 "locked": { 44 44 - "lastModified": 1743085397, 45 45 - "narHash": "sha256-mCJgxAltNx9uzYTpaSNr6yQtDMXnRykXL87L2bLmsPo=", 26 26 + "lastModified": 1753063596, 27 27 + "narHash": "sha256-el1vFxDk6DR2hKGYnMfQHR7+K4aMiJDKQRMP3gdh+ZI=", 46 28 "owner": "nix-community", 47 29 "repo": "pyproject.nix", 48 48 - "rev": "af4c3ccf8cffcd49626b0455defb0f6b22cc1910", 30 30 + "rev": "cac90713492f23be5f1072bae88406890b9c68f6", 49 31 "type": "github" 50 32 }, 51 33 "original": { ··· 56 38 }, 57 39 "root": { 58 40 "inputs": { 59 59 - "flake-utils": "flake-utils", 60 41 "nixpkgs": "nixpkgs", 61 42 "pyproject-nix": "pyproject-nix" 62 62 - } 63 63 - }, 64 64 - "systems": { 65 65 - "locked": { 66 66 - "lastModified": 1681028828, 67 67 - "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", 68 68 - "owner": "nix-systems", 69 69 - "repo": "default", 70 70 - "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", 71 71 - "type": "github" 72 72 - }, 73 73 - "original": { 74 74 - "owner": "nix-systems", 75 75 - "repo": "default", 76 76 - "type": "github" 77 43 } 78 44 } 79 45 },

+59 -46

flake.nix

··· 1 1 { 2 2 - description = "Tool for creating, managing, and running qutebrowser profiles"; 2 2 + description = "A profile manager for qutebrowser"; 3 3 4 4 inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable"; 5 5 inputs.pyproject-nix.url = "github:nix-community/pyproject.nix"; 6 6 inputs.pyproject-nix.inputs.nixpkgs.follows = "nixpkgs"; 7 7 - inputs.flake-utils.url = "github:numtide/flake-utils"; 8 7 9 8 outputs = 10 9 { 11 10 self, 12 11 nixpkgs, 13 12 pyproject-nix, 14 14 - flake-utils, 15 13 }: 16 16 - flake-utils.lib.eachDefaultSystem ( 17 17 - system: 18 18 - let 19 19 - pkgs = nixpkgs.legacyPackages.${system}; 20 20 - pyproject = pyproject-nix.lib.project.loadPyproject { projectRoot = ./.; }; 21 21 - python = pkgs.python3; 22 22 - pyprojectPackage = 23 23 - args: 24 24 - python.pkgs.buildPythonApplication ( 25 25 - args // pyproject.renderers.buildPythonPackage { inherit python; } 26 26 - ); 27 27 - pyprojectEnv = 28 28 - extraPackages: 29 29 - python.withPackages (pyproject.renderers.withPackages { inherit python extraPackages; }); 30 30 - in 31 31 - { 32 32 - packages.qbpm = pyprojectPackage { 14 14 + let 15 15 + pyproject = pyproject-nix.lib.project.loadPyproject { projectRoot = ./.; }; 16 16 + pyprojectPackage = 17 17 + python: args: 18 18 + python.pkgs.buildPythonApplication ( 19 19 + args // pyproject.renderers.buildPythonPackage { inherit python; } 20 20 + ); 21 21 + pyprojectEnv = 22 22 + python: extraPackages: 23 23 + python.withPackages (pyproject.renderers.withPackages { inherit python extraPackages; }); 24 24 + forAllSystems = 25 25 + mkOutputs: 26 26 + nixpkgs.lib.genAttrs [ 27 27 + "aarch64-linux" 28 28 + "aarch64-darwin" 29 29 + "x86_64-darwin" 30 30 + "x86_64-linux" 31 31 + ] (system: mkOutputs nixpkgs.legacyPackages.${system}); 32 32 + in 33 33 + { 34 34 + packages = forAllSystems (pkgs: { 35 35 + qbpm = pyprojectPackage pkgs.python3 { 33 36 nativeBuildInputs = [ 34 37 pkgs.scdoc 35 38 pkgs.installShellFiles 36 39 ]; 37 37 - nativeCheckInputs = [ python.pkgs.pytestCheckHook ]; 38 38 - doInstallCheck = true; 39 39 - installCheckPhase = "$out/bin/qbpm --help"; 40 40 + nativeCheckInputs = [ pkgs.python3.pkgs.pytestCheckHook ]; 41 41 + postInstallCheck = "$out/bin/qbpm --help"; 40 42 postInstall = '' 41 43 _QBPM_COMPLETE=bash_source $out/bin/qbpm > completions/qbpm.bash 42 44 _QBPM_COMPLETE=zsh_source $out/bin/qbpm > completions/qbpm.zsh ··· 44 46 scdoc < qbpm.1.scd > qbpm.1 45 47 installManPage qbpm.1 46 48 ''; 49 49 + 50 50 + meta = { 51 51 + homepage = "https://github.com/pvsr/qbpm"; 52 52 + changelog = "https://github.com/pvsr/qbpm/blob/main/CHANGELOG.md"; 53 53 + description = "A profile manager for qutebrowser"; 54 54 + license = pkgs.lib.licenses.gpl3Plus; 55 55 + }; 47 56 }; 48 48 - packages.default = self.packages.${system}.qbpm; 49 49 - apps.qbpm = flake-utils.lib.mkApp { drv = self.packages.${system}.qbpm; }; 50 50 - apps.default = self.apps.${system}.qbpm; 57 57 + default = self.packages.${pkgs.system}.qbpm; 58 58 + }); 51 59 52 52 - devShells.default = pkgs.mkShell { 60 60 + apps = forAllSystems (pkgs: { 61 61 + qbpm = { 62 62 + type = "app"; 63 63 + program = pkgs.lib.getExe self.packages.${pkgs.system}.qbpm; 64 64 + }; 65 65 + default = self.apps.${pkgs.system}.qbpm; 66 66 + }); 67 67 + 68 68 + devShells = forAllSystems (pkgs: { 69 69 + default = pkgs.mkShell { 53 70 packages = [ 54 71 pkgs.ruff 55 55 - pkgs.nixfmt-rfc-style 56 56 - (pyprojectEnv ( 57 57 - ps: with ps; [ 58 58 - flit 59 59 - pytest 60 60 - mypy 61 61 - pylsp-mypy 62 62 - ] 63 63 - )) 72 72 + (pyprojectEnv pkgs.python3 (ps: [ 73 73 + ps.flit 74 74 + ps.pytest 75 75 + ps.pytest-cov 76 76 + ps.mypy 77 77 + ps.pylsp-mypy 78 78 + ])) 64 79 ]; 65 80 }; 81 81 + }); 66 82 67 67 - formatter = pkgs.nixfmt-tree.override { 68 68 - runtimeInputs = with pkgs; [ ruff ]; 83 83 + formatter = forAllSystems ( 84 84 + pkgs: 85 85 + pkgs.nixfmt-tree.override { 86 86 + runtimeInputs = [ pkgs.ruff ]; 69 87 settings = { 70 70 - on-unmatched = "info"; 71 88 tree-root-file = "flake.nix"; 72 89 formatter.ruff = { 73 90 command = "ruff"; 74 91 options = [ "format" ]; 75 92 includes = [ "*.py" ]; 76 76 - }; 77 77 - formatter.nixfmt = { 78 78 - command = "nixfmt"; 79 79 - includes = [ "*.nix" ]; 80 93 }; 81 94 }; 82 82 - }; 83 83 - } 84 84 - ); 95 95 + } 96 96 + ); 97 97 + }; 85 98 }

+9 -3

pyproject.toml

··· 1 1 [project] 2 2 name = "qbpm" 3 3 - version = "1.0rc4" 3 3 + version = "2.3" 4 4 description = "qutebrowser profile manager" 5 5 license = "GPL-3.0-or-later" 6 6 license-files = ["LICENSE"] 7 7 readme = "README.md" 8 8 authors = [{ name = "Peter Rice", email = "peter@peterrice.xyz" }] 9 9 classifiers = [ 10 10 - "Development Status :: 4 - Beta", 11 10 "Environment :: Console", 12 11 "Intended Audience :: End Users/Desktop", 13 12 "Operating System :: MacOS", ··· 16 15 "Typing :: Typed", 17 16 ] 18 17 requires-python = ">= 3.11" 19 19 - dependencies = ["click", "xdg-base-dirs"] 18 18 + dependencies = [ 19 19 + "click", 20 20 + "xdg-base-dirs", 21 21 + "dacite", 22 22 + ] 20 23 21 24 [project.urls] 25 25 + homepage = "https://github.com/pvsr/qbpm" 22 26 repository = "https://github.com/pvsr/qbpm" 27 27 + issues = "https://github.com/pvsr/qbpm/issues" 28 28 + changelog = "https://github.com/pvsr/qbpm/blob/main/CHANGELOG.md" 23 29 24 30 [project.scripts] 25 31 qbpm = "qbpm.main:main"

+18 -11

qbpm.1.scd

··· 6 6 7 7 # SYNOPSIS 8 8 9 9 - *qbpm* [--profile-dir=<path>|-P <path>] <command> [<args>] 9 9 + *qbpm* [--profile-dir=<path>|-P <path>] [--config-file|-c <path>] <command> [<args>] 10 10 11 11 # DESCRIPTION 12 12 ··· 30 30 Use _path_ as the profile directory instead of the default location. Takes 31 31 precedence over the QBPM_PROFILE_DIR environment variable. 32 32 33 33 - *-C, --config-dir* 34 34 - Source config files from the provided directory instead of the global 35 35 - qutebrowser config location. 33 33 + *-c, --config-file* <path> 34 34 + Read configuration for qbpm from _path_. Defaults to ~/.config/qbpm/config.toml. 36 35 37 36 # COMMANDS 38 37 ··· 48 47 *-f, --foreground* 49 48 If --launch is set, run qutebrowser in the foreground. 50 49 51 51 - *--no-desktop-file* 52 52 - Do not generate an XDG desktop entry for the profile. Always true on 53 53 - non-linux systems. See https://wiki.archlinux.org/title/Desktop_entries 50 50 + *-C, --qutebrowser-config-dir* <path> 51 51 + Source config files from the provided directory instead of the global 52 52 + qutebrowser config location. 53 53 + 54 54 + *--desktop-file/--no-desktop-file* 55 55 + Whether to generate an XDG desktop entry for the profile. Only relevant 56 56 + on linux systems. See https://wiki.archlinux.org/title/Desktop_entries 54 57 for information on desktop entries. 55 58 56 59 *--overwrite* ··· 58 61 already exists. --overwrite disables this check and replaces the existing 59 62 profile's configuration files. Profile data is left untouched. 60 63 61 61 - *launch* [options] <profile> [argument...] 64 64 + *launch* [options] <profile> [arguments...] 62 65 Start qutebrowser with --basedir set to the location of _profile_. All 63 66 arguments following _profile_ will be passed on to qutebrowser. 64 67 ··· 80 83 qbpm launch -n qb-dev --debug --json-logging 81 84 ``` 82 85 83 83 - *choose* [options] 86 86 + *choose* [options] [arguments...] 84 87 Open a menu to choose a qutebrowser profile to launch. On linux this defaults 85 88 to dmenu or another compatible menu program such as rofi, and on macOS this 86 86 - will be an applescript dialog. 89 89 + will be an applescript dialog. All arguments are passed to qutebrowser. 87 90 88 91 *-m, --menu* <menu> 89 92 Use _menu_ instead of the default menu program. This may be the name of a ··· 126 129 127 130 Peter Rice 128 131 129 129 - Contribute at https://github.com/pvsr/qbpm 132 132 + # CONTRIBUTE 133 133 + 134 134 + _https://github.com/pvsr/qbpm_ 135 135 + 136 136 + _https://codeberg.org/pvsr/qbpm_

+5 -9

src/qbpm/__init__.py

··· 1 1 from pathlib import Path 2 2 - from typing import Optional 3 2 4 3 from .log import error 5 4 from .paths import qutebrowser_exe ··· 20 19 self.profile_dir = profile_dir 21 20 self.root = self.profile_dir / name 22 21 23 23 - def check(self) -> Optional["Profile"]: 24 24 - if "/" in self.name: 25 25 - error("profile name cannot contain slashes") 26 26 - return None 27 27 - return self 28 28 - 29 29 - def exists(self) -> bool: 30 30 - return self.root.exists() and self.root.is_dir() 22 22 + def check_name(self) -> bool: 23 23 + if "/" in self.name or self.name in [".", ".."]: 24 24 + error("profile name cannot be a path") 25 25 + return False 26 26 + return True 31 27 32 28 def cmdline(self) -> list[str]: 33 29 return [

+13 -8

src/qbpm/choose.py

··· 1 1 import subprocess 2 2 - from pathlib import Path 3 2 4 3 from . import Profile 4 4 + from .config import Config 5 5 from .launch import launch_qutebrowser 6 6 from .log import error 7 7 from .menus import find_menu 8 8 9 9 10 10 def choose_profile( 11 11 - profile_dir: Path, menu: str | None, foreground: bool, qb_args: tuple[str, ...] 11 11 + config: Config, 12 12 + foreground: bool, 13 13 + qb_args: tuple[str, ...], 12 14 ) -> bool: 13 13 - dmenu = find_menu(menu) 15 15 + dmenu = find_menu(config.menu) 14 16 if not dmenu: 15 17 return False 16 18 17 17 - real_profiles = {profile.name for profile in profile_dir.iterdir()} 19 19 + real_profiles = {profile.name for profile in config.profile_directory.iterdir()} 18 20 if len(real_profiles) == 0: 19 21 error("no profiles") 20 22 return False 21 21 - profiles = [*real_profiles, "qutebrowser"] 22 22 - command = dmenu.command(sorted(profiles), "qutebrowser", " ".join(qb_args)) 23 23 + profiles = [*real_profiles] 24 24 + include_qb = config.qutebrowser_in_choose and "qutebrowser" not in real_profiles 25 25 + if include_qb: 26 26 + profiles.append("qutebrowser") 27 27 + command = dmenu.command(sorted(profiles), config.menu_prompt, " ".join(qb_args)) 23 28 selection_cmd = subprocess.run( 24 29 command, 25 30 text=True, ··· 31 36 out = selection_cmd.stdout 32 37 selection = out.rstrip("\n") 33 38 34 34 - if selection == "qutebrowser" and "qutebrowser" not in real_profiles: 39 39 + if include_qb and selection == "qutebrowser": 35 40 return launch_qutebrowser(None, foreground, qb_args) 36 41 elif selection: 37 37 - profile = Profile(selection, profile_dir) 42 42 + profile = Profile(selection, config.profile_directory) 38 43 return launch_qutebrowser(profile, foreground, qb_args) 39 44 else: 40 45 error("no profile selected")

+86

src/qbpm/config.py

··· 1 1 + import os 2 2 + import platform 3 3 + import sys 4 4 + import tomllib 5 5 + from dataclasses import dataclass, field, fields 6 6 + from pathlib import Path 7 7 + 8 8 + import dacite 9 9 + 10 10 + from . import paths 11 11 + from .log import error, or_phrase 12 12 + 13 13 + DEFAULT_CONFIG_FILE = Path(__file__).parent / "config.toml" 14 14 + 15 15 + 16 16 + @dataclass(kw_only=True) 17 17 + class Config: 18 18 + config_py_template: str = """ 19 19 + config.source(r'{source_config_py}') 20 20 + 21 21 + c.window.title_format += ' ({profile_name})' 22 22 + 23 23 + config.load_autoconfig() 24 24 + """ 25 25 + symlink_autoconfig: bool = False 26 26 + qutebrowser_config_directory: Path | None = None 27 27 + profile_directory: Path = field(default_factory=paths.default_profile_dir) 28 28 + generate_desktop_file: bool = platform.system() == "Linux" 29 29 + application_name: str = "{profile_name} (qutebrowser profile)" 30 30 + desktop_file_directory: Path = field( 31 31 + default_factory=paths.default_qbpm_application_dir 32 32 + ) 33 33 + menu: str | list[str] = field(default_factory=list) 34 34 + menu_prompt: str = "qutebrowser" 35 35 + qutebrowser_in_choose: bool = False 36 36 + 37 37 + @classmethod 38 38 + def load(cls, config_file: Path | None) -> "Config": 39 39 + config_file = config_file or DEFAULT_CONFIG_FILE 40 40 + try: 41 41 + data = tomllib.loads(config_file.read_text(encoding="utf-8")) 42 42 + if extra := data.keys() - {field.name for field in fields(Config)}: 43 43 + raise RuntimeError(f'unknown config value: "{next(iter(extra))}"') 44 44 + return dacite.from_dict( 45 45 + data_class=Config, 46 46 + data=data, 47 47 + config=dacite.Config( 48 48 + type_hooks={Path: lambda val: Path(val).expanduser()} 49 49 + ), 50 50 + ) 51 51 + except Exception as e: 52 52 + error(f"loading {config_file} failed with error '{e}'") 53 53 + sys.exit(1) 54 54 + 55 55 + 56 56 + def find_config(config_path: Path | None) -> Config: 57 57 + if not config_path: 58 58 + default = paths.default_qbpm_config_dir() / "config.toml" 59 59 + if default.is_file(): 60 60 + config_path = default 61 61 + elif config_path == Path(os.devnull): 62 62 + config_path = None 63 63 + elif not config_path.is_file(): 64 64 + error(f"{config_path} is not a file") 65 65 + sys.exit(1) 66 66 + return Config.load(config_path) 67 67 + 68 68 + 69 69 + def find_qutebrowser_config_dir( 70 70 + qb_config_dir: Path | None, autoconfig: bool = False 71 71 + ) -> Path | None: 72 72 + dirs = ( 73 73 + [qb_config_dir, qb_config_dir / "config"] 74 74 + if qb_config_dir 75 75 + else list(paths.qutebrowser_config_dirs()) 76 76 + ) 77 77 + for config_dir in dirs: 78 78 + if (config_dir / "config.py").exists() or ( 79 79 + autoconfig and (config_dir / "autoconfig.yml").exists() 80 80 + ): 81 81 + return config_dir.absolute() 82 82 + if autoconfig: 83 83 + error(f"couldn't find config.py or autoconfig.yml in {or_phrase(dirs)}") 84 84 + else: 85 85 + error(f"couldn't find config.py in {or_phrase(dirs)}") 86 86 + return None

+49

src/qbpm/config.toml

··· 1 1 + # template that new config.py files are generated from 2 2 + # supported placeholders: {profile_name}, {source_config_py} 3 3 + config_py_template = """ 4 4 + config.source(r'{source_config_py}') 5 5 + 6 6 + c.window.title_format += ' ({profile_name})' 7 7 + 8 8 + config.load_autoconfig() 9 9 + """ 10 10 + 11 11 + # symlink autoconfig.yml in new profiles if the os supports it 12 12 + # symlink_autoconfig = false 13 13 + 14 14 + # location to store qutebrowser profiles 15 15 + # profile_directory = "~/.local/share/qutebrowser-profiles" 16 16 + 17 17 + # location of the qutebrowser config to inherit from 18 18 + # qutebrowser_config_directory = "~/.config/qutebrowser" 19 19 + 20 20 + # when creating a profile also generate an XDG desktop file that launches the profile 21 21 + # defaults to true on linux 22 22 + # generate_desktop_file = false 23 23 + # desktop_file_directory = "~/.local/share/applications/qbpm" 24 24 + 25 25 + # application name in XDG desktop file (replace existing with `qbpm desktop PROFILE_NAME`) 26 26 + # supported placeholders: {profile_name} 27 27 + # application_name = "{profile_name} (qutebrowser profile)" 28 28 + 29 29 + # profile selection menu for `qbpm choose` 30 30 + # when not set, qbpm will try to find a menu program on your $PATH 31 31 + # run `qbpm choose --help` for a list of known menu programs 32 32 + # if menu is a known menu, dmenu-mode flags are set automatically 33 33 + # menu = "fuzzel" # gets turned into "fuzzel --dmenu", /path/to/fuzzel also works 34 34 + # otherwise menu must be a dmenu-compatible commandline 35 35 + # supported placeholders: {prompt}, {qb_args} 36 36 + # menu = "~/bin/my-dmenu" 37 37 + # menu = "fuzzel --dmenu --prompt '{prompt}> ' --lines 20 --width 50" 38 38 + # optionally menu can be written as a list to simplify quoting 39 39 + # menu = ["fuzzel", "--dmenu", "--prompt", "{prompt}> ", "--lines", "20", "--width", "50"] 40 40 + 41 41 + # value of {prompt} in menu commands 42 42 + # supported placeholders: {qb_args} 43 43 + # defaults to "qutebrowser" 44 44 + # menu_prompt = "qbpm" 45 45 + # menu_prompt = "profiles" 46 46 + # menu_prompt = "qutebrowser {qb_args}" 47 47 + 48 48 + # include a `qutebrowser` entry in `qbpm choose` that starts qutebrowser without a profile 49 49 + # qutebrowser_in_choose = false

+6 -5

src/qbpm/desktop.py

··· 2 2 from pathlib import Path 3 3 4 4 from . import Profile 5 5 - from .paths import default_qbpm_application_dir 6 5 7 6 MIME_TYPES = [ 8 7 "text/html", ··· 19 18 ] 20 19 21 20 22 22 - # TODO expose application_dir through config 23 23 - def create_desktop_file(profile: Profile, application_dir: Path | None = None) -> None: 21 21 + def create_desktop_file( 22 22 + profile: Profile, application_dir: Path, application_name: str 23 23 + ) -> None: 24 24 + application_name = application_name.format(profile_name=profile.name) 24 25 text = textwrap.dedent(f"""\ 25 26 [Desktop Entry] 26 26 - Name={profile.name} (qutebrowser profile) 27 27 + Name={application_name} 27 28 StartupWMClass=qutebrowser 28 29 GenericName={profile.name} 29 30 Icon=qutebrowser ··· 44 45 Name=Preferences 45 46 Exec={" ".join([*profile.cmdline(), '"qute://settings"'])} 46 47 """) 47 47 - application_dir = application_dir or default_qbpm_application_dir() 48 48 + application_dir.mkdir(parents=True, exist_ok=True) 48 49 (application_dir / f"{profile.name}.desktop").write_text(text)

+1 -1

src/qbpm/launch.py

··· 24 24 p = subprocess.Popen(args, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) 25 25 try: 26 26 # give qb a chance to validate input before returning to shell 27 27 - stdout, stderr = p.communicate(timeout=0.1) 27 27 + _stdout, stderr = p.communicate(timeout=0.1) 28 28 print(stderr.decode(errors="ignore"), end="") 29 29 except subprocess.TimeoutExpired: 30 30 pass

+100 -50

src/qbpm/main.py

··· 8 8 9 9 import click 10 10 11 11 - from . import Profile, operations, profiles 11 11 + from . import Profile, profiles 12 12 from .choose import choose_profile 13 13 + from .config import DEFAULT_CONFIG_FILE, Config, find_config 14 14 + from .desktop import create_desktop_file 13 15 from .launch import launch_qutebrowser 14 14 - from .log import error, or_phrase 15 16 from .menus import supported_menus 16 16 - from .paths import default_profile_dir, qutebrowser_data_dir 17 17 + from .paths import default_qbpm_config_dir 18 18 + from .session import profile_from_session 17 19 18 18 - CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]} 20 20 + CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"], "max_content_width": 91} 19 21 20 22 21 23 @dataclass 22 24 class Context: 23 23 - profile_dir: Path 25 25 + cli_profile_dir: Path | None 26 26 + cli_config_file: Path | None 27 27 + 28 28 + def load_config(self) -> Config: 29 29 + config = find_config(self.cli_config_file) 30 30 + if self.cli_profile_dir: 31 31 + config.profile_directory = self.cli_profile_dir 32 32 + return config 24 33 25 34 26 35 @dataclass ··· 28 37 qb_config_dir: Path | None 29 38 launch: bool 30 39 foreground: bool 31 31 - desktop_file: bool 40 40 + desktop_file: bool | None 32 41 overwrite: bool 33 42 34 43 ··· 41 50 qb_config_dir: Path | None, 42 51 launch: bool, 43 52 foreground: bool, 44 44 - desktop_file: bool, 53 53 + desktop_file: bool | None, 45 54 overwrite: bool, 46 55 *args: Any, # noqa: ANN401 47 56 **kwargs: Any, # noqa: ANN401 ··· 61 70 "--qutebrowser-config-dir", 62 71 "qb_config_dir", 63 72 type=click.Path(file_okay=False, readable=True, path_type=Path), 64 64 - help="Location of the qutebrowser config to inherit from.", 73 73 + help="Location of the qutebrowser config to source.", 65 74 ), 66 75 click.option("-l", "--launch", is_flag=True, help="Launch the profile."), 67 76 click.option( ··· 71 80 help="If --launch is set, run qutebrowser in the foreground.", 72 81 ), 73 82 click.option( 74 74 - "--no-desktop-file", 75 75 - "desktop_file", 76 76 - default=True, 77 77 - is_flag=True, 78 78 - flag_value=False, 79 79 - help="Do not generate an XDG desktop entry for the profile.", 83 83 + "--desktop-file/--no-desktop-file", 84 84 + default=None, 85 85 + help="Generate an XDG desktop entry for the profile.", 80 86 ), 81 87 click.option( 82 88 "--overwrite", ··· 102 108 "--profile-dir", 103 109 type=click.Path(file_okay=False, writable=True, path_type=Path), 104 110 envvar="QBPM_PROFILE_DIR", 105 105 - show_envvar=True, 111 111 + show_envvar=False, 106 112 default=None, 107 113 help="Location to store qutebrowser profiles.", 108 114 ) 109 115 @click.option( 116 116 + "-c", 117 117 + "--config-file", 118 118 + type=click.Path(dir_okay=False, writable=True, path_type=Path), 119 119 + help="Location of qbpm config file.", 120 120 + ) 121 121 + @click.option( 110 122 "-l", 111 123 "--log-level", 112 124 default="error", 113 125 type=click.Choice(["debug", "info", "error"], case_sensitive=False), 114 126 ) 115 127 @click.pass_context 116 116 - def main(ctx: click.Context, profile_dir: Path | None, log_level: str) -> None: 128 128 + def main( 129 129 + ctx: click.Context, 130 130 + profile_dir: Path | None, 131 131 + config_file: Path | None, 132 132 + log_level: str, 133 133 + ) -> None: 117 134 root_logger = logging.getLogger() 118 135 root_logger.setLevel(log_level.upper()) 119 136 handler = logging.StreamHandler() 120 137 handler.setFormatter(LowerCaseFormatter("{levelname}: {message}", style="{")) 121 138 root_logger.addHandler(handler) 122 122 - ctx.obj = Context(profile_dir or default_profile_dir()) 139 139 + ctx.obj = Context(profile_dir, config_file) 123 140 124 141 125 142 @main.command() ··· 134 151 c_opts: CreatorOptions, 135 152 ) -> None: 136 153 """Create a new profile.""" 137 137 - profile = Profile(profile_name, **vars(context)) 154 154 + config = context.load_config() 155 155 + profile = Profile(profile_name, config.profile_directory) 156 156 + if c_opts.qb_config_dir: 157 157 + config.qutebrowser_config_directory = c_opts.qb_config_dir.absolute() 158 158 + if c_opts.desktop_file is not None: 159 159 + config.generate_desktop_file = c_opts.desktop_file 138 160 exit_with( 139 161 profiles.new_profile( 140 162 profile, 141 141 - c_opts.qb_config_dir, 163 163 + config, 142 164 home_page, 143 143 - c_opts.desktop_file, 144 165 c_opts.overwrite, 145 166 ) 146 167 and ((not c_opts.launch) or launch_qutebrowser(profile, c_opts.foreground)) ··· 163 184 SESSION may be the name of a session in the global qutebrowser profile 164 185 or a path to a session yaml file. 165 186 """ 166 166 - profile, session_path = session_info(session, profile_name, context) 187 187 + config = context.load_config() 188 188 + if c_opts.qb_config_dir: 189 189 + config.qutebrowser_config_directory = c_opts.qb_config_dir.absolute() 190 190 + if c_opts.desktop_file is not None: 191 191 + config.generate_desktop_file = c_opts.desktop_file 192 192 + profile = profile_from_session( 193 193 + session, 194 194 + profile_name, 195 195 + config, 196 196 + c_opts.overwrite, 197 197 + ) 167 198 exit_with( 168 168 - operations.from_session( 169 169 - profile, 170 170 - session_path, 171 171 - c_opts.qb_config_dir, 172 172 - c_opts.desktop_file, 173 173 - c_opts.overwrite, 174 174 - ) 199 199 + profile is not None 175 200 and ((not c_opts.launch) or launch_qutebrowser(profile, c_opts.foreground)) 176 201 ) 177 202 ··· 189 214 """Launch qutebrowser with a specific profile. 190 215 191 216 All QB_ARGS are passed on to qutebrowser.""" 192 192 - profile = Profile(profile_name, **vars(context)) 217 217 + profile = Profile(profile_name, context.load_config().profile_directory) 218 218 + if not profiles.check(profile): 219 219 + sys.exit(1) 193 220 exit_with(launch_qutebrowser(profile, foreground, qb_args)) 194 221 195 222 ··· 214 241 Support is built in for many X and Wayland launchers, as well as applescript dialogs. 215 242 All QB_ARGS are passed on to qutebrowser. 216 243 """ 217 217 - exit_with(choose_profile(context.profile_dir, menu, foreground, qb_args)) 244 244 + config = context.load_config() 245 245 + if menu: 246 246 + config.menu = menu 247 247 + exit_with( 248 248 + choose_profile( 249 249 + config, 250 250 + foreground, 251 251 + qb_args, 252 252 + ) 253 253 + ) 218 254 219 255 220 256 @main.command() ··· 222 258 @click.pass_obj 223 259 def edit(context: Context, profile_name: str) -> None: 224 260 """Edit a profile's config.py.""" 225 225 - profile = Profile(profile_name, **vars(context)) 226 226 - if not profile.exists(): 227 227 - error(f"profile {profile.name} not found at {profile.root}") 261 261 + profile = Profile(profile_name, context.load_config().profile_directory) 262 262 + if not profiles.check(profile): 228 263 sys.exit(1) 229 264 click.edit(filename=str(profile.root / "config" / "config.py")) 230 265 ··· 233 268 @click.pass_obj 234 269 def list_(context: Context) -> None: 235 270 """List existing profiles.""" 236 236 - for profile in sorted(context.profile_dir.iterdir()): 271 271 + for profile in sorted(context.load_config().profile_directory.iterdir()): 237 272 print(profile.name) 238 273 239 274 ··· 245 280 profile_name: str, 246 281 ) -> None: 247 282 """Create an XDG desktop entry for an existing profile.""" 248 248 - profile = Profile(profile_name, **vars(context)) 249 249 - exit_with(operations.desktop(profile)) 283 283 + config = context.load_config() 284 284 + profile = Profile(profile_name, config.profile_directory) 285 285 + exists = profiles.check(profile) 286 286 + if exists: 287 287 + create_desktop_file( 288 288 + profile, config.desktop_file_directory, config.application_name 289 289 + ) 290 290 + exit_with(exists) 291 291 + 292 292 + 293 293 + @main.group() 294 294 + def config() -> None: 295 295 + """Commands to create a qbpm config file. 250 296 297 297 + qbpm config default > "$(qbpm config path)" 298 298 + """ 299 299 + pass 251 300 252 252 - def session_info( 253 253 - session: str, profile_name: str | None, context: Context 254 254 - ) -> tuple[Profile, Path]: 255 255 - user_session_dir = qutebrowser_data_dir() / "sessions" 256 256 - session_paths = [] 257 257 - if "/" not in session: 258 258 - session_paths.append(user_session_dir / (session + ".yml")) 259 259 - session_paths.append(Path(session)) 260 260 - session_path = next(filter(lambda path: path.is_file(), session_paths), None) 301 301 + 302 302 + @config.command() 303 303 + @click.pass_obj 304 304 + def path(context: Context) -> None: 305 305 + """Print the location where qbpm will look for a config file.""" 306 306 + if context.cli_config_file: 307 307 + print(context.cli_config_file.absolute()) 308 308 + else: 309 309 + config_dir = default_qbpm_config_dir() 310 310 + config_dir.mkdir(parents=True, exist_ok=True) 311 311 + print(config_dir / "config.toml") 261 312 262 262 - if not session_path: 263 263 - tried = or_phrase([str(p.resolve()) for p in session_paths]) 264 264 - error(f"could not find session file at {tried}") 265 265 - sys.exit(1) 266 313 267 267 - return (Profile(profile_name or session_path.stem, **vars(context)), session_path) 314 314 + @config.command 315 315 + def default() -> None: 316 316 + """Print the default qbpm config file.""" 317 317 + print(DEFAULT_CONFIG_FILE.read_text(), end="") 268 318 269 319 270 320 def exit_with(result: bool) -> NoReturn:

+29 -21

src/qbpm/menus.py

··· 21 21 return which(self.name()) is not None 22 22 23 23 def command(self, _profiles: list[str], prompt: str, qb_args: str) -> list[str]: 24 24 + prompt = prompt.format(qb_args=qb_args) 24 25 return [arg.format(prompt=prompt, qb_args=qb_args) for arg in self.menu_command] 25 26 26 27 ··· 45 46 ] 46 47 47 48 48 48 - def find_menu(menu: str | None) -> Dmenu | ApplescriptMenu | None: 49 49 + def find_menu(menu: str | list[str] | None) -> Dmenu | ApplescriptMenu | None: 50 50 + if menu: 51 51 + dmenu = custom_dmenu(menu) 52 52 + if not dmenu.installed(): 53 53 + error(f"{dmenu.name()} not found") 54 54 + return None 55 55 + return dmenu 49 56 menus = list(supported_menus()) 50 50 - if not menu: 51 51 - found = next(filter(lambda m: m.installed(), menus), None) 52 52 - if not found: 53 53 - error( 54 54 - "no menu program found, use --menu to provide a dmenu-compatible menu or install one of " 55 55 - + or_phrase([m.name() for m in menus if isinstance(m, Dmenu)]) 56 56 - ) 57 57 - return found 58 58 - dmenu = custom_dmenu(menu) 59 59 - if not dmenu.installed(): 60 60 - error(f"{dmenu.name()} not found") 61 61 - return None 62 62 - return dmenu 57 57 + found = next(filter(lambda m: m.installed(), menus), None) 58 58 + if not found: 59 59 + error( 60 60 + "no menu program found, use --menu to provide a dmenu-compatible menu or install one of " 61 61 + + or_phrase([m.name() for m in menus if isinstance(m, Dmenu)]) 62 62 + ) 63 63 + return found 63 64 64 65 65 65 - def custom_dmenu(command: str) -> Dmenu: 66 66 - split = shlex.split(command) 66 66 + def custom_dmenu(command: str | list[str]) -> Dmenu: 67 67 + split = shlex.split(command) if isinstance(command, str) else command 67 68 if len(split) == 1 or not split[1]: 68 68 - name = Path(command).name 69 69 + command_path = Path(split[0]) 70 70 + name = command_path.name 69 71 for menu in supported_menus(): 70 72 if isinstance(menu, Dmenu) and menu.name() == name: 71 73 return ( 72 74 menu 73 73 - if name == command 74 74 - else replace(menu, menu_command=[command, *menu.menu_command[1::]]) 75 75 + if name == split[0] 76 76 + else replace( 77 77 + menu, 78 78 + menu_command=[ 79 79 + str(command_path.expanduser()), 80 80 + *menu.menu_command[1::], 81 81 + ], 82 82 + ) 75 83 ) 76 84 return Dmenu(split) 77 85 ··· 83 91 yield from [ 84 92 # default window is too narrow for a long prompt 85 93 Dmenu(["fuzzel", "--dmenu"]), 86 86 - Dmenu(["walker", "--dmenu", "--placeholder", "{prompt} {qb_args}"]), 87 87 - Dmenu(["wofi", "--dmenu", "--prompt", "{prompt} {qb_args}"]), 94 94 + Dmenu(["walker", "--dmenu", "--placeholder", "{prompt}"]), 95 95 + Dmenu(["wofi", "--dmenu", "--prompt", "{prompt}"]), 88 96 Dmenu(["tofi", "--prompt-text", "{prompt}> "]), 89 97 Dmenu(["wmenu", "-p", "{prompt}"]), 90 98 Dmenu(["dmenu-wl", "--prompt", "{prompt}"]),

-32

src/qbpm/operations.py

··· 1 1 - import shutil 2 2 - from pathlib import Path 3 3 - 4 4 - from . import Profile, profiles 5 5 - from .desktop import create_desktop_file 6 6 - from .log import error 7 7 - 8 8 - 9 9 - def from_session( 10 10 - profile: Profile, 11 11 - session_path: Path, 12 12 - qb_config_dir: Path | None, 13 13 - desktop_file: bool = True, 14 14 - overwrite: bool = False, 15 15 - ) -> bool: 16 16 - if not profiles.new_profile(profile, qb_config_dir, None, desktop_file, overwrite): 17 17 - return False 18 18 - 19 19 - session_dir = profile.root / "data" / "sessions" 20 20 - session_dir.mkdir(parents=True, exist_ok=overwrite) 21 21 - shutil.copy(session_path, session_dir / "_autosave.yml") 22 22 - 23 23 - return True 24 24 - 25 25 - 26 26 - def desktop(profile: Profile) -> bool: 27 27 - exists = profile.exists() 28 28 - if exists: 29 29 - create_desktop_file(profile) 30 30 - else: 31 31 - error(f"profile {profile.name} not found at {profile.root}") 32 32 - return exists

+15 -18

src/qbpm/paths.py

··· 1 1 import platform 2 2 + from collections.abc import Iterator 2 3 from pathlib import Path 3 4 4 5 from click import get_app_dir ··· 7 8 8 9 def qutebrowser_exe() -> str: 9 10 macos_app = "/Applications/qutebrowser.app/Contents/MacOS/qutebrowser" 10 10 - if platform == "darwin" and Path(macos_app).exists(): 11 11 + if platform.system() == "Darwin" and Path(macos_app).exists(): 11 12 return macos_app 12 13 else: 13 14 return "qutebrowser" 14 15 15 16 17 17 + def default_qbpm_config_dir() -> Path: 18 18 + return xdg_config_home() / "qbpm" 19 19 + 20 20 + 16 21 def default_qbpm_application_dir() -> Path: 17 17 - path = xdg_data_home() / "applications" / "qbpm" 18 18 - path.mkdir(parents=True, exist_ok=True) 19 19 - return path 22 22 + return xdg_data_home() / "applications" / "qbpm" 20 23 21 24 22 25 def default_profile_dir() -> Path: 23 23 - path = xdg_data_home() / "qutebrowser-profiles" 24 24 - path.mkdir(parents=True, exist_ok=True) 25 25 - return path 26 26 + return xdg_data_home() / "qutebrowser-profiles" 26 27 27 28 28 29 def qutebrowser_data_dir() -> Path: ··· 32 33 return Path(get_app_dir("qutebrowser", roaming=True)) 33 34 34 35 35 35 - def qutebrowser_config_dirs() -> list[Path]: 36 36 - # deduplicate while maintaining order 37 37 - return list( 38 38 - dict.fromkeys( 39 39 - [ 40 40 - Path(get_app_dir("qutebrowser", roaming=True)), 41 41 - xdg_config_home() / "qutebrowser", 42 42 - Path.home() / ".qutebrowser", 43 43 - ] 44 44 - ) 45 45 - ) 36 36 + def qutebrowser_config_dirs() -> Iterator[Path]: 37 37 + app_dir = Path(get_app_dir("qutebrowser", roaming=True)) 38 38 + yield app_dir 39 39 + xdg_dir = xdg_config_home() / "qutebrowser" 40 40 + if xdg_dir != app_dir: 41 41 + yield xdg_dir 42 42 + yield Path.home() / ".qutebrowser"

+82 -33

src/qbpm/profiles.py

··· 1 1 from functools import partial 2 2 from pathlib import Path 3 3 - from sys import platform 4 3 5 4 from . import Profile 5 5 + from .config import Config, find_qutebrowser_config_dir 6 6 from .desktop import create_desktop_file 7 7 - from .log import error, or_phrase 8 8 - from .paths import qutebrowser_config_dirs 7 7 + from .log import error, info 8 8 + from .paths import qutebrowser_data_dir 9 9 10 10 MIME_TYPES = [ 11 11 "text/html", ··· 23 23 24 24 25 25 def create_profile(profile: Profile, overwrite: bool = False) -> bool: 26 26 - if not profile.check(): 26 26 + if not profile.check_name(): 27 27 return False 28 28 29 29 if not overwrite and profile.root.exists(): ··· 32 32 33 33 config_dir = profile.root / "config" 34 34 config_dir.mkdir(parents=True, exist_ok=overwrite) 35 35 - print(profile.root) 36 35 return True 37 36 38 37 39 38 def create_config( 40 39 profile: Profile, 41 40 qb_config_dir: Path, 41 41 + config_py_template: str, 42 42 home_page: str | None = None, 43 43 overwrite: bool = False, 44 44 ) -> None: 45 45 + source = qb_config_dir / "config.py" 46 46 + if not source.is_file(): 47 47 + return 45 48 user_config = profile.root / "config" / "config.py" 49 49 + if overwrite and user_config.exists(): 50 50 + back_up(user_config) 46 51 with user_config.open(mode="w" if overwrite else "x") as dest_config: 47 52 out = partial(print, file=dest_config) 48 48 - out("config.load_autoconfig()") 49 49 - title_prefix = "{perc}{current_title}{title_sep}" 50 50 - out(f"c.window.title_format = '{title_prefix} qutebrowser ({profile.name})'") 53 53 + out( 54 54 + config_py_template.format( 55 55 + profile_name=profile.name, 56 56 + source_config_py=source, 57 57 + ) 58 58 + ) 59 59 + # TODO move to template? 51 60 if home_page: 52 61 out(f"c.url.start_pages = ['{home_page}']") 53 53 - out(f"config.source(r'{qb_config_dir / 'config.py'}')") 62 62 + 63 63 + 64 64 + def link_autoconfig( 65 65 + profile: Profile, 66 66 + qb_config_dir: Path, 67 67 + overwrite: bool = False, 68 68 + ) -> None: 69 69 + if not hasattr(Path, "symlink_to"): 70 70 + return 71 71 + source = qb_config_dir / "autoconfig.yml" 72 72 + dest = profile.root / "config" / "autoconfig.yml" 73 73 + if not source.is_file() or dest.resolve() == source.resolve(): 74 74 + return 75 75 + if overwrite and dest.exists(): 76 76 + back_up(dest) 77 77 + dest.symlink_to(source) 78 78 + 79 79 + 80 80 + def link_dictionaries(profile: Profile, overwrite: bool) -> None: 81 81 + if not hasattr(Path, "symlink_to"): 82 82 + return 83 83 + source = qutebrowser_data_dir() / "qtwebengine_dictionaries" 84 84 + dest = profile.root / "data" / "qtwebengine_dictionaries" 85 85 + dest.parent.mkdir(exist_ok=True) 86 86 + if dest.resolve() == source.resolve(): 87 87 + return 88 88 + if overwrite and dest.exists(): 89 89 + back_up(dest) 90 90 + dest.symlink_to(source, target_is_directory=True) 91 91 + 92 92 + 93 93 + def back_up(dest: Path) -> None: 94 94 + backup = Path(str(dest) + ".bak") 95 95 + info(f"backing up existing {dest.name} to {backup}") 96 96 + dest.replace(backup) 54 97 55 98 56 56 - def exists(profile: Profile) -> bool: 57 57 - if profile.root.exists() and not profile.root.is_dir(): 99 99 + def check(profile: Profile) -> bool: 100 100 + if not profile.check_name(): 101 101 + return False 102 102 + exists = profile.root.exists() 103 103 + if not exists: 104 104 + error(f"{profile.root} does not exist") 105 105 + return False 106 106 + if not profile.root.is_dir(): 58 107 error(f"{profile.root} is not a directory") 59 108 return False 60 60 - if not profile.root.exists(): 61 61 - error(f"{profile.root} does not exist") 109 109 + if not (profile.root / "config").is_dir(): 110 110 + error(f"no config directory in {profile.root}, is it a profile?") 62 111 return False 63 112 return True 64 113 65 114 66 115 def new_profile( 67 116 profile: Profile, 68 68 - qb_config_dir: Path | None, 117 117 + config: Config, 69 118 home_page: str | None = None, 70 70 - desktop_file: bool | None = None, 71 119 overwrite: bool = False, 72 120 ) -> bool: 73 73 - qb_config_dir = find_qutebrowser_config_dir(qb_config_dir) 121 121 + qb_config_dir = config.qutebrowser_config_directory 122 122 + if qb_config_dir and not qb_config_dir.is_dir(): 123 123 + error(f"{qb_config_dir} is not a directory") 124 124 + return False 125 125 + qb_config_dir = find_qutebrowser_config_dir( 126 126 + qb_config_dir, config.symlink_autoconfig 127 127 + ) 74 128 if not qb_config_dir: 75 129 return False 76 130 if create_profile(profile, overwrite): 77 77 - create_config(profile, qb_config_dir, home_page, overwrite) 78 78 - if desktop_file is True or (desktop_file is not False and platform == "linux"): 79 79 - create_desktop_file(profile) 131 131 + if config.config_py_template: 132 132 + create_config( 133 133 + profile, qb_config_dir, config.config_py_template, home_page, overwrite 134 134 + ) 135 135 + if config.symlink_autoconfig: 136 136 + link_autoconfig(profile, qb_config_dir, overwrite) 137 137 + if config.generate_desktop_file: 138 138 + create_desktop_file( 139 139 + profile, config.desktop_file_directory, config.application_name 140 140 + ) 141 141 + link_dictionaries(profile, overwrite) 142 142 + print(profile.root) 80 143 return True 81 144 return False 82 82 - 83 83 - 84 84 - def find_qutebrowser_config_dir(qb_config_dir: Path | None) -> Path | None: 85 85 - config_file = "config.py" 86 86 - dirs = ( 87 87 - [qb_config_dir, qb_config_dir / "config"] 88 88 - if qb_config_dir 89 89 - else qutebrowser_config_dirs() 90 90 - ) 91 91 - for config_dir in dirs: 92 92 - if (config_dir / config_file).exists(): 93 93 - return config_dir.absolute() 94 94 - error(f"could not find {config_file} in {or_phrase(dirs)}") 95 95 - return None

+50

src/qbpm/session.py

··· 1 1 + import shutil 2 2 + import sys 3 3 + from pathlib import Path 4 4 + 5 5 + from . import Profile, profiles 6 6 + from .config import Config 7 7 + from .log import error, or_phrase 8 8 + from .paths import qutebrowser_data_dir 9 9 + 10 10 + 11 11 + def profile_from_session( 12 12 + session: str, 13 13 + profile_name: str | None, 14 14 + config: Config, 15 15 + overwrite: bool = False, 16 16 + ) -> Profile | None: 17 17 + profile, session_path = session_info( 18 18 + session, profile_name, config.profile_directory 19 19 + ) 20 20 + if not profiles.new_profile(profile, config, None, overwrite): 21 21 + return None 22 22 + 23 23 + session_dir = profile.root / "data" / "sessions" 24 24 + session_dir.mkdir(parents=True, exist_ok=overwrite) 25 25 + shutil.copy(session_path, session_dir / "_autosave.yml") 26 26 + 27 27 + return profile 28 28 + 29 29 + 30 30 + def session_info( 31 31 + session: str, profile_name: str | None, profile_dir: Path 32 32 + ) -> tuple[Profile, Path]: 33 33 + user_session_dir = qutebrowser_data_dir() / "sessions" 34 34 + session_paths = [] 35 35 + if "/" not in session: 36 36 + session_paths.append(user_session_dir / (session + ".yml")) 37 37 + session_paths.append(Path(session)) 38 38 + session_path = next(filter(lambda path: path.is_file(), session_paths), None) 39 39 + 40 40 + if session_path: 41 41 + return ( 42 42 + Profile( 43 43 + profile_name or session_path.stem, 44 44 + profile_dir, 45 45 + ), 46 46 + session_path, 47 47 + ) 48 48 + tried = or_phrase([str(p.resolve()) for p in session_paths]) 49 49 + error(f"could not find session file at {tried}") 50 50 + sys.exit(1)

+12

tests/__init__.py

··· 1 1 + from os import environ 2 2 + from pathlib import Path 3 3 + 4 4 + import pytest 5 5 + 6 6 + 7 7 + @pytest.fixture(autouse=True) 8 8 + def no_homedir_fixture(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: 9 9 + environ["XDG_CONFIG_HOME"] = str(tmp_path) 10 10 + environ["XDG_DATA_HOME"] = str(tmp_path) 11 11 + monkeypatch.setattr("qbpm.paths.get_app_dir", lambda *_args, **_kwargs: tmp_path) 12 12 + monkeypatch.setattr("qbpm.paths.Path.home", lambda: tmp_path)

+13 -1

tests/test_choose.py

··· 2 2 from pathlib import Path 3 3 4 4 from qbpm.choose import choose_profile, find_menu 5 5 + from qbpm.config import Config 6 6 + 7 7 + from . import no_homedir_fixture # noqa: F401 5 8 6 9 7 10 def write_script(parent_dir: Path, name: str = "menu", contents: str = "") -> Path: ··· 27 30 profile_dir.mkdir() 28 31 (profile_dir / "p1").mkdir() 29 32 (profile_dir / "p2").mkdir() 30 30 - assert choose_profile(profile_dir, str(menu), False, ()) 33 33 + config = Config(profile_directory=profile_dir, menu=str(menu), menu_prompt="") 34 34 + assert choose_profile(config, False, ()) 35 35 + assert log.read_text().startswith( 36 36 + f"""p1 37 37 + p2 38 38 + qutebrowser -B {profile_dir / "p1"}""" 39 39 + ) 40 40 + log.write_text("") 41 41 + config.qutebrowser_in_choose = True 42 42 + assert choose_profile(config, False, ()) 31 43 assert log.read_text().startswith( 32 44 f"""p1 33 45 p2

+85

tests/test_config.py

··· 1 1 + from pathlib import Path 2 2 + 3 3 + from qbpm.config import ( 4 4 + DEFAULT_CONFIG_FILE, 5 5 + Config, 6 6 + find_config, 7 7 + find_qutebrowser_config_dir, 8 8 + ) 9 9 + 10 10 + from . import no_homedir_fixture # noqa: F401 11 11 + 12 12 + 13 13 + def test_no_config(): 14 14 + assert find_config(None) == Config.load(DEFAULT_CONFIG_FILE) 15 15 + 16 16 + 17 17 + def test_empty_config(tmp_path: Path): 18 18 + file = tmp_path / "config.toml" 19 19 + file.touch() 20 20 + assert find_config(file) == Config() 21 21 + 22 22 + 23 23 + def test_default_config_location(tmp_path: Path): 24 24 + (tmp_path / "qbpm").mkdir() 25 25 + (tmp_path / "qbpm" / "config.toml").touch() 26 26 + assert find_config(None) == Config() 27 27 + 28 28 + 29 29 + def test_minimal_config(tmp_path: Path): 30 30 + file = tmp_path / "config.toml" 31 31 + file.write_text("""config_py_template = 'template'""") 32 32 + assert find_config(file) == Config(config_py_template="template") 33 33 + 34 34 + 35 35 + def test_full_config(tmp_path: Path): 36 36 + file = tmp_path / "config.toml" 37 37 + file.write_text(""" 38 38 + config_py_template = \""" 39 39 + config.load_autoconfig() 40 40 + \""" 41 41 + symlink_autoconfig = true 42 42 + qutebrowser_config_directory = "~/.config/qutebrowser" 43 43 + profile_directory = "profile" 44 44 + generate_desktop_file = false 45 45 + desktop_file_directory = "desktop" 46 46 + menu = "~/bin/my-dmenu" 47 47 + menu_prompt = "qbpm" 48 48 + """) 49 49 + assert find_config(file) == Config( 50 50 + config_py_template="config.load_autoconfig()\n", 51 51 + symlink_autoconfig=True, 52 52 + qutebrowser_config_directory=Path("~/.config/qutebrowser").expanduser(), 53 53 + profile_directory=Path("profile"), 54 54 + desktop_file_directory=Path("desktop"), 55 55 + generate_desktop_file=False, 56 56 + menu="~/bin/my-dmenu", 57 57 + menu_prompt="qbpm", 58 58 + ) 59 59 + 60 60 + 61 61 + def test_find_qb_config(tmp_path: Path): 62 62 + qb_dir = tmp_path / "qb" 63 63 + qb_conf_dir = qb_dir / "config" 64 64 + qb_conf_dir.mkdir(parents=True) 65 65 + (qb_conf_dir / "config.py").touch() 66 66 + assert find_qutebrowser_config_dir(qb_dir) == qb_conf_dir 67 67 + assert find_qutebrowser_config_dir(qb_dir / "config") == qb_conf_dir 68 68 + 69 69 + 70 70 + def test_find_autoconfig(tmp_path: Path): 71 71 + qb_dir = tmp_path / "qb" 72 72 + qb_conf_dir = qb_dir / "config" 73 73 + qb_conf_dir.mkdir(parents=True) 74 74 + (qb_conf_dir / "autoconfig.yml").touch() 75 75 + assert find_qutebrowser_config_dir(qb_dir, autoconfig=True) == qb_conf_dir 76 76 + 77 77 + 78 78 + def test_find_qb_config_default(tmp_path: Path): 79 79 + (tmp_path / "config.py").touch() 80 80 + assert find_qutebrowser_config_dir(None) == tmp_path 81 81 + 82 82 + 83 83 + def test_find_qutebrowser_none(tmp_path: Path): 84 84 + assert find_qutebrowser_config_dir(None) is None 85 85 + assert find_qutebrowser_config_dir(tmp_path / "config") is None

+10 -1

tests/test_desktop.py

··· 1 1 from pathlib import Path 2 2 3 3 from qbpm import Profile 4 4 + from qbpm.config import Config 4 5 from qbpm.desktop import create_desktop_file 5 6 6 7 TEST_DIR = Path(__file__).resolve().parent ··· 10 11 application_path = tmp_path / "applications" 11 12 application_path.mkdir() 12 13 profile = Profile("test", tmp_path) 13 13 - create_desktop_file(profile, application_path) 14 14 + create_desktop_file(profile, application_path, Config.load(None).application_name) 14 15 assert (application_path / "test.desktop").read_text() == ( 15 16 TEST_DIR / "test.desktop" 16 17 ).read_text().replace("{qbpm}", " ".join(profile.cmdline())) 18 18 + 19 19 + 20 20 + def test_custom_name(tmp_path: Path): 21 21 + application_path = tmp_path / "applications" 22 22 + application_path.mkdir() 23 23 + profile = Profile("test", tmp_path) 24 24 + create_desktop_file(profile, application_path, "test") 25 25 + assert "Name=test\n" in (application_path / "test.desktop").read_text()

+87 -16

tests/test_main.py

··· 5 5 6 6 from qbpm.main import main 7 7 8 8 - no_desktop = "--no-desktop-file" 8 8 + from . import no_homedir_fixture # noqa: F401 9 9 + 10 10 + 11 11 + def run(*args: str): 12 12 + return CliRunner().invoke(main, args) 9 13 10 14 11 15 def test_profile_dir_option(tmp_path: Path): 12 16 (tmp_path / "config.py").touch() 13 13 - runner = CliRunner() 14 14 - result = runner.invoke( 15 15 - main, ["-P", str(tmp_path), "new", "-C", str(tmp_path), no_desktop, "test"] 16 16 - ) 17 17 + result = run("-P", str(tmp_path), "new", "-C", str(tmp_path), "test") 17 18 assert result.exit_code == 0 18 19 assert result.output.strip() == str(tmp_path / "test") 19 20 assert tmp_path / "test" in list(tmp_path.iterdir()) 21 21 + assert (tmp_path / "applications" / "qbpm" / "test.desktop").exists() 20 22 21 23 22 24 def test_profile_dir_env(tmp_path: Path): 23 25 environ["QBPM_PROFILE_DIR"] = str(tmp_path) 24 26 (tmp_path / "config.py").touch() 25 25 - runner = CliRunner() 26 26 - result = runner.invoke(main, ["new", "-C", str(tmp_path), no_desktop, "test"]) 27 27 + result = run("new", "-C", str(tmp_path), "test") 27 28 assert result.exit_code == 0 28 29 assert result.output.strip() == str(tmp_path / "test") 29 30 assert tmp_path / "test" in list(tmp_path.iterdir()) ··· 33 34 environ["QBPM_PROFILE_DIR"] = str(tmp_path) 34 35 config = tmp_path / "config.py" 35 36 config.touch() 36 36 - runner = CliRunner() 37 37 - result = runner.invoke(main, ["new", "-C", str(tmp_path), no_desktop, "test"]) 37 37 + result = run("new", "-C", str(tmp_path), "test") 38 38 assert result.exit_code == 0 39 39 assert str(config) in (tmp_path / "test/config/config.py").read_text() 40 40 ··· 44 44 config = tmp_path / "config.py" 45 45 config.touch() 46 46 chdir(tmp_path) 47 47 - runner = CliRunner() 48 48 - result = runner.invoke(main, ["new", "-C", ".", no_desktop, "test"]) 47 47 + result = run("new", "-C", ".", "test") 49 48 assert result.exit_code == 0 50 49 assert str(config) in (tmp_path / "test/config/config.py").read_text() 51 50 52 51 53 53 - def test_from_session(tmp_path: Path): 52 52 + def test_from_session_path(tmp_path: Path): 54 53 environ["QBPM_PROFILE_DIR"] = str(tmp_path) 55 54 (tmp_path / "config.py").touch() 56 55 session = tmp_path / "test.yml" 57 56 session.write_text("windows:\n") 58 58 - runner = CliRunner() 59 59 - result = runner.invoke( 60 60 - main, ["from-session", "-C", str(tmp_path), no_desktop, str(session)] 61 61 - ) 57 57 + result = run("from-session", "-C", str(tmp_path), str(session)) 62 58 assert result.exit_code == 0 63 59 assert result.output.strip() == str(tmp_path / "test") 64 60 assert (tmp_path / "test/data/sessions/_autosave.yml").read_text() == ("windows:\n") 61 61 + 62 62 + 63 63 + def test_from_session_name(tmp_path: Path): 64 64 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 65 65 + (tmp_path / "config.py").touch() 66 66 + environ["XDG_DATA_HOME"] = str(tmp_path) 67 67 + (tmp_path / "qutebrowser" / "sessions").mkdir(parents=True) 68 68 + (tmp_path / "qutebrowser" / "sessions" / "test.yml").write_text("windows:\n") 69 69 + result = run("from-session", "-C", str(tmp_path), "test") 70 70 + assert result.exit_code == 0 71 71 + assert result.output.strip() == str(tmp_path / "test") 72 72 + assert (tmp_path / "test/data/sessions/_autosave.yml").read_text() == ("windows:\n") 73 73 + 74 74 + 75 75 + def test_custom_template(tmp_path: Path): 76 76 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 77 77 + (tmp_path / "config.py").touch() 78 78 + config_file = tmp_path / "config.toml" 79 79 + config_file.write_text("config_py_template = '# Custom template {profile_name}'") 80 80 + result = run("-c", str(config_file), "new", "test") 81 81 + assert result.exit_code == 0 82 82 + profile_config = tmp_path / "test" / "config" / "config.py" 83 83 + assert "# Custom template test" in profile_config.read_text() 84 84 + 85 85 + 86 86 + def test_no_template(tmp_path: Path): 87 87 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 88 88 + (tmp_path / "config.py").touch() 89 89 + config_file = tmp_path / "config.toml" 90 90 + config_file.write_text("application_name = 'qbpm'") 91 91 + result = run("-c", str(config_file), "new", "test") 92 92 + assert result.exit_code == 0 93 93 + profile_config = tmp_path / "test" / "config" / "config.py" 94 94 + assert str(tmp_path) in profile_config.read_text() 95 95 + 96 96 + 97 97 + def test_autoconfig_only(tmp_path: Path): 98 98 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 99 99 + (tmp_path / "config.py").touch() 100 100 + config_file = tmp_path / "config.toml" 101 101 + config_file.write_text(""" 102 102 + config_py_template = '' 103 103 + symlink_autoconfig = true 104 104 + """) 105 105 + autoconfig_file = tmp_path / "autoconfig.yml" 106 106 + autoconfig_file.touch() 107 107 + result = run("-c", str(config_file), "new", "test") 108 108 + assert result.exit_code == 0 109 109 + profile_config = tmp_path / "test" / "config" / "config.py" 110 110 + profile_autoconfig = tmp_path / "test" / "config" / "autoconfig.yml" 111 111 + assert not profile_config.exists() 112 112 + assert profile_autoconfig.readlink() == autoconfig_file 113 113 + 114 114 + 115 115 + def test_bad_config_file(): 116 116 + result = run("-c", "/nonexistent/config.toml", "list") 117 117 + assert result.exit_code == 1 118 118 + assert "not a file" in result.output 119 119 + 120 120 + 121 121 + def test_no_desktop_file(tmp_path: Path): 122 122 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 123 123 + (tmp_path / "config.py").touch() 124 124 + run("-P", str(tmp_path), "new", "--no-desktop-file", "-C", str(tmp_path), "test") 125 125 + assert not (tmp_path / "applications" / "qbpm" / "test.desktop").exists() 126 126 + 127 127 + 128 128 + def test_desktop_file_directory(tmp_path: Path): 129 129 + environ["QBPM_PROFILE_DIR"] = str(tmp_path) 130 130 + (tmp_path / "config.py").touch() 131 131 + config_file = tmp_path / "config.toml" 132 132 + config_file.write_text(f'''config_py_template = "" 133 133 + desktop_file_directory="{tmp_path}"''') 134 134 + run("-P", str(tmp_path), "new", "-C", str(tmp_path), "test") 135 135 + assert not (tmp_path / "test.desktop").exists()

+19

tests/test_menu.py

··· 1 1 + from qbpm.menus import Dmenu, custom_dmenu 2 2 + 3 3 + 4 4 + def test_menu_prompt_formatting(): 5 5 + dmenu = Dmenu(["my-menu", "--prompt", "{prompt}"]) 6 6 + cmd = dmenu.command(["p1"], "qb ({qb_args})", "example.com") 7 7 + assert "--prompt" in cmd 8 8 + assert "qb (example.com)" in cmd 9 9 + 10 10 + 11 11 + def test_known_custom_menu(): 12 12 + assert custom_dmenu(["fuzzel"]).menu_command == ["fuzzel", "--dmenu"] 13 13 + assert custom_dmenu("fuzzel").menu_command == ["fuzzel", "--dmenu"] 14 14 + assert "--dmenu" in custom_dmenu("~/bin/fuzzel").menu_command 15 15 + 16 16 + 17 17 + def test_custom_menu_list(): 18 18 + menu = ["fuzzel", "--dmenu", "--prompt", "{prompt}>"] 19 19 + assert custom_dmenu(menu).menu_command == menu

+109 -13

tests/test_profiles.py

··· 1 1 from pathlib import Path 2 2 3 3 from qbpm import profiles 4 4 + from qbpm.config import Config 4 5 from qbpm.profiles import Profile 6 6 + 7 7 + from . import no_homedir_fixture # noqa: F401 5 8 6 9 7 10 def check_is_empty(path: Path): ··· 18 21 def check_new_profile(profile: Profile): 19 22 assert profile 20 23 config_dir = profile.root / "config" 21 21 - assert list(profile.root.iterdir()) == [config_dir] 22 22 - assert list(config_dir.iterdir()) == [config_dir / "config.py"] 24 24 + data_dir = profile.root / "data" 25 25 + assert set(profile.root.iterdir()) == {config_dir, data_dir} 26 26 + assert set(config_dir.iterdir()) == {config_dir / "config.py"} 27 27 + dicts_dir = data_dir / "qtwebengine_dictionaries" 28 28 + assert set(data_dir.iterdir()) == {dicts_dir} 29 29 + assert dicts_dir.is_symlink() 30 30 + assert dicts_dir.resolve().name == "qtwebengine_dictionaries" 23 31 24 32 25 33 def test_set_profile(tmp_path: Path): ··· 51 59 52 60 53 61 def test_create_config(tmp_path: Path): 62 62 + (tmp_path / "config.py").touch() 54 63 profile = Profile("test", tmp_path) 55 64 config_dir = profile.root / "config" 56 65 config_dir.mkdir(parents=True) 57 57 - profiles.create_config(profile, tmp_path) 58 58 - assert list(config_dir.iterdir()) == [config_dir / "config.py"] 66 66 + profiles.create_config(profile, tmp_path, "{source_config_py}") 67 67 + config = config_dir / "config.py" 68 68 + assert list(config_dir.iterdir()) == [config] 69 69 + assert str(tmp_path / "config.py") in config.read_text() 59 70 60 71 61 72 def test_overwrite_config(tmp_path: Path): 73 73 + (tmp_path / "config.py").touch() 62 74 profile = Profile("test", tmp_path) 63 75 url = "http://example.com" 64 76 config_dir = profile.root / "config" 65 77 config_dir.mkdir(parents=True) 66 66 - profiles.create_config(profile, tmp_path) 67 67 - profiles.create_config(profile, tmp_path, url, True) 68 68 - assert list(config_dir.iterdir()) == [config_dir / "config.py"] 69 69 - with (config_dir / "config.py").open() as conf: 70 70 - for line in conf: 71 71 - if url in line: 72 72 - return 73 73 - raise AssertionError() 78 78 + config = config_dir / "config.py" 79 79 + backup = config_dir / "config.py.bak" 80 80 + profiles.create_config(profile, tmp_path, "") 81 81 + profiles.create_config(profile, tmp_path, "", url, True) 82 82 + assert set(config_dir.iterdir()) == {config, backup} 83 83 + assert url in config.read_text() 84 84 + assert url not in backup.read_text() 85 85 + 86 86 + 87 87 + def test_link_autoconfig(tmp_path: Path): 88 88 + profile = Profile("test", tmp_path) 89 89 + config_dir = profile.root / "config" 90 90 + config_dir.mkdir(parents=True) 91 91 + (tmp_path / "autoconfig.yml").touch() 92 92 + profiles.link_autoconfig(profile, tmp_path, False) 93 93 + config = config_dir / "autoconfig.yml" 94 94 + assert list(config_dir.iterdir()) == [config] 95 95 + assert config.resolve().parent == tmp_path 96 96 + 97 97 + 98 98 + def test_autoconfig_present(tmp_path: Path): 99 99 + profile = Profile("test", tmp_path) 100 100 + config_dir = profile.root / "config" 101 101 + config_dir.mkdir(parents=True) 102 102 + (tmp_path / "autoconfig.yml").touch() 103 103 + profiles.link_autoconfig(profile, tmp_path, False) 104 104 + profiles.link_autoconfig(profile, tmp_path, False) 105 105 + config = config_dir / "autoconfig.yml" 106 106 + assert list(config_dir.iterdir()) == [config] 107 107 + assert config.resolve().parent == tmp_path 108 108 + 109 109 + 110 110 + def test_overwrite_autoconfig(tmp_path: Path): 111 111 + profile = Profile("test", tmp_path) 112 112 + config_dir = profile.root / "config" 113 113 + config_dir.mkdir(parents=True) 114 114 + (config_dir / "autoconfig.yml").touch() 115 115 + (tmp_path / "autoconfig.yml").touch() 116 116 + profiles.link_autoconfig(profile, tmp_path, True) 117 117 + config = config_dir / "autoconfig.yml" 118 118 + assert set(config_dir.iterdir()) == {config, config_dir / "autoconfig.yml.bak"} 119 119 + assert config.resolve().parent == tmp_path 74 120 75 121 76 122 def test_new_profile(tmp_path: Path): 77 123 (tmp_path / "config.py").touch() 78 124 profile = Profile("test", tmp_path / "test") 79 79 - assert profiles.new_profile(profile, tmp_path, desktop_file=False) 125 125 + config = Config.load(None) 126 126 + config.qutebrowser_config_directory = tmp_path 127 127 + config.generate_desktop_file = False 128 128 + assert profiles.new_profile(profile, config) 80 129 check_new_profile(profile) 130 130 + 131 131 + 132 132 + def test_new_profile_autoconfig(tmp_path: Path): 133 133 + (tmp_path / "autoconfig.yml").touch() 134 134 + profile = Profile("test", tmp_path / "test") 135 135 + config = Config.load(None) 136 136 + config.qutebrowser_config_directory = tmp_path 137 137 + config.generate_desktop_file = False 138 138 + config.symlink_autoconfig = True 139 139 + profiles.new_profile(profile, config) 140 140 + config_dir = profile.root / "config" 141 141 + assert set(config_dir.iterdir()) == {config_dir / "autoconfig.yml"} 142 142 + 143 143 + 144 144 + def test_new_profile_both(tmp_path: Path): 145 145 + (tmp_path / "config.py").touch() 146 146 + (tmp_path / "autoconfig.yml").touch() 147 147 + profile = Profile("test", tmp_path / "test") 148 148 + config = Config.load(None) 149 149 + config.qutebrowser_config_directory = tmp_path 150 150 + config.generate_desktop_file = False 151 151 + config.symlink_autoconfig = True 152 152 + profiles.new_profile(profile, config) 153 153 + assert len(set((profile.root / "config").iterdir())) == 2 # noqa: PLR2004 154 154 + 155 155 + 156 156 + def test_config_template(tmp_path: Path): 157 157 + (tmp_path / "config.py").touch() 158 158 + profile = Profile("test", tmp_path) 159 159 + config_dir = profile.root / "config" 160 160 + config_dir.mkdir(parents=True) 161 161 + template = "# Profile: {profile_name}\nconfig.source('{source_config_py}')" 162 162 + profiles.create_profile(profile) 163 163 + profiles.create_config(profile, tmp_path, template) 164 164 + config_content = (profile.root / "config" / "config.py").read_text() 165 165 + assert "# Profile: test" in config_content 166 166 + assert f"config.source('{tmp_path / 'config.py'}')" in config_content 167 167 + 168 168 + 169 169 + def test_missing_qb_config(tmp_path: Path): 170 170 + profile = Profile("test", tmp_path / "test") 171 171 + config = Config.load(None) 172 172 + config.qutebrowser_config_directory = tmp_path 173 173 + config.generate_desktop_file = False 174 174 + assert not profiles.new_profile(profile, config) 175 175 + config.qutebrowser_config_directory = tmp_path / "nonexistent" 176 176 + assert not profiles.new_profile(profile, config)