Since the starting parameters are fairly hardwired for wezterm anyway I
don't see this making much sense with e.g. xterm. However, long-term, we
should rather change the hard-dependency instead of doing it this way.
Just run `sc <diagnosis number>` and you will instantly be beamed to the
correcsponding shellcheck wiki error page.
E.g. `sc 3001` will transport you to 'In POSIX sh, process substitution
is undefined'.
Prefer regular 'Iosevka' font in most cases, not the highly specific
'Iosevka Nerd Font'. This may break some things back in Archlinux-land
but it is required for iosevka to be correctly displayed in Voidlinux,
and, to be honest, also feels more clean than using such a highly
specialized font for everything.
Additionally, we generally make use of both where possible, defaulting
to the more specific 'Nerd Font' family variant but falling back to
regular old Iosevka.
One exception is 'wezterm' which, though it nicely includes a font
fallback option (and a very configurable one at that), _always_ produces
a warning when the first font in a fallback list is not found -- even
when the specific 'warn_about_missing_glyphs' option is ticked. No clue
why but for now this works well enough for me.
Make more extensive using of dataclasses for typing and simpler future
refactors.
The redirects 'plugin' is now a simple class which can be imported into
the configuration and is automatically active when instantiated. For
that to work it needs access to the qutebrowser python library but that
should hopefully be a given if wanting to have a qutebrowser plugin.
To make the default redirects active, simply import the class and
instantiate it:
```python
from fossredirect import Redirects
_ = Redirects()
```
This loads the defaults and activates them in qutebrowser. Try to go to
e.g. 'reddit.com' and it will automatically open in a libreddit
frontend.
To customize the redirects, provide a custom list of Services:
```python
from fossredirect import Redirects
_ = Redirects(services=[Service(source=["fromhere.com"], target=["tohere"])])
```
It works a little more flexibly now:
Redirects contains a list of Services.
Each service is a simple data container with the following:
```python
Service(
source=["list.of", "hosts.to", "redirect.com"],
target=["farside-redirect"]
)
```
The above redirects any of the source hosts to the far-side provided
target (in this case it would be
`farside.link/farside-redirect/<original-path>`).
However we can also specify 'custom' targets if farside does not have a
service that we want to redirect.
```python
Service(
source=["list.of", "hosts.to", "redirect.com"],
target=["my-redirected-host.org"],
custom_targets=True
)
```
This directly rewrites the host to
`https://my-redirected-host.org/<original-path>`.
Lastly, we can have custom preprocess/postprocess functions which fix
some more involved redirect:
```python
Service(
source=["list.of", "hosts.to", "redirect.com"],
target=["my-redirected-host.org"],
postprocess=lambda item: item
)
```
Be aware that the functions take 'QUrl' objects so you have to access
e.g. the actual host with `item.host()` before rewriting. Look at the
breezewiki rewrite function for an easy example.
If 'yq' is found on the system, the qutedmenu script will now also
traverse any saved sessions for urls (either active or historic) and
display those as well.
Also added a simple check for the sqlite3 and yq tools and spit out a
warning if either isn't found. Program will continue unhindered and just
ignore the history/session urls respectively.
Renamed from `docker` to `hub` since I otherwise always accidentally
search the actual docker hub when I want to find solutions for docker
issues.
Also sorted search engines alphabetically.
Added privacy-aware redirects for goodreads (biblioreads) and
twitch (safetwitch). Safetwitch unfortunately requires
javascript enabled but is still heaps lighter of a website
than the official streaming one.
Farside does not offer redirects for these services yet so we
keep a manual list to redirect to for the time being.
When looking for the most up-to-date link to grab a scihub url
we used to use wikiless but now simply directly scrape from
wikipedia.
Functionality is not changed but should work much faster and
more reliably.
The redirector can now be fed with either a list of targets to pick from
(as before) or a "farside" entry which points to a farside service
redirect or multiple.
The dict entry then looks like:
```python
"quora": {
"source": ["quora.com"],
"farside": ["quetre"],
}
```
It has the source service url as usual, but then instead of a "target"
entry contains a "farside" entry.
A redirect dict entry can take both "target" and "farside" entries, but
will then always give precedence to farside choices.
This should go a long way in helping keep OSS frontends up to date. It
now mostly depends on farside entries in turn being updated.
One potential concern is the new centralization in relying on farside as
the redirect authority.
These are the redirects that made the most trouble for me, and honestly I
do not think wikipedia really belongs in the same category of 'necessary
to redirect' surveillance pages like reddit,instagram or twitter.
Updated reddit redirects once again.
Will soon have to figure out a different way of
approaching the lib- redirections with so many
services blocking/throttling/shutting down the
FOSS frontends. For now, I will bear with it.
Simple wrapper for xdg-open functionality. Simply refers
to xdg-open except if there exists mimeo on the system
which it will refer to instead.
So, a simple preference modificator for mimeo over
xdg-open since that is my preference too.
Also gave it a short name so I can do open whenever I
want and don't have to tax my left hand with tying xdg.
Since we now use dotter we can simplify the dir structure for
qutebrowser a lot. Everything dot-filed earlier can now reside
in simple directories called config (for ~/.config/qutebrowser),
data (for ~/.local/share/qutebrowser), and scripts
(for ~/.local/bin) files.
Do not allow html5 canvas reading in qutebrowser. This shuts off one of the main
avenues of browser fingerprinting (aside from cookies) still currently
undertaken. It will possibly stop some obscure streaming sites from working but
I do not care, especially at the cost of fingerprinting information.
When not showing tabs (only displaying them on actually
switchting between tabs), so far the duration that the
tabs would be displayed was just 800ms, way too short
to actually provide legible info.
This commit changes it to 2000ms, which may still be
too short but is at least more digestible.
Main linking buttons (f/F) *can* be used for this but the resulting
userscript has to account for many more different scenarios than
opening a page.
If it does not, we can not 'click' on text entry fields, dropdowns,
sliders etc with the f-buttons anymore.
This commit switches the qute-gemini script to be invoked via ,g or ,G
thus with the local leader mapping instead.
Code grabbing has been slightly refactored to always check for the
existence of the qutebrowser fifo before sending anything.
Translate has been fixed up a little to use lingva for selection
translations, only falling back to google translate for complete page
translations since I do not think any other services support this for
now.
Now possibly a little less clunky (though still using soon-to-be
deprecated modules), and able to correctly surf gemini/non-gemini pages
as a userscript or as a stand-alone script (simply calling it from
command line).
Works as before for tabbed pages (the clunky rename/symlink way).
Can now also be used as the default way to surf to links so I switched
out my qutebrowser f/F link hinting for this script. Will simply open
links if staying on http but open gemini version as local file if moving
on to gemini.
Could probably be rewritten as an actual plugin to interject itself in
link opening to be a little more elegant (similar to the redirect code I
have running to move to open source web frontends).
Both bookmarkers can now either send the current page ("s for sending to
shaarli; "w to send to wallabag) or send any link on the current page
(;s for shaarli, ;w for wallabag).
Both have been adapted to the same format, both can be sent a link as an
argument as well (./wallabag_add.sh 'myawesome.blog/entry').
Moved the qutebrowser userscript to open recently downloaded files
to be accessible as a normal shell script as well
(`recently-downloaded`).
Mapped this to Super+Shift+D in riverwm to be easily able to open
the most recent downloads from anywhere.
Double the default lines shown to 20.
Blocked hosts reside in a single (giant) plaintext file, which we
now remove from the repository.
Especially with the new blocking sources we grew from around 700k
(which was already a lot at ~35000 lines) to around 5MB which is
just stupid to keep in the git repo if we don't have to.
Since qutebrowser automatically re-creates the file for us on
running `:adblock-update` there's no reason to waste space here.
Scribe links are often not redirected correctly if belonging to medium's
'global-identity' redirections. This is a first attempt at fixing those
by removing the superfluous string from the scribe URL.
Generalized enough to work as a 'post-processing' function for the
redirection plugin, which can be set up by pointing the 'postprocess'
key of a page entry to a callable object (most likely a function).
Fixed text not flowing to the external (nvim) editor and saved text not
being brought back into qutebrowser.
Same issue as here https://github.com/qutebrowser/qutebrowser/issues/6707
it essentially amounts to the terminal not having its own running
process id which qutebrowser uses to know when the application closes.
Thus, it thinks it closes immediately and deletes the temporary file. No
changes are brought back and the file is empty for the editor.
With the fix, this does not happen anymore.
