qutebrowser development blog

still

:open -t
:open -w
:open
:winopen
:tabopen
rasengan
about:blank
--check-untyped-defs
commit 11a94957dc038fc27c5ff976197ad2b2d0352d20
Author: Florian Bruhin <git@the-compiler.org>
Date:   Sat Dec 14 22:15:16 2013 +0100

    Initial commit

qute://settings
editor.command
autoconfig.yml
config.py
from qutebrowser.browser import qutescheme
qutescheme._qute_settings_set = lambda url: ('text/html', '')

autoconfig.yml
:version
:set
:config-cycle
-u
--pattern
config.set
config.py
with config.pattern('...') as p:
config.py
tsh
S
H
u
h
tph
:session-load
--delete
--no-last
:tab-focus
--edit
:view-source
--select
:follow-hint
qute://bindings
:bind
qute://tabs
:buffer
statusbar.widgets
tabs.mode_on_change
tabs.persist_mode_on_change
restore
input.insert_mode.auto_enter
input.forward_unbound_keys
:prompt-yank
Alt-y
hostblock_blame
cycle-inputs.js
scripts/
:jseval -f
<Ctrl-X><Ctrl-C>
prompt
yesno
bindings.default
config.py
autoconfig.yml
@include
@exclude
@requires
:open-editor
:config-edit
hist_importer.py
:
/
?
<summary>
<details>
:tab-only
url.incdec_segments
port
:view-source
view-source:
:version
{url}
{{url}}
view-source:
:follow-selected
Ctrl-V
Shift-Insert
:view-source
:bookmark-add "" foo
:spawn -o
:config-source
:config-edit
:bookmark-add --toggle
completion.timestamp_format
completion.min_chars
bindings.key_mappings
QUTE_SELECTED_HTML
qutebrowser_viewsource
:view-source --edit
tabs.persist_mode_on_change
tabs.mode_on_change
python-attr
qute://help/configuring.html
qutebrowser.desktop
:set
:config-cycle
completion.web_history_max_items
-1
spellcheck.languages
qt.args
backend
:config-cycle
:config-unset
:config-clear
:config-source
config.py
:config-edit
config.py
:config-write-py
config.py
:version
qute://version
bindings.key_mappings
:download
:back
:forward
:search
<Escape>
tabs.width.pinned
:set-cmd-text
--run-on-count
:scroll-perc
:scroll-to-perc
--harfbuzz
--relaxed-config
:fullscreen
input.insert_mode.auto_load
window.hide_wayland_decoration
new-config
master
new-config
input.ambiguous_timeout
javascript.log
config.py
config.py
226 files changed, 13144 insertions(+), 14030 deletions(-)

QApplication
QApplication
:open
:download
PyOpenGL
218 files changed, 10234 insertions(+), 13768 deletions(-)

new-config
4888 passed, 170 skipped, 60 xfailed in 605.11 seconds

new-config
config.py
:set
qute://settings
bindings.commands = {
    'normal': {
        'gg': 'scroll-perc 0',
        ...
    },
    ...
}

bindings.commands
autoconfig.yml
bindings.default
bindings.commands
{}
bindings.commands
bindings.default = {}
bindings.default
:bind
:unbind
bindings.commands
bindings.key_mappings
<Ctrl-[>
<Escape>
<Ctrl-J>
<Enter>
<Enter>
<Ctrl-J>
@hypothesis.given(val=strategies.dictionaries(
    strategies.text(min_size=1), strategies.booleans()))
def test_hypothesis(val):
    d = configtypes.Dict(keytype=configtypes.String(),
                         valtype=configtypes.Bool(),
                         none_ok=True)
    try:
        converted = d.to_py(val)
        expected = converted if converted else None
        assert d.from_str(d.to_str(converted)) == expected
    except configexc.ValidationError:
        # Invalid unicode in the string, etc...
        hypothesis.assume(False)

{'x': True}
:set
{Hello: World}
{"Hello": "World"}
>>> yaml.load(json.dumps({'\U00010000': True}))
{'\ud800\udc00': True}

.to_str()
git diff
{"one": 1, "two": 2}
{"two": 2, "one": 1}
.to_doc()
.to_str()
hdiutil detach
device busy
.msi
.exe
@rcorre
master
content.user_stylesheets
content.headers.do_not_track
154 files changed, 6128 insertions(+), 7000 deletions(-)

1001 passed, 42 skipped, 10 xfailed in 374.00 seconds

:set
qute://settings
qute://settings
configtypes.py
class BaseType:

    def from_py(self, value):
        # Convert the value from a config.py or YAML file to a
        # value used by the rest of the code (and stored as
        # internally).

    def from_str(self, value):
        # Convert the value from plaintext to a value used like
        # explained above.

QColor
from_py
config.py
class BaseType:

    def from_str(self, value):
        # Convert the value from plaintext to a YAML-like value.
        # (which is also what's stored internally)

    def from_py(self, value):
        # Convert the value from how it's stored internally
        # to what is used by the rest of the code.

:set
config.py
headers = conf.content.custom_headers
headers['X-Foo'] = 'bar'

class ConfigNotifierMixin:

    def __init__(self, data, manager, option, origin):
        self._inited = False
        self._manager = manager
        self._option = option
        self._origin = origin
        super().__init__(data)
        self._inited = True

    def __getitem__(self, name):
        item = super().__getitem__(name)
        return wrap_value(item, manager=self._manager,
                          name=self._option,
                          origin=self._origin)

    def __setitem__(self, name, value):
        value = wrap_value(value, manager=self._manager,
                           name=self._option,
                           origin=self._origin)
        super().__setitem__(name, value)
        if not self._inited:
            return
        self._manager.set(self._option, self._origin)

    def __delitem__(self, name):
        super().__delitem__(name)
        if not self._inited:
            return
        self._manager.set(self._option, self._origin)

class ConfigDict(ConfigNotifierMixin, collections.UserDict):

    pass

class ConfigList(ConfigNotifierMixin, collections.UserList):

    pass

def wrap_value(val, *, manager, name, origin):
    if isinstance(val, (list, ConfigList)):
        return ConfigList(val, manager, name, origin)
    elif isinstance(val, (dict, ConfigDict)):
        return ConfigDict(val, manager, name, origin)
    else:
        return val

config.py
config.set
configtypes
:set
qute://settings
:set tabs.position left
~/.config/qutebrowser/autoconfig.yml
# DO NOT edit this file by hand, qutebrowser will overwrite it.
# Instead, create a config.py - see :help for details.

global:
  tabs.position: left

bindings.commands = {
    'normal': {
        'gg': 'scroll-perc 0',
        ...
    },
    ...
}

bindings.commands
@rcorre
new-config
master
:set
qute:config
98 files changed, 4270 insertions(+), 3865 deletions(-)

AttributeError
WTF::StringImpl::copyChars<char16_t>()
JSC::jsSpliceSubstringsWithSeparators()
JSC::replaceUsingRegExpSearch()
JSC::replace()
JSC::stringProtoFuncReplace()

"abc".replace(/a/, "b")
.replace()
(function(replace) {
    String.prototype.replace = function() {
        console.log(this, arguments);
        return replace.apply(this, arguments);
    };
})(String.prototype.replace)

jsc
s = 'xxxxxxxxxxxxxxAxxxxxxxxxxxxxxxxxxxxA–'; s.replace(/A/g, 'b')

template <typename T> static void copyChars(
    T* destination, const T* source, unsigned numCharacters)
{
  if (numCharacters == 1) {
    *destination = *source;
    return;
  }

  if (numCharacters <= s_copyCharsInlineCutOff) {
    unsigned i = 0;
#if (CPU(X86) || CPU(X86_64))
    const unsigned charsPerInt = sizeof(uint32_t) / sizeof(T);

    if (numCharacters > charsPerInt) {
      unsigned stopCount = numCharacters & ~(charsPerInt - 1);

      const uint32_t* srcCharacters =
          reinterpret_cast<const uint32_t*>(source);
      uint32_t* destCharacters =
          reinterpret_cast<uint32_t*>(destination);
      for (unsigned j = 0; i < stopCount; i += charsPerInt, ++j)
        destCharacters[j] = srcCharacters[j];
    }
#endif
    for (; i < numCharacters; ++i)
      destination[i] = source[i];
  } else
    memcpy(destination, source, numCharacters * sizeof(T));
}

memcpy
s_copyCharsInlineCutOff
memcpy
#if
j
i
#gcc
uint16_t*
uint32_t*
-fno-strict-aliasing
historyContains
new-config
class SectionStub:

    def __init__(self, conf, name):
        self._conf = conf
        self._name = name

    def __getitem__(self, item):
        return self._conf.get(self._name, item)

class NewConfigManager(QObject):

    changed = pyqtSignal(str, str)

    def __init__(self, parent=None):
        super().__init__(parent)
        self._values = {}

    def _key(self, sect, opt):
        return sect + ' -> ' + opt

    def read_defaults(self):
        for name, section in configdata.data().items():
            for key, value in section.items():
                self._values[self._key(name, key)] = value

    def get(self, section, option):
        val = self._values[self._key(section, option)]
        return val.typ.transform(val.value())

:set
configdata.py
configdata
('log-javascript-console',
  SettingValue(typ.String(
      valid_values=typ.ValidValues(
          ('none', "Don't log messages."),
          ('debug', "Log messages with debug level."),
          ('info', "Log messages with info level.")
      )), 'debug'),
  "How to log javascript console messages."),

log_javascript_console:
  type:
    name: String
    valid_values:
      - none: "Don't log messages."
      - debug: "Log messages with debug level."
      - info: "Log messages with info level."
  default: debug
  desc: "How to log javascript console messages."

import yaml
import collections

from qutebrowser.config import configdata, configtypes

data = configdata.data()
for sectname, sect in data.items():
    print()
    print("# {}".format(sectname))
    print()
    for optname, opt in sect.items():
        data = {}

        if optname in sect.descriptions:
            data['desc'] = sect.descriptions[optname]

        if isinstance(opt.typ, configtypes.Bool):
            data['type'] = opt.typ.__class__.__name__
        else:
            data['type'] = {'name': opt.typ.__class__.__name__}
            if opt.typ.valid_values:
                vv = data['type']['valid_values'] = []
                typ_vv = opt.typ.valid_values
                for val in typ_vv:
                    desc = typ_vv.descriptions.get(val)
                    if desc:
                        vv.append({val: desc})
                    else:
                        vv.append(val)

        data['default'] = opt.typ.transform(opt.default())

        if sectname in ['colors', 'fonts']:
            new_optname = (sectname + '.' +
                           optname.replace('-', '_'))
        else:
            new_optname = optname.replace('-', '_')

        print(yaml.dump({new_optname: data},
                        default_flow_style=False))

configdata.yml
colors.statusbar.bg
colors.statusbar.bg.private
conf.colors.statusbar.bg = 'black'
colors.statusbar.bg.private
.private
'black'
class ConfigContainer:

    def __init__(self, handler, prefix=''):
        self._handler = handler
        self._prefix = prefix

    def __repr__(self):
        return ('ConfigContainer(handler={!r}, prefix={!r})'
                .format(self._handler, self._prefix))

    def __getattr__(self, attr):
        return ConfigContainer(handler=self._handler,
                               prefix=self._join(attr))

    def __setattr__(self, attr, value):
        if attr.startswith('_'):
            return super().__setattr__(attr, value)
        self._handler(self._join(attr), value)

    def _join(self, attr):
        if self._prefix:
            return '{}.{}'.format(self._prefix, attr)
        else:
            return attr

conf = ConfigContainer(print)
conf.foo.bar.baz.fish = 42
conf.foo.bar.baz = 23
print(conf.foo.bar.baz.fish)

ConfigContainer(handler=<built-in function print>, prefix='foo.bar.baz.fish')
conf.foo.bar.baz()
:debug-console
{private}
window-title
$QUTE_COMMANDLINE_TEXT
ripbang
general -> print-element-backgrounds
content -> cookies-store
storage -> cache-size
colors -> webpage.bg
:download --mhtml
qute:history
:history
:jseval
--file
:session-save
--only-active-window
input -> mouse-zoom-divider
network -> proxy
pac+file://...
:enter-mode
:record-macro
q
:download --mhtml
:navigate prev/next
rel
<a>
rel
userscript
qutebrowser/
utils.prevent_exceptions
window.open()
QUTE_QTBUG54419_PATCHED=1
@qtwebengine_flaky
:scroll-page
--bottom-navigate
colors -> webpage.bg
auto-insert-mode
:insert-text
:paste-primary
webelem.classes
do-not-track
accept-language
--backend webengine
webelem.click()
webelem.hover()
hints.py
@qtwebengine_todo
@qtwebengine_skip
yankpaste.feature
QOpenGLWidget
:set
:fake-key
CommandError
:view-source
CommandError
QMenu
WebView
history
QOpenGLWidget
WebView
new-hints
hints -> opacity
:navigate prev
:navigate forward
.lower()
:open-editor
flake8
utils.javascript
tab.find_all_elements()
:navigate
HintManager
:navigate
qutebrowser.browser.navigate
_resolve_url
requirements.txt
webelem
:navigate
private-browsing
build_release.py
QTWEBENGINE_REMOTE_DEBUGGING
developer-extras
QWebEngineView
QWebEngineSettings.globalSettings()
globalSettings
.app
:<enter>
scroll.at_bottom()
return
continue
--backend webengine
:repeat-command
.
:unbind .i
:unbind .o
qute:bookmarks
:prompt-open-download
Ctrl-X
{host}
;t
:hint input
$QUTE_CONFIG_DIR
$QUTE_DATA_DIR
$QUTE_DOWNLOAD_DIR
ui
status-position
--pdf <filename>
:print
:scroll-perc
gg
;;
:edit-url
:bookmark-add
taskadd
:bookmark-del
:quickmark-del
:jump-mark
''
ui ->  display-statusbar-messages
general -> wrap-search
wrap-search = false
:edit-url
STUB: ...
scroll.to_point
:print --pdf
:print --pdf
QWebView
general -> wrap-search
true
qtwebengine
tab
QObject::destroyed
master
--backend webengine
QWebView
--backend webengine
gg
qtwebengine
--backend webengine
$QUTE_CONFIG_DIR
DATA
DOWNLOADS
qtwebengine
671 passed, 9 skipped, 8 xfailed

QWebView
master
qtwebengine
35 files changed, 2085 insertions(+), 867 deletions(-)

qtwebengine
master
--backend webengine
:undo
:buffer
:follow-selected
:debug-clear-ssl-errors
:debug-webaction
:inspect
:view-source
test_downloading_as_mhtml_is_available
test_downloading_as_mhtml_with_nonascii_headers
test_cancelling_a_mhtml_download_issue_1535
test_spawning_an_editor_successfully
test_scrollpage_with_a_very_big_value
test_starting_a_userscript_which_doesnt_exist
test_running_spawn_with_userscript
test_buffer_with_a_matching_title
test_pasting_the_primary_selection_into_an_empty_text_field
test_pasting_the_primary_selection_into_a_text_field_at_specific_position
test_pasting_the_primary_selection_into_a_text_field_with_undo
test_pasting_the_primary_selection_without_a_focused_field
test_pasting_the_primary_selection_with_a_readonly_field
scroll
tabs
downloads
editor
spawn
yankpaste
QWebEngineView
qtwebengine
hints -> letters
:scroll-perc
gg
pytest-bdd
.feature
pytest-bdd
:hint inputs
:jump-mark
'x
:repeat-command
.
$QUTE_CONFIG
:edit-url
@kvas-it
@kvas-it
@tags
.feature
@olegpidsadnyi
modeltest
@nicoddemus
:navigate
QWebEnginePage::runJavaScript
def calc(view):
    def cb(data):
        print("data: {}".format(data))
    view.page().runJavaScript('1 + 1', cb)

yield
@wrap_cb
def calc(view):
    data = yield view.page().runJavaScript, '1 + 1'
    print("data: {}".format(data))

wrap_cb
def wrap_cb(func):

    @functools.wraps(func)
    def inner(*args):
        gen = func(*args)
        arg = next(gen)

        def _send(*args):
            try:
                gen.send(*args)
            except StopIteration:
                pass

        if callable(arg):
            cb_func = arg
            args = []
        else:
            cb_func, *args = arg
        cb_func(*args, _send)

    return inner

qtwebengine
QWebView
QWebEngineView
:debug-dump-page
:jseval
{host}
:edit-url
network -> custom-headers
{url:pretty}
:jump-mark
'
:set-mark
'
''
--force-color
:messages
:set ui keyhint-blacklist *
hints -> auto-follow-timeout
:history-clear
hints -> find-implementation
javascript
:tab-focus
:yank
--pretty
:navigate
:completion-item-del
Ctrl-D
:buffer
tabs-are-windows
:bind <key>
colorlog
normal
:zoom-in
:zoom-out
+
-
hints -> scatter
-r
:hint links spawn
-v
:spawn
;Y
:hint links yank-primary
:--
:debug-console
sys.stderr
None
FileNotFoundError
private-browsing
:set
<a href=" http://example.com ">
 58
new data 59
new data 60
new data 61
new data 62
new data 63

ew data 59
new data 60
new data 61
new data 62
new data 63

> assert lineparser.get_recent(size) == data
E assert ['ew data 59\...ew data 63\n'] ==
         [' 58\n', 'new...ew data 63\n']
E   At index 0 diff: 'ew data 59\n' != ' 58\n'
E   Right contains more items, first extra item: 'new data 63\n'

\r
os.linesep
\n
# data = '\n'.join(self.BASE_DATA + new_data)
data = os.linesep.join(self.BASE_DATA + new_data)
data = [e + '\n' for e in data[-(size - 1):].splitlines()]

-(size - 1)
-size
+ os.linesep
pluggy==0.3.1
py==1.4.31
tox==2.3.1
virtualenv==15.0.2

tox
pip-compile
$ virtualenv venv
$ ./venv/bin/pip install -r requirements.txt-raw
$ ./venv/bin/pip freeze > requirements.txt

./scripts/dev/pylint_checkers
qute-pylint
#@
requirements.raw-txt
#@ comment: mypkg blah blub
mypkg
#@ filter: mypkg != 1.0.0
# rq.filter: ...
#@ ignore: mypkg, otherpkg
#@ replace: foo bar
beautifulsoup4
CherryPy
coverage
Flask==0.10.1
httpbin
...

#@ filter: Flask < 0.11.0
#@ ignore: Jinja2, MarkupSafe

# This file is automatically generated by recompile_requirements.py

beautifulsoup4==4.4.1
CherryPy==6.0.1
coverage==4.1
decorator==4.0.10
Flask==0.10.1  # rq.filter: < 0.11.0
glob2==0.4.1
httpbin==0.4.1
hypothesis==3.4.0
itsdangerous==0.24
# Jinja2==2.8
Mako==1.0.4
# MarkupSafe==0.23
parse==1.6.6
...

pip-compile
:history-clear
:set
true
false
:restart
Scenario: Going back without history
    Given I open data/backforward/1.txt
    When I run :back
    Then the error "At beginning of history." should be shown

pytest-bdd
scenario
(Pdb++) pp report.scenario
{'examples': [],
 'feature': {
     'description': '',
     'filename': '/home/me/.../tests/end2end/features/misc.feature',
     'line_number': 1,
     'name': 'Various utility commands.',
     'rel_filename': 'features/misc.feature',
     'tags': []
 },
 'line_number': 367,
 'name': 'Focusing download widget via Tab (original issue)',
 'steps': [{
               'duration': 0.05486869812011719,
               'failed': False,
               'keyword': 'When',
               'line_number': 368,
               'name': 'I open data/prompt/jsprompt.html',
               'type': 'when'
           },
           ...
 ],
 'tags': ['pyqt531_or_newer']}

conftest.py
@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
    """Add a BDD section to the test output."""
    outcome = yield
    if call.when not in ['call', 'teardown']:
        return
    report = outcome.get_result()

    if report.passed:
        return

    if (not hasattr(report.longrepr, 'addsection') or
            not hasattr(report, 'scenario')):
        return

    output = []
    output.append("Feature: {name}".format(
        name=report.scenario['feature']['name'],
    ))
    output.append(
        "  Scenario: {name} ({filename}:{line})".format(
            name=report.scenario['name'],
            filename=report.scenario['feature']['rel_filename'],
            line=report.scenario['line_number'])
    )
    for step in report.scenario['steps']:
        output.append(
            "    {keyword} {name} ({duration:.2f}s)".format(
                keyword=step['keyword'],
                name=step['name'],
                duration=step['duration'],
        )

    report.longrepr.addsection("BDD scenario", '\n'.join(output))

getElementRects()
assert QRect(5, 5, 4, 4) == QRect(10, 10, 4, 4)

{
    "left": geometry.left() - scroll_x / zoom,
    "top": geometry.top() - scroll_y / zoom,
    "right": geometry.right() - scroll_x / zoom,
    "bottom": geometry.bottom() - scroll_y / zoom,
    "width": geometry.width() / zoom,
    "height": geometry.height() / zoom,
}

{
    "left": (geometry.left() - scroll_x) / zoom,
    "top": (geometry.top() - scroll_y) / zoom,
    "right": (geometry.right() - scroll_x) / zoom,
    "bottom": (geometry.bottom() - scroll_y) / zoom,
    "width": geometry.width() / zoom,
    "height": geometry.height() / zoom,
}

geometry.left() - (0 / zoom)
geometry.left()
:tab-move
:bac
--backend webengine
--backend webengine

qutebrowser development blog

Happy 9th birthday, qutebrowser!

The death of dwb

A new browser on the horizon

Towards the first release, and then some more

Another big transition

Looking forward towards qutebrowser v3

Better nightly builds on CI, state of Qt 6 support, and steps towards v3

CVE-2021-41146: Arbitrary command execution in qutebrowser on Windows via URL handler

qutebrowser moving to Libera Chat

Paying it forward

Paving the road towards qutebrowser v2.0

Founding a company

Funding campaign

Pull request backlog

Session changes in Qt 5.15

Other bits and pieces

The road towards Qt 6 and qutebrowser v2.0.0

Qt Company and the KDE free Qt foundation

Wrapping up

2019 qutebrowser crowdfunding - reminder

qutebrowser meetup Berlin (2019-11-28)

2019 qutebrowser crowdfunding with shirts, stickers and more!

Current qutebrowser roadmap and next crowdfunding

Upcoming crowdfunding

Current priorities

Keeping qutebrowser up and running

Getting the pull request backlog down

Extension API

Increasing maintainability

Second look at the config system

tl;dr

Crowdfunding 2019 ideas

Happy birthday, qutebrowser!

CVE-2018-10895: Remote code execution due to CSRF in qutebrowser

Description

Affected versions

Timeline

Mitigation

Credits

Links

qutebrowser v1.3.3 released (security update!)

qutebrowser v1.2.0 released!

Added

Changed

Fixed

Removed

T-Shirts shipped, initial implementation of per-domain settings

Current state of per-domain settings

History

Current status

What I'm busy with

Future

qutebrowser v1.0.0 released!

Major changes

Added

Changed

Removed

Fixes

qutebrowser v1.0.0 is coming closer

New config merged!

End of the crowdfunding

The big merge

After the merge

Other work

Moving on

Config revolution - Part 1 finished

Keybindings

Testing

Unicode is hard!

configdata.yml performance

Documentation generation

New release

Completion refactoring

Miscellaneous

Refactoring more things, a working YAML config, and more!

config types

Mutables

YAML saving/restoring

Keybindings