Release v0.1.2

Regenerate docs.
Use qurl_from_user_input() in urlutils.is_url().
2015-01-09 22:30:04 +01:00 · 2015-01-09 22:28:25 +01:00 · 2015-01-09 22:26:35 +01:00 · 2015-01-09 22:26:35 +01:00 · 2015-01-09 22:26:35 +01:00 · 2015-01-09 19:27:44 +01:00
768 changed files with 31151 additions and 136145 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,19 +0,0 @@
-shallow_clone: true
-version: '{branch}-{build}'
-cache:
-  - C:\projects\qutebrowser\.cache
-build: off
-environment:
-    PYTHONUNBUFFERED: 1
-    PYTHON: C:\Python36-x64\python.exe
-    matrix:
-    - TESTENV: py36-pyqt511
-    - TESTENV: pylint
-
-install:
-  - '%PYTHON% -m pip install -U pip'
-  - '%PYTHON% -m pip install -r misc\requirements\requirements-tox.txt'
-  - 'set PATH=C:\Python36-x64;%PATH'
-
-test_script:
-  - '%PYTHON% -m tox -e %TESTENV%'
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -1,7 +0,0 @@
-coverage:
-  status:
-    project: off
-    patch: off
-    changes: off
-
-comment: off
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,19 +0,0 @@
-[run]
-source = qutebrowser
-branch = true
-omit =
-    qutebrowser/__main__.py
-    */__init__.py
-    qutebrowser/resources.py
-
-[report]
-exclude_lines =
-    pragma: no cover
-    def __repr__
-    raise AssertionError
-    raise NotImplementedError
-    raise utils\.Unreachable
-    if __name__ == ["']__main__["']:
-
-[xml]
-output=coverage.xml
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,17 +0,0 @@
-[*]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-charset = utf-8
-
-max_line_length = 79
-
-indent_style = space
-indent_size = 4
-
-[*.yml]
-indent_size = 2
-
-[*.feature]
-max_line_length = 9999
-
--- a/.flake8
+++ b/.flake8
@@ -1,54 +1,19 @@
+# vim: ft=dosini fileencoding=utf-8:
+
 [flake8]
-exclude = .*,__pycache__,resources.py
-# B001: bare except
-# B008: Do not perform calls in argument defaults. (fine with some Qt stuff)
-# B305: .next() (false-positives)
-# E128: continuation line under-indented for visual indent
-# E226: missing whitespace around arithmetic operator
+# E241: Multiple spaces after ,
 # E265: Block comment should start with '#'
-# E501: Line too long
-# E402: module level import not at top of file
-# E266: too many leading '#' for block comment
-# E722: do not use bare except
-# E731: do not assign a lambda expression, use a def
-#       (for pytest's __tracebackhide__)
+# checked by pylint:
 # F401: Unused import
-# N802: function name should be lowercase
-# N806: variable in function should be lowercase
-# P101: format string does contain unindexed parameters
-# P102: docstring does contain unindexed parameters
-# P103: other string does contain unindexed parameters
-# D102: Missing docstring in public method (will be handled by others)
-# D103: Missing docstring in public function (will be handled by others)
-# D104: Missing docstring in public package (will be handled by others)
-# D105: Missing docstring in magic method (will be handled by others)
-# D106: Missing docstring in public nested class (will be handled by others)
-# D107: Missing docstring in __init__ (will be handled by others)
-# D209: Blank line before closing """ (removed from PEP257)
-# D211: No blank lines allowed before class docstring
-#       (PEP257 got changed, but let's stick to the old standard)
-# D401: First line should be in imperative mood (okay sometimes)
-# D402: First line should not be function's signature (false-positives)
-# D403: First word of the first line should be properly capitalized
-#       (false-positives)
-# D413: Missing blank line after last section (not in pep257?)
-# A003: Builtin name for class attribute (needed for overridden methods)
-ignore =
-    B001,B008,B305,
-    E128,E226,E265,E501,E402,E266,E722,E731,
-    F401,
-    N802,
-    P101,P102,P103,
-    D102,D103,D106,D107,D104,D105,D209,D211,D401,D402,D403,D413,
-    A003
-min-version = 3.4.0
-max-complexity = 12
-per-file-ignores =
-    /tests/**/*.py : D100,D101,D401
-    /tests/unit/browser/test_history.py : N806
-    /tests/helpers/fixtures.py : N806
-    /tests/unit/browser/webkit/http/test_content_disposition.py : D400
-    /scripts/dev/ci/appveyor_install.py : FI53
-copyright-check = True
-copyright-regexp = # Copyright [\d-]+ .*
-copyright-min-file-size = 110
+# E501: Line too long
+# F821: undefined name
+# F841: unused variable
+# E222: Multiple spaces after operator
+# F811: Redifiniton
+# W292: No newline at end of file
+# E701: multiple statements on one line
+# E702: multiple statements on one line
+# E225: missing whitespace around operator
+ignore=E241,E265,F401,E501,F821,F841,E222,F811,W292,E701,E702,E225
+max_complexity = 12
+exclude = ez_setup.py
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,12 +0,0 @@
-qutebrowser/browser/history.py  @rcorre
-qutebrowser/completion/*  @rcorre
-qutebrowser/misc/sql.py  @rcorre
-tests/end2end/features/completion.feature  @rcorre
-tests/end2end/features/test_completion_bdd.py  @rcorre
-tests/unit/browser/test_history.py  @rcorre
-tests/unit/completion/*  @rcorre
-tests/unit/misc/test_sql.py  @rcorre
-
-qutebrowser/config/configdata.yml  @mschilli87
-
-qutebrowser/javascript/caret.js @artur-shaik
--- a/.github/CODE_OF_CONDUCT.md
+++ b/.github/CODE_OF_CONDUCT.md
@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at mail@qutebrowser.org. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
--- a/.github/CONTRIBUTING.asciidoc
+++ b/.github/CONTRIBUTING.asciidoc
@@ -1,17 +0,0 @@
-IMPORTANT: I'm currently (July 2018) more busy than usual until September,
-because of exams coming up. Review of non-trivial pull requests will thus be
-delayed until then. If you're reading this note after mid-September, please
-open an issue.
-
- Before you start to work on something, please leave a comment on the relevant
-  issue (or open one). This makes sure there is no duplicate work done.
-
- Either run the testsuite locally, or keep an eye on Travis CI / AppVeyor
-  after pushing changes.
-
- If you are stuck somewhere or have questions,
-  https://github.com/qutebrowser/qutebrowser#getting-help[please ask]!
-
-See the full contribution documentation for details and other useful hints:
-
-include::../doc/contributing.asciidoc[]
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,2 +0,0 @@
-<!-- If this is a bug report, please remember to mention your version info from
-`:open qute:version` or `qutebrowser --version` -->
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,5 @@
 __pycache__
-*.py~
 *.pyc
-*.swp
 /build
 /dist
 /qutebrowser.egg-info
@@ -12,33 +10,6 @@ __pycache__
 /setuptools-*.egg
 /setuptools-*.zip
 /qutebrowser/git-commit-id
-/qutebrowser/3rdparty
 /doc/*.html
 /README.html
 /qutebrowser/html/doc/
-/qutebrowser/html/*.html
-/.venv*
-/.coverage
-/htmlcov
-/coverage.xml
-/.coverage.*
-/.tox
-/testresults.html
-/.cache
-/.pytest_cache
-/.testmondata
-/.hypothesis
-/.mypy_cache
-/prof
-/venv
-TODO
-/scripts/testbrowser/cpp/webkit/Makefile
-/scripts/testbrowser/cpp/webkit/main.o
-/scripts/testbrowser/cpp/webkit/testbrowser
-/scripts/testbrowser/cpp/webkit/.qmake.stash
-/scripts/testbrowser/cpp/webengine/Makefile
-/scripts/testbrowser/cpp/webengine/main.o
-/scripts/testbrowser/cpp/webengine/testbrowser
-/scripts/testbrowser/cpp/webengine/.qmake.stash
-/scripts/dev/pylint_checkers/qute_pylint.egg-info
-/misc/file_version_info.txt
--- a/.pydocstylerc
+++ b/.pydocstylerc
@@ -1,13 +0,0 @@
-[pydocstyle]
-# Disabled checks:
-# D102: Missing docstring in public method (will be handled by others)
-# D103: Missing docstring in public function (will be handled by others)
-# D104: Missing docstring in public package (will be handled by others)
-# D105: Missing docstring in magic method (will be handled by others)
-# D209: Blank line before closing """ (removed from PEP257)
-# D211: No blank lines allowed before class docstring
-#       (PEP257 got changed, but let's stick to the old standard)
-# D402: First line should not be function's signature (false-positives)
-ignore = D102,D103,D104,D105,D209,D211,D402
-match = (?!resources|test_*).*\.py
-inherit = false
--- a/.pylintrc
+++ b/.pylintrc
@@ -1,77 +1,56 @@
 # vim: ft=dosini fileencoding=utf-8:

 [MASTER]
-ignore=resources.py
-extension-pkg-whitelist=PyQt5,sip
-load-plugins=qute_pylint.config,
-             qute_pylint.modeline,
-             qute_pylint.openencoding,
-             qute_pylint.settrace,
-             pylint.extensions.bad_builtin,
-             pylint.extensions.docstyle
-persistent=n
+ignore=ez_setup.py

 [MESSAGES CONTROL]
-enable=all
-disable=locally-disabled,
-        locally-enabled,
-        suppressed-message,
+disable=no-self-use,
+        super-on-old-class,
+        old-style-class,
+        abstract-class-little-used,
+        bad-builtin,
+        star-args,
        fixme,
-        no-self-use,
-        cyclic-import,
-        blacklisted-name,
-        logging-format-interpolation,
-        logging-not-lazy,
-        broad-except,
-        bare-except,
-        eval-used,
-        exec-used,
        global-statement,
-        wrong-import-position,
-        duplicate-code,
-        no-else-return,
+        no-init,
+        locally-disabled,
        too-many-ancestors,
+        too-few-public-methods,
        too-many-public-methods,
+        cyclic-import,
+        bad-option-value,
+        bad-continuation,
        too-many-instance-attributes,
-        too-many-lines,
-        too-many-return-statements,
-        too-many-boolean-expressions,
-        too-many-locals,
-        too-many-branches,
-        too-many-statements,
-        too-few-public-methods
+        unnecessary-lambda,
+        blacklisted-name,
+        too-many-lines

 [BASIC]
-function-rgx=[a-z_][a-z0-9_]{2,50}$
+module-rgx=(__)?[a-z][a-z0-9_]*(__)?$
+function-rgx=([a-z_][a-z0-9_]{2,30}|setUpModule|tearDownModule)$
 const-rgx=[A-Za-z_][A-Za-z0-9_]{0,30}$
-method-rgx=[a-z_][A-Za-z0-9_]{1,50}$
+method-rgx=[a-z_][A-Za-z0-9_]{2,40}$
 attr-rgx=[a-z_][a-z0-9_]{0,30}$
-class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{1,30}|(__.*__))$
 argument-rgx=[a-z_][a-z0-9_]{0,30}$
 variable-rgx=[a-z_][a-z0-9_]{0,30}$
-docstring-min-length=3
-no-docstring-rgx=(^_|^main$)
+class-attribute-rgx=[A-Za-z_][A-Za-z0-9_]{1,30}$
+inlinevar-rgx=[a-z_][a-z0-9_]*$

 [FORMAT]
 max-line-length=79
-ignore-long-lines=(<?https?://|^# Copyright 201\d)
-expected-line-ending-format=LF
+ignore-long-lines=<?https?://
+
+[SIMILARITIES]
+min-similarity-lines=8

 [VARIABLES]
 dummy-variables-rgx=_.*

+[CLASSES]
+defining-attr-methods=__init__,__new__,setUp
+
 [DESIGN]
 max-args=10

-[CLASSES]
-valid-metaclass-classmethod-first-arg=cls
-
 [TYPECHECK]
-ignored-modules=PyQt5,PyQt5.QtWebKit
-
-[IMPORTS]
-# WORKAROUND
-# For some reason, pylint doesn't know about some Python 3 modules on
-# AppVeyor...
-known-standard-library=faulthandler,http,enum,tokenize,posixpath,importlib,types
-known-third-party=sip
+ignored-classes=WebElementWrapper,AnsiCodes,UnsetObject
--- a/.pyup.yml
+++ b/.pyup.yml
@@ -1 +0,0 @@
-schedule: "every week on monday"
--- a/.run_checks
+++ b/.run_checks
@@ -0,0 +1,20 @@
+# vim: ft=dosini
+
+[DEFAULT]
+targets=qutebrowser,scripts
+
+[pep257]
+# D102: Docstring missing, will be handled by others
+# D209: Blank line before closing """ (removed from PEP257)
+# D402: First line should not be function's signature (false-positives)
+disable=D102,D209,D402
+exclude=test_.*
+
+[pylint]
+args=--output-format=colorized,--reports=no,--rcfile=.pylintrc
+plugins=config,crlf,modeline,settrace,openencoding
+exclude=resources.py
+
+[flake8]
+args=--config=.flake8
+exclude=resources.py
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,98 +0,0 @@
-sudo: false
-dist: trusty
-language: python
-group: edge
-python: 3.6
-
-matrix:
-  include:
-    - os: linux
-      env: DOCKER=archlinux
-      services: docker
-    - os: linux
-      env: DOCKER=archlinux-webengine QUTE_BDD_WEBENGINE=true
-      services: docker
-    - os: linux
-      env: TESTENV=py36-pyqt571
-    - os: linux
-      python: 3.5
-      env: TESTENV=py35-pyqt571
-    - os: linux
-      env: TESTENV=py36-pyqt59
-    - os: linux
-      env: TESTENV=py36-pyqt510
-    - os: linux
-      env: TESTENV=py36-pyqt511-cov
-    # https://github.com/travis-ci/travis-ci/issues/9069
-    - os: linux
-      python: 3.7
-      sudo: required
-      dist: xenial
-      env: TESTENV=py37-pyqt511
-    - os: osx
-      env: TESTENV=py37 OSX=sierra
-      osx_image: xcode9.2
-      language: generic
-    # https://github.com/qutebrowser/qutebrowser/issues/2013
-    # - os: osx
-    #   env: TESTENV=py35 OSX=yosemite
-    #   osx_image: xcode6.4
-    - os: linux
-      env: TESTENV=pylint PYTHON=python3.6
-    - os: linux
-      env: TESTENV=flake8
-    - os: linux
-      env: TESTENV=docs
-      addons:
-         apt:
-           packages:
-           - asciidoc
-    - os: linux
-      env: TESTENV=vulture
-    - os: linux
-      env: TESTENV=misc
-    - os: linux
-      env: TESTENV=pyroma
-    - os: linux
-      env: TESTENV=check-manifest
-    - os: linux
-      env: TESTENV=eslint
-      language: node_js
-      python: null
-      node_js: "lts/*"
-    - os: linux
-      language: generic
-      env: TESTENV=shellcheck
-      services: docker
-  fast_finish: true
-
-cache:
-  directories:
-    - $HOME/.cache/pip
-    - $HOME/build/qutebrowser/qutebrowser/.cache
-
-install:
-  - bash scripts/dev/ci/travis_install.sh
-  - ulimit -c unlimited
-
-script:
-  - bash scripts/dev/ci/travis_run.sh
-
-after_success:
-  - '[[ $TESTENV == *-cov ]] && codecov -e TESTENV -X gcov'
-
-after_failure:
-  - bash scripts/dev/ci/travis_backtrace.sh
-
-notifications:
-  webhooks:
-    - https://buildtimetrend.herokuapp.com/travis
-  irc:
-    channels:
-      - "chat.freenode.net#qutebrowser-dev"
-    on_success: always
-    on_failure: always
-    skip_join: true
-    template:
-      - "%{repository}#%{build_number} (%{branch} - %{commit} : %{author}): %{message}"
-      - "%{compare_url} - %{build_url}"
--- a/0
+++ b/0
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,43 +1,17 @@
-recursive-include qutebrowser *.py
-recursive-include qutebrowser/img *.svg *.png
-recursive-include qutebrowser/javascript *.js
-graft qutebrowser/html
-graft qutebrowser/3rdparty
-graft icons
-graft doc/img
-graft misc/apparmor
-graft misc/userscripts
-graft misc/requirements
-recursive-include scripts *.py *.sh *.js
-include qutebrowser/utils/testfile
-include qutebrowser/git-commit-id
-include LICENSE doc/* README.asciidoc
-include misc/qutebrowser.desktop
-include misc/qutebrowser.appdata.xml
-include misc/Makefile
-include requirements.txt
-include tox.ini
-include qutebrowser.py
-include misc/cheatsheet.svg
-include qutebrowser/config/configdata.yml
-
-prune www
-prune scripts/dev
-prune scripts/testbrowser/cpp
-prune .github
-exclude scripts/asciidoc2html.py
-recursive-exclude doc *.asciidoc
-include doc/qutebrowser.1.asciidoc
-include doc/changelog.asciidoc
-prune tests
-prune qutebrowser/3rdparty
-exclude pytest.ini
-exclude qutebrowser/javascript/.eslintrc.yaml
-exclude qutebrowser/javascript/.eslintignore
-exclude doc/help
-exclude .*
-exclude misc/qutebrowser.spec
-exclude misc/qutebrowser.nsi
-exclude misc/qutebrowser.rcc
-
-global-exclude __pycache__ *.pyc *.pyo
+recursive-include qutebrowser/html *.html
+recursive-include qutebrowser/test *.py
+recursive-include icons *
+include qutebrowser/test/testfile
+include qutebrowser/git-commit-id
+include COPYING doc/* README.asciidoc
+include qutebrowser.desktop
+
+exclude scripts/run_checks.py
+exclude scripts/cleanup.py
+exclude scripts/minimal_webkit_testbrowser.py
+exclude scripts/run_profile.py
+exclude scripts/generate_authors.sh
+exclude .flake8
+exclude .pylintrc
+exclude doc/notes
+prune pkg
--- a/README.asciidoc
+++ b/README.asciidoc
@@ -1,40 +1,36 @@
 // If you are reading this in plaintext or on PyPi:
 //
 // A rendered version is available at:
-// https://github.com/qutebrowser/qutebrowser/blob/master/README.asciidoc
+// https://github.com/The-Compiler/qutebrowser/blob/master/README.asciidoc

 qutebrowser
 ===========

-// QUTE_WEB_HIDE
-image:icons/qutebrowser-64x64.png[qutebrowser logo] *A keyboard-driven, vim-like browser based on PyQt5 and Qt.*
+image:icons/qutebrowser-64x64.png[] _A keyboard-driven, vim-like browser based
+on PyQt5 and QtWebKit._

-image:https://travis-ci.org/qutebrowser/qutebrowser.svg?branch=master["Build Status", link="https://travis-ci.org/qutebrowser/qutebrowser"]
-image:https://ci.appveyor.com/api/projects/status/5pyauww2k68bbow2/branch/master?svg=true["AppVeyor build status", link="https://ci.appveyor.com/project/qutebrowser/qutebrowser"]
-image:https://codecov.io/github/qutebrowser/qutebrowser/coverage.svg?branch=master["coverage badge",link="https://codecov.io/github/qutebrowser/qutebrowser?branch=master"]
-
-link:https://www.qutebrowser.org[website] | link:https://blog.qutebrowser.org[blog] | https://github.com/qutebrowser/qutebrowser/blob/master/doc/faq.asciidoc[FAQ] | https://www.qutebrowser.org/doc/contributing.html[contributing] | link:https://github.com/qutebrowser/qutebrowser/releases[releases] | https://github.com/qutebrowser/qutebrowser/blob/master/doc/install.asciidoc[installing]
-// QUTE_WEB_HIDE_END
-
-qutebrowser is a keyboard-focused browser with a minimal GUI. It's based
-on Python and PyQt5 and free software, licensed under the GPL.
+qutebrowser is a keyboard-focused browser with with a minimal GUI. It's based
+on Python, PyQt5 and QtWebKit and free software, licensed under the GPL.

 It was inspired by other browsers/addons like dwb and Vimperator/Pentadactyl.

 Screenshots
 -----------

-image:doc/img/main.png["screenshot 1",width=300,link="doc/img/main.png"]
-image:doc/img/downloads.png["screenshot 2",width=300,link="doc/img/downloads.png"]
-image:doc/img/completion.png["screenshot 3",width=300,link="doc/img/completion.png"]
-image:doc/img/hints.png["screenshot 4",width=300,link="doc/img/hints.png"]
+image:doc/img/main.png[width=300,link="doc/img/main.png"]
+image:doc/img/downloads.png[width=300,link="doc/img/downloads.png"]
+image:doc/img/completion.png[width=300,link="doc/img/completion.png"]
+image:doc/img/hints.png[width=300,link="doc/img/hints.png"]

 Downloads
 ---------

-See the https://github.com/qutebrowser/qutebrowser/releases[github releases
-page] for available downloads and the link:doc/install.asciidoc[INSTALL] file for
-detailed instructions on how to get qutebrowser running on various platforms.
+See the https://github.com/The-Compiler/qutebrowser/releases[github releases
+page] for available downloads (currently a source archive, and standalone
+packages as well as MSI installers for Windows).
+
+See link:doc/INSTALL.asciidoc[INSTALL] for detailed instructions on how to get
+qutebrowser running for various platforms.

 Documentation
 -------------
@@ -42,17 +38,13 @@ Documentation
 In addition to the topics mentioned in this README, the following documents are
 available:

-* https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-big.png[Key binding cheatsheet]: +
-image:https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-small.png["qutebrowser key binding cheatsheet",link="https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-big.png"]
+* A http://qutebrowser.org/img/cheatsheet-big.png[keybinding cheatsheet]: +
+image:http://qutebrowser.org/img/cheatsheet-small.png["qutebrowser keybinding cheatsheet",link="http://qutebrowser.org/img/cheatsheet-big.png"]
 * link:doc/quickstart.asciidoc[Quick start guide]
-* https://www.shortcutfoo.com/app/dojos/qutebrowser[Free training course] to remember those key bindings
-* link:doc/faq.asciidoc[Frequently asked questions]
-* link:doc/help/configuring.asciidoc[Configuring qutebrowser]
-* link:doc/contributing.asciidoc[Contributing to qutebrowser]
-* link:doc/install.asciidoc[Installing qutebrowser]
-* link:doc/changelog.asciidoc[Change Log]
+* link:doc/FAQ.asciidoc[Frequently asked questions]
+* link:doc/HACKING.asciidoc[HACKING]
+* link:doc/INSTALL.asciidoc[INSTALL]
 * link:doc/stacktrace.asciidoc[Reporting segfaults]
-* link:doc/userscripts.asciidoc[How to write userscripts]

 Getting help
 ------------
@@ -65,19 +57,11 @@ message to the
 https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[mailinglist] at
 mailto:qutebrowser@lists.qutebrowser.org[].

-There's also an https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser-announce[announce-only mailinglist]
-at mailto:qutebrowser-announce@lists.qutebrowser.org[] (the announcements also
-get sent to the general qutebrowser@ list).
-
-If you're a reddit user, there's a
-https://www.reddit.com/r/qutebrowser/[/r/qutebrowser] subreddit there.
-
 Contributions / Bugs
 --------------------

 You want to contribute to qutebrowser? Awesome! Please read
-link:doc/contributing.asciidoc[the contribution guidelines] for details and
-useful hints.
+link:doc/HACKING.asciidoc[HACKING] for details and useful hints.

 If you found a bug or have a feature request, you can report it in several
 ways:
@@ -89,43 +73,34 @@ https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[mailinglist] at
 mailto:qutebrowser@lists.qutebrowser.org[].

 For security bugs, please contact me directly at mail@qutebrowser.org, GPG ID
-https://www.the-compiler.org/pubkey.asc[0x916eb0c8fd55a072].
+http://www.the-compiler.org/pubkey.asc[0xFD55A072].

 Requirements
 ------------

 The following software and libraries are required to run qutebrowser:

-* http://www.python.org/[Python] 3.5 or newer (3.6 recommended)
-* http://qt.io/[Qt] 5.7.1 or newer (5.11.1 recommended) with the following modules:
-  - QtCore / qtbase
-  - QtQuick (part of qtbase in some distributions)
-  - QtSQL (part of qtbase in some distributions)
-  - QtOpenGL
-  - QtWebEngine, or
-  - QtWebKit - only the
-    link:https://github.com/annulen/webkit/wiki[updated fork] (5.212) is
-    supported
-* http://www.riverbankcomputing.com/software/pyqt/intro[PyQt] 5.7.0 or newer
-  (5.11.2 recommended) for Python 3
+* http://www.python.org/[Python] 3.4
+* http://qt-project.org/[Qt] 5.2.0 or newer (5.4 recommended)
+* QtWebKit
+* http://www.riverbankcomputing.com/software/pyqt/intro[PyQt] 5.2.0 or newer
+(5.3.2 recommended) for Python 3
 * https://pypi.python.org/pypi/setuptools/[pkg_resources/setuptools]
 * http://fdik.org/pyPEG/[pyPEG2]
 * http://jinja.pocoo.org/[jinja2]
 * http://pygments.org/[pygments]
-* https://github.com/yaml/pyyaml[PyYAML]
-* http://www.attrs.org/[attrs]

-The following libraries are optional:
+To generate the documentation for the `:help` command, when using the git
+repository (rather than a release), http://asciidoc.org/[asciidoc] is needed.

-* http://cthedot.de/cssutils/[cssutils] (for an improved `:download --mhtml`
-  with QtWebKit).
-* On Windows, https://pypi.python.org/pypi/colorama/[colorama] for colored log
-  output.
-* http://asciidoc.org/[asciidoc] to generate the documentation for the `:help`
-  command, when using the git repository (rather than a release).
+The following libraries are optional and provide colored logging in the
+console:

-See link:doc/install.asciidoc[the documentation] for directions on how to
-install qutebrowser and its dependencies.
+* https://pypi.python.org/pypi/colorlog/[colorlog]
+* On Windows: https://pypi.python.org/pypi/colorama/[colorama]
+
+See link:doc/INSTALL.asciidoc[INSTALL] for directions on how to install
+qutebrowser and its dependencies.

 Donating
 --------
@@ -146,63 +121,79 @@ get in touch!
 Authors
 -------

-qutebrowser's primary author is Florian Bruhin (The Compiler), but qutebrowser
-wouldn't be what it is without the help of
-https://github.com/qutebrowser/qutebrowser/graphs/contributors[hundreds of contributors]!
+Contributors, sorted by the number of commits in descending order:

-Additionally, the following people have contributed graphics:
+// QUTE_AUTHORS_START
+* Florian Bruhin
+* Claude
+* John ShaggyTwoDope Jenkins
+* rikn00
+* Brian Jackson
+* Martin Zimmermann
+* Error 800
+* Mathias Fussenegger
+* Larry Hynes
+* Johannes Altmanninger
+* Joel Torstensson
+* Regina Hug
+* Peter Vilim
+* Matthias Lisin
+* Helen Sherwood-Taylor
+// QUTE_AUTHORS_END

-* Jad/link:http://yelostudio.com[yelo] (new icon)
-* WOFall (original icon)
-* regines (key binding cheatsheet)
+The following people have contributed graphics:

-Also, thanks to everyone who contributed to one of qutebrowser's
-link:doc/backers.asciidoc[crowdfunding campaigns]!
+* WOFall (icon)
+* regines (keybinding cheatsheet)

-Similar projects
----------------
+Thanks / Similiar projects
+--------------------------
+
+Many projects with a similar goal as qutebrowser exist:
+
+* http://portix.bitbucket.org/dwb/[dwb] (C, GTK+ with WebKit1, currently
+http://www.reddit.com/r/linux/comments/2huqbc/dwb_abandoned/[unmaintained] -
+main inspiration for qutebrowser)
+* https://github.com/fanglingsu/vimb[vimb] (C, GTK+ with WebKit1, active)
+* http://sourceforge.net/p/vimprobable/wiki/Home/[vimprobable] (C, GTK+ with
+WebKit1, dead)
+* http://surf.suckless.org/[surf] (C, GTK+ with WebKit1, active)
+* https://mason-larobina.github.io/luakit/[luakit] (C/Lua, GTK+ with
+WebKit1, not very active)
+* http://pwmt.org/projects/jumanji/[jumanji] (C, GTK+ with WebKit1, not very
+active)
+* http://www.uzbl.org/[uzbl] (C, GTK+ with WebKit1/WebKit2, active)
+* http://conkeror.org/[conkeror] (Javascript, Emacs-like, XULRunner/Gecko,
+active)
+* https://github.com/AeroNotix/lispkit[lispkit] (quite new, lisp, GTK+ with
+WebKit, active)
+* http://www.vimperator.org/[Vimperator] (Firefox addon)
+* http://5digits.org/pentadactyl/[Pentadactyl] (Firefox addon)
+* https://github.com/akhodakivskiy/VimFx[VimFx] (Firefox addon)
+* https://github.com/1995eaton/chromium-vim[cVim] (Chrome/Chromium addon)
+* http://vimium.github.io/[vimium] (Chrome/Chromium addon)
+* https://chrome.google.com/webstore/detail/vichrome/gghkfhpblkcmlkmpcpgaajbbiikbhpdi?hl=en[ViChrome] (Chrome/Chromium addon)
+* https://github.com/jinzhu/vrome[Vrome] (Chrome/Chromium addon)

-Many projects with a similar goal as qutebrowser exist.
 Most of them were inspirations for qutebrowser in some way, thanks for that!

-Active
-~~~~~~
+Thanks as well to the following projects and people for helping me with
+problems and helpful hints:

-* https://fanglingsu.github.io/vimb/[vimb] (C, GTK+ with WebKit2)
-* https://luakit.github.io/luakit/[luakit] (C/Lua, GTK+ with WebKit2)
-* http://surf.suckless.org/[surf] (C, GTK+ with WebKit1/WebKit2)
-* http://www.uzbl.org/[uzbl] (C, GTK+ with WebKit1/WebKit2)
-* Chrome/Chromium addons:
-  https://github.com/1995eaton/chromium-vim[cVim],
-  http://vimium.github.io/[Vimium],
-  https://github.com/brookhong/Surfingkeys[Surfingkeys],
-  https://key.saka.io/[Saka Key]
-* Firefox addons (based on WebExtensions):
-  https://addons.mozilla.org/en-GB/firefox/addon/vimium-ff/[Vimium-FF] (experimental),
-  https://key.saka.io[Saka Key],
-  https://github.com/ueokande/vim-vixen[Vim Vixen],
-  https://github.com/shinglyu/QuantumVim[QuantumVim],
-  https://github.com/cmcaine/tridactyl[Tridactyl] (working
-  on a https://bugzilla.mozilla.org/show_bug.cgi?id=1215061[better API] for
-  keyboard integration in Firefox).
+* http://eric-ide.python-projects.org/[eric5] / Detlev Offenbach
+* https://code.google.com/p/devicenzo/[devicenzo]
+* portix
+* seir
+* nitroxleecher

-Inactive
-~~~~~~~~
+Also, thanks to:

-* https://bitbucket.org/portix/dwb[dwb] (C, GTK+ with WebKit1,
-https://bitbucket.org/portix/dwb/pull-requests/22/several-cleanups-to-increase-portability/diff[unmaintained] -
-main inspiration for qutebrowser)
-* http://sourceforge.net/p/vimprobable/wiki/Home/[vimprobable] (C, GTK+ with
-  WebKit1)
-* http://pwmt.org/projects/jumanji/[jumanji] (C, GTK+ with WebKit1)
-* http://conkeror.org/[conkeror] (Javascript, Emacs-like, XULRunner/Gecko)
-* Firefox addons (not based on WebExtensions or no recent activity):
-  http://www.vimperator.org/[Vimperator],
-  http://5digits.org/pentadactyl/[Pentadactyl],
-  https://github.com/akhodakivskiy/VimFx[VimFx],
-* Chrome/Chromium addons:
-  https://chrome.google.com/webstore/detail/vichrome/gghkfhpblkcmlkmpcpgaajbbiikbhpdi?hl=en[ViChrome],
-  https://github.com/jinzhu/vrome[Vrome]
+* Everyone who had the patience to test qutebrowser before v0.1.
+* Everyone triaging/fixing my bugs in the
+https://bugreports.qt-project.org/secure/Dashboard.jspa[Qt bugtracker]
+* Everyone answering my questions on http://stackoverflow.com/[Stack Overflow]
+and in IRC.
+* All the projects which were a great help while developing qutebrowser.

 License
 -------
@@ -218,15 +209,4 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
-
-pdf.js
------
-
-qutebrowser optionally uses https://github.com/mozilla/pdf.js/[pdf.js] to
-display PDF files in the browser. Windows releases come with a bundled pdf.js.
-
-pdf.js is distributed under the terms of the Apache License. You can
-find a copy of the license in `qutebrowser/3rdparty/pdfjs/LICENSE` (in the
-Windows release or after running `scripts/dev/update_3rdparty.py`), or online
-http://www.apache.org/licenses/LICENSE-2.0.html[here].
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
--- a/doc/FAQ.asciidoc
+++ b/doc/FAQ.asciidoc
@@ -0,0 +1,117 @@
+Frequently asked questions
+==========================
+The Compiler <mail@qutebrowser.org>
+
+[qanda]
+What is qutebrowser based on?::
+    qutebrowser uses http://www.python.org/[Python], http://qt-project.org/[Qt]
+    and http://www.riverbankcomputing.com/software/pyqt/intro[PyQt].
+
+The concept of it is largely inspired by http://portix.bitbucket.org/dwb/[dwb]
+and http://www.vimperator.org/vimperator[Vimperator]. Many actions and
+keybindings are similar to dwb.
+
+Why another browser?::
+    It might be hard to believe, but I didn't find any browser which I was
+    happy with, so I started to write my own. Also, I needed a project to get
+    into writing GUI applications with Python and
+    link:http://qt-project.org/[Qt]/link:http://www.riverbankcomputing.com/software/pyqt/intro[PyQt].
+
+Read the next few questions to find out why I was unhappy with existing
+software.
+
+What's wrong with link:http://portix.bitbucket.org/dwb/[dwb]/link:http://sourceforge.net/projects/vimprobable/[vimprobable]/link:https://mason-larobina.github.io/luakit/[luakit]/link:http://pwmt.org/projects/jumanji/[jumanji]/... (projects based on WebKitGTK)?::
+    Most of them are based on the http://webkitgtk.org/[WebKitGTK+]
+    http://webkitgtk.org/reference/webkitgtk/stable/index.html[WebKit1] API,
+    which causes a lot of crashes. As the GTK API using WebKit1 is
+    https://lists.webkit.org/pipermail/webkit-gtk/2014-March/001821.html[deprecated],
+    these bugs are never going to be fixed.
+
+The newer http://webkitgtk.org/reference/webkit2gtk/stable/index.html[WebKit2
+API] seems to lack basic features like proxy support, and almost no projects
+seem to have started porting to WebKit2 (I only know of
+http://www.uzbl.org/[uzbl]).
+
+qutebrowser uses http://qt-project.org/[Qt] and
+http://qt-project.org/wiki/QtWebKit[QtWebKit] instead, which suffers from far
+less such crashes. It might switch to
+http://qt-project.org/wiki/QtWebEngine[QtWebEngine] in the future, which is
+based on Google's https://en.wikipedia.org/wiki/Blink_(layout_engine)[Blink]
+rendering engine.
+
+What's wrong with https://www.mozilla.org/en-US/firefox/new/[Firefox] and link:http://5digits.org/pentadactyl/[Pentadactyl]/link:http://www.vimperator.org/vimperator[Vimperator]?::
+    Firefox likes to break compatibility with addons on each upgrade, gets
+    slower and more bloated with every upgrade, and has some
+    https://blog.mozilla.org/advancingcontent/2014/02/11/publisher-transformation-with-users-at-the-center/[horrible
+    ideas] lately.
+
+Also, developing addons for it is a nightmare.
+
+What's wrong with http://www.chromium.org/Home[Chromium] and https://vimium.github.io/[Vimium]?::
+    The Chrome plugin API doesn't seem to allow much freedom for plugin
+    writers, which results in Vimium not really having all the features you'd
+    expect from a proper minimal, vim-like browser.
+
+Why Python?::
+    I enjoy writing Python since 2011, which made it one of the possible
+    choices. I wanted to use http://qt-project.org/[Qt] because of
+    http://qt-project.org/wiki/QtWebKit[QtWebKit] so I didn't have
+    http://qt-project.org/wiki/Category:LanguageBindings[many other choices]. I
+    don't like C++ and can't write it very well, so that wasn't an alternative.
+
+But isn't Python too slow for a browser?::
+    http://www.infoworld.com/d/application-development/van-rossum-python-not-too-slow-188715[No.]
+    I believe efficency while coding is a lot more important than efficency
+    while running. Also, most of the heavy lifting of qutebrowser is done by Qt
+    and WebKit in C++, with the
+    https://wiki.python.org/moin/GlobalInterpreterLock[GIL] released.
+
+Is there an adblocker?::
+    There is a host-based adblocker which takes /etc/hosts-like lists. A "real"
+    adblocker has a
+    http://www.reddit.com/r/programming/comments/25j41u/adblock_pluss_effect_on_firefoxs_memory_usage/chhpomw[big
+    impact] on browsing speed and
+    https://blog.mozilla.org/nnethercote/2014/05/14/adblock-pluss-effect-on-firefoxs-memory-usage/[RAM
+    usage], so implementing it properly might take some time and won't be done
+    for v0.1 if at all.
+
+== Troubleshooting
+
+Configuration not saved after modifying config.::
+    When editing your config file manually, qutebrowser must be exited completely.
+    This can be done by issuing the command `:quit` or by pressing `Ctrl+q`.
+
+Unable to view flash content.::
+    If you have flash installed for on your system, it's necessary to enable plugins
+    to use the flash plugin. Using the command `:set content allow-plugins true`
+    in qutebrowser will enable plugins. Packages for flash should
+    be provided for your platform or it can be obtained from
+    http://get.adobe.com/flashplayer/[Adobe].
+
+Experiencing freezing on sites like duckduckgo and youtube.::
+    This issue could be caused by stale plugin files installed by `mozplugger`
+    if mozplugger was subsequently removed.
+    Try exiting qutebroser and removing `~/.mozilla/plugins/mozplugger*.so`.
+    See https://github.com/The-Compiler/qutebrowser/issues/357[Issue #357]
+    for more details.
+
+Experiencing segfaults (crashes) on Debian systems.::
+    For Debian it's highly recommended to install the `gstreamer0.10-plugins-base` package.
+    This is a workaround for a bug in Qt, it has been fixed upstream in Qt 5.4
+    More details can be found
+    https://bugs.webkit.org/show_bug.cgi?id=119951[here].
+
+Segfaults on Facebook, Medium, Amazon, ...::
+    If you are on a Debian or Ubuntu based system, you might experience some crashes
+    visting these sites. This is caused by a known bug in Qt which has been
+    fixed in Qt 5.4. However Debian and Ubuntu are slow to adopt or upgrade
+    some packages. There is currently no easy way to manually upgrade to Qt
+    5.4 on those systems.
+
+My issue is not listed.::
+    If you experience any segfaults or crashes, you can report the issue in
+    https://github.com/The-Compiler/qutebrowser/issues[the issue tracker] or
+    using the `:report` command.
+    If you are reporting a segfault, make sure you read the
+    https://github.com/The-Compiler/qutebrowser/blob/master/doc/stacktrace.asciidoc[guide]
+    on how to report them with all needed information.
--- a/doc/HACKING.asciidoc
+++ b/doc/HACKING.asciidoc
@@ -0,0 +1,562 @@
+qutebrowser HACKING
+===================
+The Compiler <mail@qutebrowser.org>
+:icons:
+:data-uri:
+:toc:
+
+I `&lt;3` footnote:[Of course, that says `<3` in HTML.] contributors!
+
+This document contains guidelines for contributing to qutebrowser, as well as
+useful hints when doing so.
+
+If anything mentioned here would prevent you from contributing, please let me
+know, and contribute anyways! The guidelines are only meant to make life easier
+for me, but if you don't follow anything in here, I won't be mad at you. I will
+probably change it for you then, though.
+
+If you have any problems, I'm more than happy to help! You can get help in
+several ways:
+
+* Send a mail to the mailing list at mailto:qutebrowser@lists.qutebrowser.org[]
+(optionally
+https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[subscribe]
+first).
+* Join the IRC channel irc://irc.freenode.org/#qutebrowser[`#qutebrowser`] on
+http://freenode.net/[Freenode]
+(https://webchat.freenode.net/?channels=#qutebrowser[webchat]).
+
+Finding something to work on
+----------------------------
+
+Chances are you already know something to improve or add when you're reading
+this. It might be a good idea to ask on the mailing list or IRC channel to make
+sure nobody else started working on the same thing already.
+
+If you want to find something useful to do, check the
+https://github.com/The-Compiler/qutebrowser/issues[issue tracker]. Some
+pointers:
+
+* https://github.com/The-Compiler/qutebrowser/milestones/v0.1[Open issues for
+the v0.1 release]
+* https://github.com/The-Compiler/qutebrowser/labels/easy[Issues which should
+be easy to solve]
+* https://github.com/The-Compiler/qutebrowser/labels/not%20code[Issues which
+require little/no coding]
+
+There are also some things to do if you don't want to write code:
+
+* Help the community, e.g. on the mailinglist and the IRC channel.
+* Improve the documentation.
+* Help on the website and graphics (logo, etc.).
+
+Using git
+---------
+
+qutebrowser uses http://git-scm.com/[git] for its development. You can clone
+the repo like this:
+
+----
+git clone git://the-compiler.org/qutebrowser
+----
+
+If you don't know git, a http://git-scm.com/[git cheatsheet] might come in
+handy. Of course, if using git is the issue which prevents you from
+contributing, feel free to send normal patches instead, e.g. generated via
+`diff -Nur`.
+
+Getting patches
+~~~~~~~~~~~~~~~
+
+After you finished your work and did `git commit`, you can get patches of your
+changes like this:
+
+----
+git format-patch origin/master <1>
+----
+<1> Replace `master` by the branch your work was based on, e.g.
+`origin/develop`.
+
+Useful utilities
+----------------
+
+Checkers
+~~~~~~~~
+
+In the _scripts/_ subfolder, there is a `run_checks.py` script.
+
+It runs a bunch of static checks on all source files, using the following
+checkers:
+
+* Unit tests using the Python
+https://docs.python.org/3.4/library/unittest.html[unittest] framework
+* https://pypi.python.org/pypi/flake8/1.3.1[flake8]
+* https://github.com/GreenSteam/pep257/[pep257]
+* http://pylint.org/[pylint]
+* A custom checker for the following things:
+    - untracked git files
+    - VCS conflict markers
+
+If you changed `setup.py` or `MANIFEST.in`, add the `--setup` argument to run
+the following additional checkers:
+
+* https://pypi.python.org/pypi/pyroma/0.9.3[pyroma]
+* https://github.com/mgedmin/check-manifest[check-manifest]
+
+It needs all the checkers to be installed and also needs
+https://pypi.python.org/pypi/colorama/[colorama].
+
+Please make sure this script runs without any warnings on your new
+contributions. There's of course the possibility of false-positives, and the
+following techniques are useful to handle these:
+
+* Use `_foo` for unused parameters, with `foo` being a descriptive name. Using
+`_` is discouraged.
+* If you think you have a good reason to suppress a message, add the following
+comment:
+
+----
+# pylint: disable=message-name
+----
+
+Note you can add this per line, per function/class, or per file. Please use the
+smallest scope which makes sense. Most of the time, this will be line scope.
+
+* If you really think a check shouldn't be done globally as it yields a lot of
+false-positives, let me know! I'm still tweaking the parameters.
+
+Profiling
+~~~~~~~~~
+
+In the _scripts/_ subfolder there's a `run_profile.py` which profiles the code
+and shows a graphical representation of what takes how much time.
+
+It needs https://pypi.python.org/pypi/pyprof2calltree/[pyprof2calltree] and
+http://kcachegrind.sourceforge.net/html/Home.html[KCacheGrind]. It uses the
+built-in Python https://docs.python.org/3.4/library/profile.html[cProfile]
+module.
+
+Debugging
+~~~~~~~~~
+
+In the `qutebrowser.utils.debug` module there are some useful functions for
+debugging.
+
+When starting qutebrowser with the `--debug` flag you also get useful debug
+logs. You can add +--logfilter _category[,category,...]_+ to restrict logging
+to the given categories.
+
+With `--debug` there are also some additional +debug-_*_+ commands available,
+for example `:debug-all-objects` and `:debug-all-widgets` which print a list of
+all Qt objects/widgets to the debug log -- this is very useful for finding
+memory leaks.
+
+Useful websites
+~~~~~~~~~~~~~~~
+
+Some resources which might be handy:
+
+* http://qt-project.org/doc/qt-5/classes.html[The Qt5 reference]
+* https://docs.python.org/3/library/index.html[The Python reference]
+* http://httpbin.org/[httpbin, a test service for HTTP requests/responses]
+* http://requestb.in/[RequestBin, a service to inspect HTTP requests]
+
+Documentation of used Python libraries:
+
+* http://jinja.pocoo.org/docs/dev/[jinja2]
+* http://pygments.org/docs/[pygments]
+* http://fdik.org/pyPEG/index.html[pyPEG2]
+* http://pythonhosted.org/setuptools/[setuptools]
+* http://cx-freeze.readthedocs.org/en/latest/overview.html[cx_Freeze]
+* https://pypi.python.org/pypi/colorama[colorama]
+* https://pypi.python.org/pypi/colorlog[colorlog]
+
+Related RFCs and standards:
+
+HTTP
+^^^^
+
+* https://tools.ietf.org/html/rfc2616[RFC 2616 - Hypertext Transfer Protocol
+-- HTTP/1.1]
+(http://www.rfc-editor.org/errata_search.php?rfc=2616[Errata])
+* https://tools.ietf.org/html/rfc7230[RFC 7230 - Hypertext Transfer Protocol
+(HTTP/1.1): Message Syntax and Routing]
+(http://www.rfc-editor.org/errata_search.php?rfc=7230[Errata])
+* https://tools.ietf.org/html/rfc7231[RFC 7231 - Hypertext Transfer Protocol
+(HTTP/1.1): Semantics and Content]
+(http://www.rfc-editor.org/errata_search.php?rfc=7231[Errata])
+* https://tools.ietf.org/html/rfc7232[RFC 7232 - Hypertext Transfer Protocol
+(HTTP/1.1): Conditional Requests]
+(http://www.rfc-editor.org/errata_search.php?rfc=7232[Errata])
+* https://tools.ietf.org/html/rfc7233[RFC 7233 - Hypertext Transfer Protocol
+(HTTP/1.1): Range Requests]
+(http://www.rfc-editor.org/errata_search.php?rfc=7233[Errata])
+* https://tools.ietf.org/html/rfc7234[RFC 7234 - Hypertext Transfer Protocol
+(HTTP/1.1): Caching]
+(http://www.rfc-editor.org/errata_search.php?rfc=7234[Errata])
+* https://tools.ietf.org/html/rfc7235[RFC 7235 - Hypertext Transfer Protocol
+(HTTP/1.1): Authentication]
+(http://www.rfc-editor.org/errata_search.php?rfc=7235[Errata])
+* https://tools.ietf.org/html/rfc5987[RFC 5987 - Character Set and Language
+Encoding for Hypertext Transfer Protocol (HTTP) Header Field Parameters]
+(http://www.rfc-editor.org/errata_search.php?rfc=5987[Errata])
+* https://tools.ietf.org/html/rfc6266[RFC 6266 - Use of the
+Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)]
+(http://www.rfc-editor.org/errata_search.php?rfc=6266[Errata])
+* http://tools.ietf.org/html/rfc6265[RFC 6265 - HTTP State Management Mechanism
+(Cookies)] (http://www.rfc-editor.org/errata_search.php?rfc=6265[Errata])
+* http://www.cookiecentral.com/faq/#3.5[Netscape Cookie Format]
+
+Other
+^^^^^
+
+* https://tools.ietf.org/html/rfc5646[RFC 5646 - Tags for Identifying
+Languages] (http://www.rfc-editor.org/errata_search.php?rfc=5646[Errata])
+* http://www.w3.org/TR/CSS2/[Cascading Style Sheets Level 2 Revision 1 (CSS
+2.1) Specification]
+* http://qt-project.org/doc/qt-4.8/stylesheet-reference.html[Qt Style Sheets
+Reference]
+* http://mimesniff.spec.whatwg.org/[MIME Sniffing Standard]
+* http://spec.whatwg.org/[WHATWG specifications]
+* http://www.w3.org/html/wg/drafts/html/master/Overview.html[HTML 5.1 Nightly]
+* http://www.w3.org/TR/webstorage/[Web Storage]
+* http://www.brynosaurus.com/cachedir/spec.html[Cache directory tagging
+standard]
+* http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html[XDG
+basedir specification]
+
+Hints
+-----
+
+Python and Qt objects
+~~~~~~~~~~~~~~~~~~~~~
+
+For many tasks, there are solutions in both Qt and the Python standard libary
+available.
+
+In qutebrowser, the policy is usually using the Python libraries, as they
+provide exceptions and other benefits.
+
+There are some exceptions to that:
+
+* `QThread` is used instead of Python threads because it provides signals and
+slots.
+* `QProcess` is used instead of Python's `subprocess` if certain actions (e.g.
+cleanup) when the process finished are desired, as it provides signals for
+that.
+* `QUrl` is used instead of storing URLs as string, see the
+<<handling-urls,handling URLs>> section for details.
+
+When using Qt objects, two issues must be taken care of:
+
+* Methods of Qt objects report their status by using their return values,
+instead of using exceptions.
+
+If a function gets or returns a Qt object which
+has an `.isValid()` method such as `QUrl` or `QModelIndex`, there's a helper
+function `ensure_valid` in `qutebrowser.utils.qt` which should get called on
+all such objects. It will raise `qutebrowser.utils.qt.QtValueError` if the
+value is not valid.
+
+If a function returns something else on error, the return value should
+carefully be checked.
+
+* Methods of Qt objects have certain maximum values, based on their underlying
+C++ types.
+
+When passing a numeric parameter to a Qt function, all numbers should be
+range-checked using `qutebrowser.utils.check_overflow`, or passing a value
+which is too large should be avoided by other means (e.g. by setting a maximum
+value for a config object).
+
+[[object-registry]]
+The object registry
+~~~~~~~~~~~~~~~~~~~
+
+The object registry in `qutebrowser.utils.objreg` is a collection of
+dictionaries which map object names to the actual long-living objects.
+
+There are currently these object registries, also called 'scopes':
+
+* The `global` scope, with objects which are used globally (`config`,
+`cookie-jar`, etc.)
+* The `tab` scope with objects which are per-tab (`hintmanager`, `webview`,
+etc.). Passing this scope to `objreg.get()` selects the object in the currently
+focused tab by default. A tab can be explicitely selected by passing
+tab=_tab-id_, window=_win-id_+ to it.
+
+A new object can be registered by using
+objreg.register(_name_, _object_[, scope=_scope_, window=_win-id_,
+tab=_tab-id_])+. An object should not be registered twice. To update it,
+`update=True` has to be given.
+
+An object can be retrieved by using +objreg.get(_name_[, scope=_scope_,
+window=_win-id_, tab=_tab-id_])+. The default scope is `global`.
+
+All objects can be printed by starting with the `--debug` flag and using the
+`:debug-all-objects` command.
+
+The registry is mainly used for <<commands,command handlers>> but also can be
+useful in places where using Qt's
+http://qt-project.org/doc/qt-5/signalsandslots.html[signals and slots]
+mechanism would be difficult.
+
+Logging
+~~~~~~~
+
+Logging is used at various places throughout the qutebrowser code. If you add a
+new feature, you should also add some strategic debug logging.
+
+Unless other Python projects, qutebrowser doesn't use a logger per file,
+instead it uses custom-named loggers.
+
+The existing loggers are defined in `qutebrowser.utils.log`. If your feature
+doesn't fit in any of the logging categories, simply add a new line like this:
+
+[source,python]
+----
+foo = getLogger('foo')
+----
+
+Then in your source files, do this:
+
+[source,python]
+----
+from qutebrowser.utils import log
+...
+log.foo.debug("Hello World")
+----
+
+The following logging levels are available for every logger:
+
+[width="75%",cols="25%,75%"]
+|=======================================================================
+|criticial |Critical issue, qutebrowser can't continue to run.
+|error     |There was an issue and some kind of operation was abandoned.
+|warning   |There was an issue but the operation can continue running.
+|info      |General informational messages.
+|debug     |Verbose debugging informations.
+|=======================================================================
+
+[[commands]]
+Commands
+~~~~~~~~
+
+qutebrowser has the concept of functions which are exposed to the user as
+commands.
+
+Creating a new command is straightforward:
+
+[source,python]
+----
+import qutebrowser.commands.cmdutils
+
+...
+
+@cmdutils.register(...)
+def foo():
+    ...
+----
+
+The commands arguments are automatically deduced by inspecting your function.
+
+If the function is a method of a class, the `@cmdutils.register` decorator
+needs to have an `instance=...` parameter which points to the (single/main)
+instance of the class.
+
+The `instance` parameter is the name of an object in the object registry, which
+then gets passed as the `self` parameter to the handler. The `scope` argument
+selects which object registry (global, per-tab, etc.) to use.  See the
+<<object-registry,object registry>> section for details.
+
+There are also other arguments to customize the way the command is registered,
+see the class documentation for `register` in `qutebrowser.commands.utils` for
+details.
+
+The types of the function arguments are inferred based on their default values,
+e.g. an argument `foo=True` will be converted to a flag `-f`/`--foo` in
+qutebrowser's commandline.
+
+This behaviour can be overridden using Python's
+http://legacy.python.org/dev/peps/pep-3107/[function annotations]. The
+annotation should always be a `dict`, like this:
+
+[source,python]
+----
+@cmdutils.register(...)
+def foo(bar: {'type': int}, baz=True):
+    ...
+----
+
+The following keys are supported in the dict:
+
+* `type`: The type this value should have. The value entered by the user is
+then automatically checked. Possible values:
+    - A callable (`int`, `float`, etc.): Gets called to validate/convert the
+      value.
+    - A string: The value must match exactly (mainly useful with tuples to get
+      a choice of values, see below).
+    - A python enum type: All members of the enum are possible values.
+    - A tuple of multiple types above: Any of these types are valid values,
+      e.g. `('foo', 'bar')` or `(int, 'foo')`.
+* `flag`: The flag to be used, as 1-char string (default: First char of the
+long name).
+* `name`: The long name to be used, as string (default: Name of the parameter).
+* `special`: The string `count` or `win_id` if the parameter should be
+auto-filled (with the count given by the user and the window ID the command was
+executed in, respectively).
+* `nargs`: Gets passed to argparse, see
+https://docs.python.org/dev/library/argparse.html#nargs[its documentation].
+
+[[handling-urls]]
+Handling URLs
+~~~~~~~~~~~~~
+
+qutebrowser handles two different types of URLs: URLs as a string, and URLs as
+the Qt `QUrl` type. As this can get confusing quickly, please follow the
+following guidelines:
+
+* Convert a string to a QUrl object as early as possible, i.e. directly after
+the user did enter it.
+    - Use `utils.urlutils.fuzzy_url` if the URL is entered by the user
+      somewhere.
+    - Be sure you handle `utils.urlutils.FuzzyError` and display an error
+      message to the user.
+* Convert a `QUrl` object to a string as late as possible, e.g. before
+displaying it to the user.
+    - If you want to display the URL to the user, use `url.toDisplayString()`
+      so password information is removed.
+    - If you want to get the URL as string for some other reason, you most
+      likely want to add the `QUrl.EncodeFully` and `QUrl.RemovePassword`
+      flags.
+* Name a string URL something like `urlstr`, and a `QUrl` something like `url`.
+* Mention in the docstring whether your function needs a URL string or a
+`QUrl`.
+* Call `ensure_valid` from `utils.qtutils` whenever getting or creating a
+`QUrl` and take appropriate action if not. Note the URL of the current page
+always could be an invalid QUrl (if nothing is loaded yet).
+
+
+Style conventions
+-----------------
+
+qutebrowser's coding conventions are based on
+http://legacy.python.org/dev/peps/pep-0008/[PEP8] and the https://google-styleguide.googlecode.com/svn/trunk/pyguide.html[Google Python style guidelines] with some additions:
+
+* The _Raise:_ section is not added to the docstring.
+* Methods overriding Qt methods (obviously!) don't follow the naming schemes.
+* Everything else does though, even slots.
+* Docstrings should look like described in
+http://legacy.python.org/dev/peps/pep-0257/[PEP257] and the google guidelines.
+* Class docstrings have additional _Attributes:_, _Class attributes:_ and
+  _Signals:_ sections.
+* In docstrings of command handlers (registered via `@cmdutils.register`), the
+description should be split into two parts by using `//` - the first part is
+the description of the command like it will appear in the documentation, the
+second part is "internal" documentation only relevant to people reading the
+sourcecode.
+
+Example for a class docstring:
+
+[source,python]
+----
+"""Some object.
+
+Attributes:
+    blub: The current thing to handle.
+
+Signals:
+    valueChanged: Emitted when a value changed.
+                  arg: The new value
+"""
+----
+
+Example for a method/function docstring:
+
+[source,python]
+----
+"""Do something special.
+
+This will do something.
+
+//
+
+It is based on http://example.com/.
+
+Args:
+    foo: ...
+
+Return:
+    True if something, False if something else.
+"""
+----
+
+* The layout of a module should be roughly like this:
+  - Shebang (`#!/usr/bin/python`, if needed)
+  - vim-modeline (`# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et`)
+  - Copyright
+  - GPL boilerplate
+  - Module docstring
+  - Python standard library imports
+  - PyQt imports
+  - qutebrowser imports
+  - functions
+  - classes
+* The layout of a class should be like this:
+  - docstring
+  - `__magic__` methods
+  - properties
+  - _private methods
+  - public methods
+  - `on_*` methods
+  - overrides of Qt methods
+
+Checklists
+----------
+
+These are mainly intended for myself, but they also fit in here well.
+
+New Qt release
+~~~~~~~~~~~~~~
+
+* Run all tests and check nothing is broken.
+* Check the
+https://bugreports.qt-project.org/issues/?jql=reporter%20%3D%20%22The%20Compiler%22%20ORDER%20BY%20fixVersion%20ASC[Qt bugtracker]
+and make sure all bugs marked as resolved are actually fixed.
+* Update own PKGBUILDs based on upstream Archlinux updates.
+* Build developer packages.
+* Build non-developer symbol packages.
+* Upload symbols patch to http://www.qutebrowser.org/qt-symbols.patch
+* Upload symbols packages to http://www.qutebrowser.org/qt-symbols-pkg/
+* Update recommended Qt version in `README`
+* Update OS X instructions in `README`
+* Make sure Gentoo instructions are up to date.
+* Grep for `WORKAROUND` in the code and test if fixed stuff works without the
+workaround.
+
+qutebrowser release
+~~~~~~~~~~~~~~~~~~~
+
+* Make sure there are no unstaged changes.
+* Run `src2asciidoc.py` and commit changes if necessary.
+* Run `asciidoc2html.py`.
+* Adjust `__version_info__` in `qutebrowser/__init__.py`.
+
+* Run all tests on all supported systems.
+* Test an upgrade from the previous version (no manual intervention).
+* Test an upgrade from the first version (no manual intervention).
+
+* Create annotated git tag (`git tag -s "v0.1" -m "Release v0.1"`)
+* Create git branch `v0.1.x`
+* Push including `--tags`
+* Create release on github
+* Mark the milestone at https://github.com/The-Compiler/qutebrowser/milestones
+as closed.
+
+* Create standalone Windows package (32/64bit) in Windows VM
+* Upload to PyPI: `python setup.py register sdist upload --sign`
+* Maybe upload to http://qt-apps.org/
+* Upload to webpage with checksum/GPG (when/if it exists)
+
+* Announce to qutebrowser mailinglist
+* Maybe annouce at other places?
--- a/doc/INSTALL.asciidoc
+++ b/doc/INSTALL.asciidoc
@@ -0,0 +1,142 @@
+Installing qutebrowser
+======================
+
+On Debian / Ubuntu
+------------------
+
+qutebrowser should run on these systems:
+
+* Debian jessie or newer
+* Ubuntu Trusty (14.04 LTS) or newer
+* Any other distribution based on these (e.g. Linux Mint)
+
+Install the dependencies via apt-get:
+
+----
+# apt-get install python3-pyqt5 python3-pyqt5.qtwebkit python-virtualenv
+----
+
+To generate the documentation for the `:help` command, when using the git
+repository (rather than a release):
+
+----
+# apt-get install asciidoc
+# python3 scripts/asciidoc2html.py
+----
+
+Then run the supplied script to run qutebrowser inside a
+https://virtualenv.pypa.io/en/latest/virtualenv.html[virtualenv]:
+
+----
+# python3 scripts/init_venv.py
+----
+
+This installs all needed Python dependencies in a `.venv` subfolder. The
+system-wide Qt5/PyQt5 installations are symlinked into the virtualenv.
+
+You can then create a simple wrapper script to start qutebrowser somewhere in
+your `$PATH` (e.g. `/usr/local/bin/qutebrowser` or `~/bin/qutebrowser`):
+
+----
+#!/bin/bash
+~/path/to/qutebrowser/.venv/bin/python3 -m qutebrowser
+----
+
+On Archlinux
+------------
+
+There are two Archlinux packages available in the AUR:
+https://aur.archlinux.org/packages/qutebrowser/[qutebrowser] and
+https://aur.archlinux.org/packages/qutebrowser-git/[qutebrowser-git].
+
+You can install them like this:
+
+----
+$ mkdir qutebrowser
+$ cd qutebrowser
+$ wget https://aur.archlinux.org/packages/qu/qutebrowser-git/PKGBUILD
+$ makepkg -si
+----
+
+or you could use an AUR helper, e.g. `yaourt -S qutebrowser-git`.
+
+On Gentoo
+---------
+
+A dedicated overlay is available on
+https://github.com/posativ/qutebrowser-overlay[GitHub]. To install it, add the
+overlay with http://wiki.gentoo.org/wiki/Layman[layman]:
+
+----
+# wget https://raw.githubusercontent.com/posativ/qutebrowser-overlay/master/overlays.xml -O /etc/layman/overlays/qutebrowser.xml
+# layman -a qutebrowser
+----
+
+Note, that Qt5 is available in the portage tree, but masked. You may need to do
+a lot of keywording to install qutebrowser. Also make sure you have `python3_4`
+in your `PYTHON_TARGETS` (`/etc/portage/make.conf`) and rebuild your system
+(`emerge -uDNav @world`). Afterwards, you can install qutebrowser:
+
+----
+# emerge -av qutebrowser
+----
+
+On Windows
+----------
+
+You can either use one of the
+https://github.com/The-Compiler/qutebrowser/releases[prebuilt standalone
+packages or MSI installers], or install manually:
+
+* Use the installer from http://www.python.org/downloads[python.org] to get
+Python 3 (be sure to install pip).
+* Use the installer from
+http://www.riverbankcomputing.com/software/pyqt/download5[Riverbank computing]
+to get Qt and PyQt5.
+* Run `pip install virtualenv` or
+http://www.lfd.uci.edu/~gohlke/pythonlibs/#virtualenv[the installer from here]
+to install virtualenv.
+
+Then run the supplied script to run qutebrowser inside a
+https://virtualenv.pypa.io/en/latest/virtualenv.html[virtualenv]:
+
+----
+# python3 scripts/init_venv.py
+----
+
+This installs all needed Python dependencies in a `.venv` subfolder. The
+system-wide Qt5/PyQt5 installations are used in the virtualenv.
+
+On OS X
+-------
+
+To install qutebrowser on OS X, you'll want a package manager, e.g.
+http://brew.sh/[Homebrew] or https://www.macports.org/[MacPorts]. Also make
+sure, you have https://itunes.apple.com/en/app/xcode/id497799835[XCode]
+installed to compile PyQt5 in a later step.
+
+----
+$ brew install python3 pyqt5
+$ pip3.4 install qutebrowser
+----
+
+if you are using Homebrew. For MacPorts, run:
+
+----
+$ sudo port install python34 py34-jinja2 asciidoc py34-pygments py34-pyqt5
+$ sudo pip3.4 install qutebrowser
+----
+
+The preferences for qutebrowser are stored in
+`~/Library/Preferences/qutebrowser`, the application data is stored in
+`~/Library/Application Support/qutebrowser`.
+
+Packagers
+---------
+
+There are example .desktop and icon files provided. They would go in the
+standard location for your distro (`/usr/share/applications` and
+`/usr/share/pixmaps` for example).
+
+The normal `setup.py install` doesn't install these files, so you'll have to do
+it as part of the packaging process.
--- a/doc/backers.asciidoc
+++ b/doc/backers.asciidoc
@@ -1,346 +0,0 @@
-Crowdfunding backers
-====================
-
-2017
----
-
-Mid-2017, qutebrowser had its
-https://www.kickstarter.com/projects/the-compiler/qutebrowser-v10-with-per-domain-settings[second crowdfunding]
-with the goal of implementing the new config system and releasing v1.0.
-
-Thanks a lot to the following people who contributed to it:
-
-Gold sponsors
-~~~~~~~~~~~~~
-
- Iggy
- zwitschi
- 2x Anonymous
-
-Silver sponsors
-~~~~~~~~~~~~~~~
-
- https://benary.org[benaryorg]
- https://scratchbook.ch[Claude]
- Martin Tournoij
- http://supported.elsensohn.ch[Thomas Elsensohn]
- Christian Helbling
- Gavin Troy
- Chris King-Parra
- Tim Das Mool Wegener
-
-Other sponsors
-~~~~~~~~~~~~~~
-
- 7scan
- AMD1212
- Alex
- Alex Suykov
- Alexey Zhikhartsev
- Allan Nordhøy
- Anirudh Sanjeev
- Anssi Puustinen
- Anton Grensjö
- Aristaeus
- Armin Fisslthaler
- Ashley Hauck
- Benedikt Steindorf
- Bernardo Kuri
- Blaise Duszynski
- Bostan
- Bruno Oliveira
- BunnyApocalypse
- Christian Kellermann
- Colin Jacobs
- Daniel Andersson
- Daniel Nelson
- Daniel P. Schmidt
- Daniel Salby
- Danilo
- David Beley
- David Hollings
- David Keijser
- David Parrish
- Derin Yarsuvat
- Dmytro Kostiuchenko
- Eero Kari
- Epictek
- Eric
- Faure Hu
- Ferus
- Frederik Thorøe
- G4v4g4i
- Granitosaurus
- Gyula Teleki
- H
- Heinz Bruhin
- Hosaka
- Ihor Radchenko
- Iordanis Grigoriou
- Isaac Sandaljian
- Jakub Podeszwik
- Jamie Anderson
- Jasper Woudenberg
- Jay Kamat
- Jens Højgaard
- Johannes
- John Baber-Lucero
- Jonas Schürmann
- Kenichiro Ito
- Kenny Low
- Lars Ivar Igesund
- Leulas
- Lucas Aride Moulin
- Ludovic Chabant
- Lukas Gierth
- Magnus Lindström
- Marulkan
- Matthew Chun-Lum
- Matthew Cronen
- Matthew Quigley
- Michael Schönwälder
- Mika Kutila
- Mitchell Stokes
- Nathan Howell
- Nathan Schlehlein
- Noël Zindel
- Obri
- Patrik Peng
- Peter DiMarco
- Peter Rice
- Philipp Middendorf
- Pkill9
- PluMGMK
- Prescott
- ProXicT
- Ram-Z
- Robotichead
- Roshless
- Ryan Ellis
- Ryan P Deslandes
- Sam Doshi
- Sam Stone
- Sean Herman
- Sebastian Frysztak
- Shelby Cruver
- Simon Désaulniers
- SirCmpwn
- Soham Pal
- Stephan Jauernick
- Stewart Webb
- Sven Reinecke
- Timothée Floure
- Tom Bass
- Tom Kirchner
- Tomas Slusny
- Tomasz Kramkowski
- Tommy Thomas
- Tuscan
- Ulrich Pötter
- Vasilij Schneidermann
- Vlaaaaaaad
- XTaran
- Z2h-A6n
- ayekat
- beanieuptop
- cee
- craftyguy
- demure
- dlangevi
- epon
- evenorbert
- fishss
- gsnewmark
- guillermohs9
- hernani
- hubcaps
- jnphilipp
- lobachevsky
- neodarz
- nihlaeth
- notbenh
- nyctea
- ongy
- patrick suwanvithaya
- pyratebeard
- p≡p foundation
- randm_dave
- sabreman
- toml
- vimja
- wiz
- 48 Anonymous
-
-2016
----
-
-Mid-2016, qutebrowser did run a http://igg.me/at/qutebrowser[crowdfunding] for
-QtWebEngine support in qutebrowser.
-
-Thanks a lot to the following people who contributed to it:
-
-Gold sponsors
-~~~~~~~~~~~~~
-
- Chris Salzberg
- Clayton Craft
- Jean-Louis Fuchs
- Matthias Lisin
- 1 Anonymous
-
-Day sponsors
-~~~~~~~~~~~~
-
- Agent 42
- Iggy Jackson
- James B
- Rudi Seitz
- Tim „Das MooL“ Wegener
- amd1212
- gavtroy
- 4 Anonymous
-
-Other sponsors
-~~~~~~~~~~~~~~
-
- AP M
- Alessandro Balzano
- Allan Nordhøy
- Andor Uhlar
- Andreas Leppert
- Andreas Saga Romsdal
- Andrew Rogers / tuxlovesyou
- André Glüpker
- Arian Sanusi
- Arin Lares
- Assaf Lavie
- Baptiste Wicht
- Benjamin Richter
- Benjamin Schnitzler
- Bernardo Kuri
- Boris Kourtoukov
- Brian Buccola
- Bruno Oliveira
- Bryan Gilbert
- Cassandra Rebecca Ruppen
- Charles Saternos
- Chris H
- Christian Karl
- Christian Lange
- Christian Strasser
- Colin O'Brien
- Corsin Pfister
- Cosmin Popescu
- Daniel Andersson
- David Wilson
- Demure Demeanor
- Doug Stone-Weaver
- Eero Kari
- Enric Morales
- Eric Krohn
- Eskild Hustvedt
- Federico Panico
- Felix Van der Jeugt
- Francis Tseng
- Geir Isene
- George Voronin
- German Correa
- Grady Martin
- Gregor Böhl
- Guilherme Stein
- Hannes Doyle
- Hasan Soydabas
- Ian Scott
- Jacob Boldman
- Jacob Wikmark
- Jan Verbeek
- Jarrod Seccombe
- Joel Bradshaw
- Johannes Martinsson
- Jonas Schürmann
- Josh Medeiros
- José Alberto Orejuela García
- Julie Engel
- Jörg Behrmann
- Jørgen Skancke
- Kevin Kainan Li
- Kevin Velghe
- Konstantin Shmelkov
- Kyle Frazer
- Lukas Gierth
- Mar v Leeuwaarde
- Marek Roszman
- Marius Betz
- Marius Krämer
- Markus Schmidinger
- Martin Gabelmann
- Martin Zimmermann
- Mathias Fußenegger
- Maxime Wack
- Michał Góral
- Nathan Isom
- Nathanael Philipp
- Nils Stål
- Oliver Hope
- Oskar Nyberg
- Pablo Navarro
- Panashe M. Fundira
- Patric Schmitz
- Pete M
- Peter Smith
- Phil Collins
- Philipp Hansch
- Philipp Kuhnz
- Raphael Khaiat
- Raphael Pierzina
- Renan Guilherme
- Rick Losie
- Robert Cross
- Roy Van Ginneken
- Rupus Reinefjord
- Ryan Roden-Corrent
- Samir Benmendil
- Simon Giotta
- Stephen England
- Sverrir H Steindorsson
- Tarcisio Fedrizzi
- Thorsten Wißmann
- Timon Stampfli
- Tjelvar Olsson
- Tomasz Kramkowski
- Tsukiko Tsutsukakushi
- Vasilij Schneidermann
- Vinney Cavallo
- Wesly Grefrath
- Will Ware
- Yousaf Khurshid
- Zach Schultz
- averrin
- ben hengst
- colin
- craigtski47
- dag.robole
- daniel.m.kao
- diepfann3
- eamonn oneil
- esakaforever
- francois47
- glspisso
- gmccoy4242
- gtcee3
- jonathf
- lapinski.maciej
- lauri.hakko
- ljanzen
- mutilx9
- nussgipfel
- oed
- p p
- r.c.bruno.andre
- robert.perce
- sghctoma
- targy
- freelancer
- pupu
- regines
- 37 Anonymous
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
--- a/doc/contributing.asciidoc
+++ b/doc/contributing.asciidoc
@@ -1,724 +0,0 @@
-Contributing to qutebrowser
-===========================
-The Compiler <mail@qutebrowser.org>
-:icons:
-:data-uri:
-:toc:
-
-IMPORTANT: I'm currently (July 2018) more busy than usual until September,
-because of exams coming up. Review of non-trivial pull requests will thus be
-delayed until then. If you're reading this note after mid-September, please
-open an issue.
-
-I `&lt;3` footnote:[Of course, that says `<3` in HTML.] contributors!
-
-This document contains guidelines for contributing to qutebrowser, as well as
-useful hints when doing so.
-
-If anything mentioned here would prevent you from contributing, please let me
-know, and contribute anyways! The guidelines are meant to make life easier for
-me, but if you don't follow everything in here, I won't be mad at you. In
-fact, I will probably change it for you.
-
-If you have any problems, I'm more than happy to help! You can get help in
-several ways:
-
-* Send a mail to the mailing list at mailto:qutebrowser@lists.qutebrowser.org[]
-(optionally
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[subscribe]
-first).
-* Join the IRC channel irc://irc.freenode.org/#qutebrowser[`#qutebrowser`] on
-http://freenode.net/[Freenode]
-(https://webchat.freenode.net/?channels=#qutebrowser[webchat]).
-
-Finding something to work on
----------------------------
-
-Chances are you already know something to improve or add when you're reading
-this. It might be a good idea to ask on the mailing list or IRC channel to make
-sure nobody else started working on the same thing already.
-
-If you want to find something useful to do, check the
-https://github.com/qutebrowser/qutebrowser/issues[issue tracker]. Some
-pointers:
-
-* https://github.com/qutebrowser/qutebrowser/labels/easy[Issues which should
-be easy to solve]
-* https://github.com/qutebrowser/qutebrowser/labels/component%3A%20docs[Documentation issues which require little/no coding]
-
-If you prefer C++ or Javascript to Python, see the relevant issues which involve
-work in those languages:
-
-* https://github.com/qutebrowser/qutebrowser/issues?q=is%3Aopen+is%3Aissue+label%3A%22language%3A+c%2B%2B%22[C++] (mostly work on Qt, the library behind qutebrowser)
-* https://github.com/qutebrowser/qutebrowser/issues?q=is%3Aopen+is%3Aissue+label%3A%22language%3A+javascript%22[JavaScript]
-
-There are also some things to do if you don't want to write code:
-
-* Help the community, e.g., on the mailinglist and the IRC channel.
-* Improve the documentation.
-* Help on the website and graphics (logo, etc.).
-
-Using git
---------
-
-qutebrowser uses http://git-scm.com/[git] for its development. You can clone
-the repo like this:
-
----
-git clone https://github.com/qutebrowser/qutebrowser.git
----
-
-If you don't know git, a http://git-scm.com/[git cheatsheet] might come in
-handy. Of course, if using git is the issue which prevents you from
-contributing, feel free to send normal patches instead, e.g., generated via
-`diff -Nur`.
-
-Getting patches
-~~~~~~~~~~~~~~~
-
-The preferred way of submitting changes is to
-https://help.github.com/articles/fork-a-repo/[fork the repository] and to
-https://help.github.com/articles/creating-a-pull-request/[submit a pull
-request].
-
-If you prefer to send a patch to the mailinglist, you can generate a patch
-based on your changes like this:
-
----
-git format-patch origin/master <1>
----
-<1> Replace `master` by the branch your work was based on, e.g.,
-`origin/develop`.
-
-Running qutebrowser
-------------------
-
-After link:install.asciidoc#tox[installing qutebrowser via tox], you can run
-`.venv/bin/qutebrowser --debug --temp-basedir` to test your changes with debug
-logging enabled and without affecting existing running instances.
-
-Alternatively, you can install qutebrowser's dependencies system-wide and run
-`python3 -m qutebrowser --debug --temp-basedir`.
-
-Useful utilities
----------------
-
-Checkers
-~~~~~~~~
-
-qutebrowser uses http://tox.readthedocs.org/en/latest/[tox] to run its
-unittests and several linters/checkers.
-
-Currently, the following tox environments are available:
-
-* Tests using https://www.pytest.org[pytest]:
-  - `py35`, `py36`: Run pytest for python 3.5/3.6 with the system-wide PyQt.
-  - `py36-pyqt57`, ..., `py36-pyqt59`: Run pytest with the given PyQt version (`py35-*` also works).
-  - `py36-pyqt59-cov`: Run with coverage support (other Python/PyQt versions work too).
-* `flake8`: Run various linting checks via https://pypi.python.org/pypi/flake8[flake8].
-* `vulture`: Run https://pypi.python.org/pypi/vulture[vulture] to find
-  unused code portions.
-* `pylint`: Run http://pylint.org/[pylint] static code analysis.
-* `pyroma`: Check packaging practices with
-  https://pypi.python.org/pypi/pyroma/[pyroma].
-* `eslint`: Run http://eslint.org/[ESLint] javascript checker.
-* `check-manifest`: Check MANIFEST.in completeness with
-  https://github.com/mgedmin/check-manifest[check-manifest].
-* `mkvenv`: Bootstrap a virtualenv for testing.
-* `misc`: Run `scripts/misc_checks.py` to check for:
-    - untracked git files
-    - VCS conflict markers
-    - common spelling mistakes
-
-The default test suite is run with `tox`; the list of default
-environments is obtained with `tox -l`.
-
-Please make sure the checks run without any warnings on your new contributions.
-
-There's always the possibility of false positives; the following
-techniques are useful to handle these:
-
-* Use `_foo` for unused parameters, with `foo` being a descriptive name. Using
-`_` is discouraged.
-* If you think you have a good reason to suppress a message, then add the
-following comment:
-+
----
-# pylint: disable=message-name
----
-+
-Note you can add this per line, per function/class, or per file. Please use the
-smallest scope which makes sense. Most of the time, this will be line scope.
-+
-* If you really think a check shouldn't be done globally as it yields a lot of
-false-positives, let me know! I'm still tweaking the parameters.
-
-
-Running Specific Tests
-~~~~~~~~~~~~~~~~~~~~~~
-
-While you are developing you often don't want to run the full test
-suite each time.
-
-Specific test environments can be run with `tox -e <envlist>`.
-
-Additional parameters can be passed to the test scripts by separating
-them from `tox` arguments with `--`.
-
-Examples:
-
----
-# run only pytest tests which failed in last run:
-tox -e py35 -- --lf
-
-# run only the end2end feature tests:
-tox -e py35 -- tests/end2end/features
-
-# run everything with undo in the generated name, based on the scenario text
-tox -e py35 -- tests/end2end/features/test_tabs_bdd.py -k undo
-
-# run coverage test for specific file (updates htmlcov/index.html)
-tox -e py35-cov -- tests/unit/browser/test_webelem.py
----
-
-Profiling
-~~~~~~~~~
-
-In the _scripts/_ subfolder there's a `run_profile.py` which profiles the code
-and shows a graphical representation of what takes how much time.
-
-It uses the built-in Python
-https://docs.python.org/3.6/library/profile.html[cProfile] module and can show
-the output in four different ways:
-
-* Raw profile file (`--profile-tool=none`)
-* https://pypi.python.org/pypi/pyprof2calltree/[pyprof2calltree] and http://kcachegrind.sourceforge.net/html/Home.html[KCacheGrind] (`--profile-tool=kcachegrind`)
-* https://jiffyclub.github.io/snakeviz/[SnakeViz] (`--profile-tool=snakeviz`)
-* https://github.com/jrfonseca/gprof2dot[gprof2dot] (needs `dot` from http://graphviz.org/[Graphviz] and http://feh.finalrewind.org/[feh])
-
-Debugging
-~~~~~~~~~
-
-There are some useful functions for debugging in the `qutebrowser.utils.debug`
-module.
-
-When starting qutebrowser with the `--debug` flag, you also get useful debug
-logs. You can add +--logfilter _[!]category[,category,...]_+ to restrict
-logging to the given categories.
-
-With `--debug` there are also some additional +debug-_*_+ commands available,
-for example `:debug-all-objects` and `:debug-all-widgets` which print a list of
-all Qt objects/widgets to the debug log -- this is very useful for finding
-memory leaks.
-
-Useful websites
-~~~~~~~~~~~~~~~
-
-Some resources which might be handy:
-
-* http://doc.qt.io/qt-5/classes.html[The Qt5 reference]
-* https://docs.python.org/3/library/index.html[The Python reference]
-* http://httpbin.org/[httpbin, a test service for HTTP requests/responses]
-* http://requestb.in/[RequestBin, a service to inspect HTTP requests]
-
-Documentation of used Python libraries:
-
-* http://jinja.pocoo.org/docs/dev/[jinja2]
-* http://pygments.org/docs/[pygments]
-* http://fdik.org/pyPEG/index.html[pyPEG2]
-* http://pythonhosted.org/setuptools/[setuptools]
-* http://www.pyinstaller.org/[PyInstaller]
-* https://pypi.python.org/pypi/colorama[colorama]
-
-Related RFCs and standards:
-
-HTTP
-^^^^
-
-* https://tools.ietf.org/html/rfc2616[RFC 2616 - Hypertext Transfer Protocol
-- HTTP/1.1]
-(http://www.rfc-editor.org/errata_search.php?rfc=2616[Errata])
-* https://tools.ietf.org/html/rfc7230[RFC 7230 - Hypertext Transfer Protocol
-(HTTP/1.1): Message Syntax and Routing]
-(http://www.rfc-editor.org/errata_search.php?rfc=7230[Errata])
-* https://tools.ietf.org/html/rfc7231[RFC 7231 - Hypertext Transfer Protocol
-(HTTP/1.1): Semantics and Content]
-(http://www.rfc-editor.org/errata_search.php?rfc=7231[Errata])
-* https://tools.ietf.org/html/rfc7232[RFC 7232 - Hypertext Transfer Protocol
-(HTTP/1.1): Conditional Requests]
-(http://www.rfc-editor.org/errata_search.php?rfc=7232[Errata])
-* https://tools.ietf.org/html/rfc7233[RFC 7233 - Hypertext Transfer Protocol
-(HTTP/1.1): Range Requests]
-(http://www.rfc-editor.org/errata_search.php?rfc=7233[Errata])
-* https://tools.ietf.org/html/rfc7234[RFC 7234 - Hypertext Transfer Protocol
-(HTTP/1.1): Caching]
-(http://www.rfc-editor.org/errata_search.php?rfc=7234[Errata])
-* https://tools.ietf.org/html/rfc7235[RFC 7235 - Hypertext Transfer Protocol
-(HTTP/1.1): Authentication]
-(http://www.rfc-editor.org/errata_search.php?rfc=7235[Errata])
-* https://tools.ietf.org/html/rfc5987[RFC 5987 - Character Set and Language
-Encoding for Hypertext Transfer Protocol (HTTP) Header Field Parameters]
-(http://www.rfc-editor.org/errata_search.php?rfc=5987[Errata])
-* https://tools.ietf.org/html/rfc6266[RFC 6266 - Use of the
-Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)]
-(http://www.rfc-editor.org/errata_search.php?rfc=6266[Errata])
-* http://tools.ietf.org/html/rfc6265[RFC 6265 - HTTP State Management Mechanism
-(Cookies)] (http://www.rfc-editor.org/errata_search.php?rfc=6265[Errata])
-* http://www.cookiecentral.com/faq/#3.5[Netscape Cookie Format]
-
-Other
-^^^^^
-
-* https://tools.ietf.org/html/rfc5646[RFC 5646 - Tags for Identifying
-Languages] (http://www.rfc-editor.org/errata_search.php?rfc=5646[Errata])
-* http://www.w3.org/TR/CSS2/[Cascading Style Sheets Level 2 Revision 1 (CSS
-2.1) Specification]
-* http://doc.qt.io/qt-5/stylesheet-reference.html[Qt Style Sheets Reference]
-* http://mimesniff.spec.whatwg.org/[MIME Sniffing Standard]
-* http://spec.whatwg.org/[WHATWG specifications]
-* http://www.w3.org/html/wg/drafts/html/master/Overview.html[HTML 5.1 Nightly]
-* http://www.w3.org/TR/webstorage/[Web Storage]
-* http://www.brynosaurus.com/cachedir/spec.html[Cache directory tagging
-standard]
-* http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html[XDG
-basedir specification]
-
-Hints
-----
-
-Python and Qt objects
-~~~~~~~~~~~~~~~~~~~~~
-
-For many tasks, there are solutions available in both Qt and the Python
-standard library.
-
-In qutebrowser, the policy is usually to use the Python libraries, as they
-provide exceptions and other benefits.
-
-There are some exceptions to that:
-
-* `QThread` is used instead of Python threads because it provides signals and
-slots.
-* `QProcess` is used instead of Python's `subprocess`.
-* `QUrl` is used instead of storing URLs as string, see the
-<<handling-urls,handling URLs>> section for details.
-
-When using Qt objects, two issues must be taken care of:
-
-* Methods of Qt objects report their status with their return values,
-instead of using exceptions.
-+
-If a function gets or returns a Qt object which has an `.isValid()`
-method such as `QUrl` or `QModelIndex`, there's a helper function
-`ensure_valid` in `qutebrowser.utils.qtutils` which should get called
-on all such objects. It will raise
-`qutebrowser.utils.qtutils.QtValueError` if the value is not valid.
-+
-If a function returns something else on error, the return value should
-carefully be checked.
-
-* Methods of Qt objects have certain maximum values based on their
-underlying C++ types.
-+
-To avoid passing too large of a numeric parameter to a Qt function, all
-numbers should be range-checked using `qutebrowser.qtutils.check_overflow`,
-or by other means (e.g. by setting a maximum value for a config object).
-
-[[object-registry]]
-The object registry
-~~~~~~~~~~~~~~~~~~~
-
-The object registry in `qutebrowser.utils.objreg` is a collection of
-dictionaries which map object names to the actual long-living objects.
-
-There are currently these object registries, also called 'scopes':
-
-* The `global` scope, with objects which are used globally (`config`,
-`cookie-jar`, etc.).
-* The `tab` scope with objects which are per-tab (`hintmanager`, `webview`,
-etc.). Passing this scope to `objreg.get()` selects the object in the currently
-focused tab by default. A tab can be explicitly selected by passing
-+tab=_tab-id_, window=_win-id_+ to it.
-
-A new object can be registered by using
-+objreg.register(_name_, _object_[, scope=_scope_, window=_win-id_,
-tab=_tab-id_])+. An object should not be registered twice. To update it,
-`update=True` has to be given.
-
-An object can be retrieved by using +objreg.get(_name_[, scope=_scope_,
-window=_win-id_, tab=_tab-id_])+. The default scope is `global`.
-
-All objects can be printed by starting with the `--debug` flag and using the
-`:debug-all-objects` command.
-
-The registry is mainly used for <<commands,command handlers>>, but it can
-also be useful in places where using Qt's
-http://doc.qt.io/qt-5/signalsandslots.html[signals and slots] mechanism would
-be difficult.
-
-Logging
-~~~~~~~
-
-Logging is used at various places throughout the qutebrowser code. If you add a
-new feature, you should also add some strategic debug logging.
-
-Unlike other Python projects, qutebrowser doesn't use a logger per file,
-instead it uses custom-named loggers.
-
-The existing loggers are defined in `qutebrowser.utils.log`. If your feature
-doesn't fit in any of the logging categories, simply add a new line like this:
-
-[source,python]
----
-foo = getLogger('foo')
----
-
-Then in your source files, do this:
-
-[source,python]
----
-from qutebrowser.utils import log
-...
-log.foo.debug("Hello World")
----
-
-The following logging levels are available for every logger:
-
-[width="75%",cols="25%,75%"]
-|=======================================================================
-|critical  |Critical issue, qutebrowser can't continue to run.
-|error     |There was an issue and some kind of operation was abandoned.
-|warning   |There was an issue but the operation can continue running.
-|info      |General informational messages.
-|debug     |Verbose debugging information.
-|=======================================================================
-
-[[commands]]
-Commands
-~~~~~~~~
-
-qutebrowser has the concept of functions which are exposed to the user as
-commands.
-
-Creating a new command is straightforward:
-
-[source,python]
----
-import qutebrowser.commands.cmdutils
-
-...
-
-@cmdutils.register(...)
-def foo():
-    ...
----
-
-The commands arguments are automatically deduced by inspecting your function.
-
-If the function is a method of a class, the `@cmdutils.register` decorator
-needs to have an `instance=...` parameter which points to the (single/main)
-instance of the class.
-
-The `instance` parameter is the name of an object in the object registry, which
-then gets passed as the `self` parameter to the handler. The `scope` argument
-selects which object registry (global, per-tab, etc.) to use.  See the
-<<object-registry,object registry>> section for details.
-
-There are also other arguments to customize the way the command is
-registered; see the class documentation for `register` in
-`qutebrowser.commands.cmdutils` for details.
-
-The types of the function arguments are inferred based on their default values,
-e.g., an argument `foo=True` will be converted to a flag `-f`/`--foo` in
-qutebrowser's commandline.
-
-The type can be overridden using Python's
-http://legacy.python.org/dev/peps/pep-3107/[function annotations]:
-
-[source,python]
----
-@cmdutils.register(...)
-def foo(bar: int, baz=True):
-    ...
----
-
-Possible values:
-
- A callable (`int`, `float`, etc.): Gets called to validate/convert the value.
- A python enum type: All members of the enum are possible values.
- A `typing.Union` of multiple types above: Any of these types are valid
-  values, e.g., `typing.Union[str, int]`.
-
-You can customize how an argument is handled using the `@cmdutils.argument`
-decorator *after* `@cmdutils.register`. This can, for example, be used to
-customize the flag an argument should get:
-
-[source,python]
----
-@cmdutils.register(...)
-@cmdutils.argument('bar', flag='c')
-def foo(bar):
-    ...
----
-
-For a `str` argument, you can restrict the allowed strings using `choices`:
-
-[source,python]
----
-@cmdutils.register(...)
-@cmdutils.argument('bar', choices=['val1', 'val2'])
-def foo(bar: str):
-    ...
----
-
-For `typing.Union` types, the given `choices` are only checked if other types
-(like `int`) don't match.
-
-The following arguments are supported for `@cmdutils.argument`:
-
- `flag`: Customize the short flag (`-x`) the argument will get.
- `win_id=True`: Mark the argument as special window ID argument.
- `count=True`: Mark the argument as special count argument.
- `completion`: A completion function (see `qutebrowser.completions.models.*`)
-  to use when completing arguments for the given command.
- `choices`: The allowed string choices for the argument.
-
-The name of an argument will always be the parameter name, with any trailing
-underscores stripped and underscores replaced by dashes.
-
-[[handling-urls]]
-Handling URLs
-~~~~~~~~~~~~~
-
-qutebrowser handles two different types of URLs: URLs as a string, and URLs as
-the Qt `QUrl` type. As this can get confusing quickly, please follow the
-following guidelines:
-
-* Convert a string to a QUrl object as early as possible, i.e., directly after
-the user did enter it.
-    - Use `utils.urlutils.fuzzy_url` if the URL is entered by the user
-      somewhere.
-    - Be sure you handle `utils.urlutils.FuzzyError` and display an error
-      message to the user.
-* Convert a `QUrl` object to a string as late as possible, i.e., before
-displaying it to the user.
-    - If you want to display the URL to the user, use `url.toDisplayString()`
-      so password information is removed.
-    - If you want to get the URL as string for some other reason, you most
-      likely want to add the `QUrl.EncodeFully` and `QUrl.RemovePassword`
-      flags.
-* Name a string URL something like `urlstr`, and a `QUrl` something like `url`.
-* Mention in the docstring whether your function needs a URL string or a
-`QUrl`.
-* Call `ensure_valid` from `utils.qtutils` whenever getting or creating a
-`QUrl` and take appropriate action if not. Note the URL of the current page
-always could be an invalid QUrl (if nothing is loaded yet).
-
-Running valgrind on QtWebKit
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you want to run qutebrowser (and thus QtWebKit) with
-http://valgrind.org/[valgrind], you'll need to pass `--smc-check=all` to it or
-recompile QtWebKit with the Javascript JIT disabled.
-
-This is needed so valgrind handles self-modifying code correctly:
-
-[quote]
-____
-This option controls Valgrind's detection of self-modifying code. If no
-checking is done and a program executes some code, overwrites it with new
-code, and then executes the new code, Valgrind will continue to execute the
-translations it made for the old code. This will likely lead to incorrect
-behavior and/or crashes.
-
-...
-
-Note that the default option will catch the vast majority of cases. The main
-case it will not catch is programs such as JIT compilers that dynamically
-generate code and subsequently overwrite part or all of it. Running with all
-will slow Valgrind down noticeably.
-____
-
-Setting up a Windows Development Environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* Install https://www.python.org/downloads/release/python-362/[Python 3.6].
-* Install PyQt via `pip install PyQt5`.
-* Create a file at `C:\Windows\system32\python3.bat` with the following content (adjust the path as necessary):
-  `@C:\Python36\python %*`.
-  This will make the Python 3.6 interpreter available as `python3`, which is used by various development scripts.
-* Install git from the https://git-scm.com/download/win[git-scm downloads page].
-  Try not to enable `core.autocrlf`, since that will cause `flake8` to complain a lot. Use an editor that can deal with plain line feeds instead.
-* Clone your favourite qutebrowser repository.
-* To install tox, open an elevated cmd, enter your working directory and run `pip install -rmisc/requirements/requirements-tox.txt`.
-
-Note that the `flake8` tox env might not run due to encoding errors despite having LANG/LC_* set correctly.
-
-Rebuilding the website
-~~~~~~~~~~~~~~~~~~~~~~
-
-If you want to rebuild the website, run `./scripts/asciidoc2html.py --website <outputdir>`.
-
-Chrome URLs
-~~~~~~~~~~~
-
-With the QtWebEngine backend, qutebrowser supports several chrome:// urls which
-can be useful for debugging:
-
- chrome://appcache-internals/
- chrome://blob-internals/
- chrome://gpu/
- chrome://histograms/
- chrome://indexeddb-internals/
- chrome://media-internals/
- chrome://network-errors/
- chrome://serviceworker-internals/
- chrome://webrtc-internals/
- chrome://crash/ (crashes the current renderer process!)
- chrome://kill/ (kills the current renderer process!)
- chrome://gpucrash/ (crashes qutebrowser!)
- chrome://gpuhang/ (hangs qutebrowser!)
- chrome://gpuclean/ (crashes the current renderer process!)
- chrome://ppapiflashcrash/
- chrome://ppapiflashhang/
- chrome://quota-internals/ (Qt 5.11)
- chrome://taskscheduler-internals/ (Qt 5.11)
- chrome://sandbox/ (Qt 5.11, Linux only)
-
-QtWebEngine internals
-~~~~~~~~~~~~~~~~~~~~~
-
-This is mostly useful for qutebrowser maintainers to work around issues in Qt - if you don't understand it, don't worry, just ignore it.
-
-The hierarchy of widgets when QtWebEngine is involved looks like this:
-
- qutebrowser has a `WebEngineTab` object, which is its abstraction over QtWebKit/QtWebEngine.
- The `WebEngineTab` has a `_widget` attribute, which is the https://doc.qt.io/qt-5/qwebengineview.html[QWebEngineView]
- That view has a https://doc.qt.io/qt-5/qwebenginepage.html[QWebEnginePage] for everything which doesn't require rendering.
- The view also has a layout with exactly one element (which also is its `focusProxy()`)
- That element is the  http://code.qt.io/cgit/qt/qtwebengine.git/tree/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp[RenderWidgetHostViewQtDelegateWidget] (it inherits https://doc.qt.io/qt-5/qquickwidget.html[QQuickWidget]) - also often referred to as RWHV or RWHVQDW. It can be obtained via `sip.cast(tab._widget.focusProxy(), QQuickWidget)`.
- Calling `rootObject()` on that gives us the https://doc.qt.io/qt-5/qquickitem.html[QQuickItem] where Chromium renders into (?). With it, we can do things like `.setRotation(20)`.
-
-Style conventions
-----------------
-
-qutebrowser's coding conventions are based on
-http://legacy.python.org/dev/peps/pep-0008/[PEP8] and the https://google-styleguide.googlecode.com/svn/trunk/pyguide.html[Google Python style guidelines] with some additions:
-
-* The _Raise:_ section is not added to the docstring.
-* Methods overriding Qt methods (obviously!) don't follow the naming schemes.
-* Everything else does though, even slots.
-* Docstrings should look like described in
-http://legacy.python.org/dev/peps/pep-0257/[PEP257] and the google guidelines.
-* Class docstrings have additional _Attributes:_, _Class attributes:_ and
-  _Signals:_ sections.
-* In docstrings of command handlers (registered via `@cmdutils.register`), the
-description should be split into two parts by using `//` - the first part is
-the description of the command like it will appear in the documentation, the
-second part is "internal" documentation only relevant to people reading the
-sourcecode.
-+
-Example for a class docstring:
-+
-[source,python]
----
-"""Some object.
-
-Attributes:
-    blub: The current thing to handle.
-
-Signals:
-    valueChanged: Emitted when a value changed.
-                  arg: The new value
-"""
----
-+
-Example for a method/function docstring:
-+
-[source,python]
----
-"""Do something special.
-
-This will do something.
-
-//
-
-It is based on http://example.com/.
-
-Args:
-    foo: ...
-
-Return:
-    True if something, False if something else.
-"""
----
-+
-* The layout of a module should be roughly like this:
-  - Shebang (`#!/usr/bin/python`, if needed)
-  - vim-modeline (`# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et`)
-  - Copyright
-  - GPL boilerplate
-  - Module docstring
-  - Python standard library imports
-  - PyQt imports
-  - qutebrowser imports
-  - functions
-  - classes
-* The layout of a class should be like this:
-  - docstring
-  - `__magic__` methods
-  - other methods
-  - overrides of Qt methods
-
-Checklists
----------
-
-These are mainly intended for myself, but they also fit in here well.
-
-New Qt release
-~~~~~~~~~~~~~~
-
-* Run all tests and check nothing is broken.
-* Check the
-https://bugreports.qt.io/issues/?jql=reporter%20%3D%20%22The%20Compiler%22%20ORDER%20BY%20fixVersion%20ASC[Qt bugtracker]
-and make sure all bugs marked as resolved are actually fixed.
-* Update own PKGBUILDs based on upstream Archlinux updates and rebuild.
-* Update recommended Qt version in `README`.
-* Grep for `WORKAROUND` in the code and test if fixed stuff works without the
-workaround.
-* Check relevant
-https://github.com/qutebrowser/qutebrowser/issues?q=is%3Aopen+is%3Aissue+label%3Aqt[qutebrowser
-bugs] and check if they're fixed.
-
-New PyQt release
-~~~~~~~~~~~~~~~~
-
-* See above.
-* Update `tox.ini`/`.travis.yml`/`.appveyor.yml` to test new versions.
-
-qutebrowser release
-~~~~~~~~~~~~~~~~~~~
-
-* Make sure there are no unstaged changes and the tests are green.
-* Make sure all issues with the related milestone are closed.
-* Run `x=... y=...` to set the respective shell variables.
-
-* Update changelog (remove *(unreleased)*).
-* Adjust `__version_info__` in `qutebrowser/__init__.py`.
-* Commit.
-
-* Create annotated git tag (`git tag -s "v1.$x.$y" -m "Release v1.$x.$y"`).
-* `git push origin`; `git push origin v1.$x.$y`.
-* If committing on minor branch, cherry-pick release commit to master.
-* Create release on github.
-* Mark the milestone at https://github.com/qutebrowser/qutebrowser/milestones
-as closed.
-
-* Linux: Run `git checkout v1.$x.$y && ./.venv/bin/python3 scripts/dev/build_release.py --upload v1.$x.$y`.
-* Windows: Run `git checkout v1.X.Y; py -3.6 scripts\dev\build_release.py --asciidoc C:\Python27\python C:\asciidoc-8.6.9\asciidoc.py --upload v1.X.Y` (replace X/Y by hand).
-* macOS: Run `pyenv shell 3.6.6 && git checkout v1.X.Y && python3 scripts/dev/build_release.py --upload v1.X.Y` (replace X/Y by hand).
-* On server:
-  - Run `python3 scripts/dev/download_release.py v1.X.Y` (replace X/Y by hand).
-  - Run `git pull github master && sudo python3 scripts/asciidoc2html.py --website /srv/http/qutebrowser`
-* Update `qutebrowser-git` PKGBUILD if dependencies/install changed.
-* Announce to qutebrowser and qutebrowser-announce mailinglist.
--- a/doc/faq.asciidoc
+++ b/doc/faq.asciidoc
@@ -1,304 +0,0 @@
-Frequently asked questions
-==========================
-:title: Frequently asked questions
-The Compiler <mail@qutebrowser.org>
-
-[qanda]
-What is qutebrowser based on?::
-    qutebrowser uses http://www.python.org/[Python], http://qt.io/[Qt] and
-    http://www.riverbankcomputing.com/software/pyqt/intro[PyQt].
-+
-The concept of it is largely inspired by http://portix.bitbucket.org/dwb/[dwb]
-and http://www.vimperator.org/vimperator[Vimperator]. Many actions and
-key bindings are similar to dwb.
-
-Why another browser?::
-    It might be hard to believe, but I didn't find any browser which I was
-    happy with, so I started to write my own. Also, I needed a project to get
-    into writing GUI applications with Python and
-    link:http://qt.io/[Qt]/link:http://www.riverbankcomputing.com/software/pyqt/intro[PyQt].
-+
-Read the next few questions to find out why I was unhappy with existing
-software.
-
-What's wrong with link:http://portix.bitbucket.org/dwb/[dwb]/link:http://sourceforge.net/projects/vimprobable/[vimprobable]/link:https://mason-larobina.github.io/luakit/[luakit]/link:http://pwmt.org/projects/jumanji/[jumanji]/... (projects based on WebKitGTK)?::
-    Most of them are based on the http://webkitgtk.org/[WebKitGTK+]
-    http://webkitgtk.org/reference/webkitgtk/stable/index.html[WebKit1] API,
-    which causes a lot of crashes. As the GTK API using WebKit1 is
-    https://lists.webkit.org/pipermail/webkit-gtk/2014-March/001821.html[deprecated],
-    these bugs are never going to be fixed.
-+
-When qutebrowser was created, the newer
-http://webkitgtk.org/reference/webkit2gtk/stable/index.html[WebKit2 API] lacked
-basic features like proxy support, and almost no projects have started porting
-to WebKit2. In the meantime, this situation has improved a bit, but there are
-still only a few projects which have some kind of WebKit2 support (see the
-https://github.com/qutebrowser/qutebrowser#similar-projects[list of
-alternatives]).
-+
-qutebrowser uses http://qt.io/[Qt] and
-http://wiki.qt.io/QtWebEngine[QtWebEngine] by default (and supports
-http://wiki.qt.io/QtWebKit[QtWebKit] optionally). QtWebEngine is based on
-Google's https://www.chromium.org/Home[Chromium]. With an up-to-date Qt, it has
-much more man-power behind it than WebKitGTK+ has, and thus supports more modern
-web features - it's also arguably more secure.
-
-What's wrong with https://www.mozilla.org/en-US/firefox/new/[Firefox] and link:http://5digits.org/pentadactyl/[Pentadactyl]/link:http://www.vimperator.org/vimperator[Vimperator]?::
-    Firefox likes to break compatibility with addons on each upgrade, gets
-    slower and more bloated with every upgrade, and has some
-    https://blog.mozilla.org/advancingcontent/2014/02/11/publisher-transformation-with-users-at-the-center/[horrible
-    ideas] lately.
-+
-Also, developing addons for it is a nightmare.
-
-What's wrong with http://www.chromium.org/Home[Chromium] and https://vimium.github.io/[Vimium]?::
-    The Chrome plugin API doesn't seem to allow much freedom for plugin
-    writers, which results in Vimium not really having all the features you'd
-    expect from a proper minimal, vim-like browser.
-
-Why Python?::
-    I enjoy writing Python since 2011, which made it one of the possible
-    choices. I wanted to use http://qt.io/[Qt] because of
-    http://wiki.qt.io/QtWebKit[QtWebKit] so I didn't have
-    http://wiki.qt.io/Category:LanguageBindings[many other choices]. I don't
-    like C++ and can't write it very well, so that wasn't an alternative.
-
-But isn't Python too slow for a browser?::
-    http://www.infoworld.com/d/application-development/van-rossum-python-not-too-slow-188715[No.]
-    I believe efficiency while coding is a lot more important than efficiency
-    while running. Also, most of the heavy lifting of qutebrowser is done by Qt
-    and WebKit in C++, with the
-    https://wiki.python.org/moin/GlobalInterpreterLock[GIL] released.
-
-Is qutebrowser secure?::
-    Most security issues are in the backend (which handles networking,
-    rendering, JavaScript, etc.) and not qutebrowser itself.
-+
-qutebrowser uses http://wiki.qt.io/QtWebEngine[QtWebEngine] by default.
-QtWebEngine is based on Google's https://www.chromium.org/Home[Chromium]. While
-Qt only updates to a new Chromium release on every minor Qt release (all ~6
-months), every patch release backports security fixes from newer Chromium
-versions. In other words: As long as you're using an up-to-date Qt, you should
-be recieving security updates on a regular basis, without qutebrowser having to
-do anything. Chromium's process isolation and
-https://chromium.googlesource.com/chromium/src/+/master/docs/design/sandbox.md[sandboxing]
-features are also enabled as a second line of defense.
-+
-http://wiki.qt.io/QtWebKit[QtWebKit] is also supported as an alternative
-backend, but hasn't seen new releases
-https://github.com/annulen/webkit/releases[in a while]. It also doesn't have any
-process isolation or sandboxing.
-+
-Security issues in qutebrowser's code happen very rarely (as per March 2018,
-there has been one security issue caused by qutebrowser in over four years) and
-are fixed timely. To report security bugs, please contact me directly at
-mail@qutebrowser.org, GPG ID
-https://www.the-compiler.org/pubkey.asc[0x916eb0c8fd55a072].
-
-Is there an adblocker?::
-    There is a host-based adblocker which takes /etc/hosts-like lists. A "real"
-    adblocker has a
-    http://www.reddit.com/r/programming/comments/25j41u/adblock_pluss_effect_on_firefoxs_memory_usage/chhpomw[big
-    impact] on browsing speed and
-    https://blog.mozilla.org/nnethercote/2014/05/14/adblock-pluss-effect-on-firefoxs-memory-usage/[RAM
-    usage], so implementing support for AdBlockPlus-like lists is currently not
-    a priority.
-
-How do I play Youtube videos with mpv?::
-    You can easily add a key binding to play youtube videos inside a real video
-    player - optionally even with hinting for links:
-+
----
-:bind m spawn mpv {url}
-:bind M hint links spawn mpv {hint-url}
----
-+
-Note that you might need an additional package (e.g.
-https://www.archlinux.org/packages/community/any/youtube-dl/[youtube-dl] on
-Archlinux) to play web videos with mpv.
-+
-There is a very useful script for mpv, which emulates "unique application"
-functionality. This way you can add links to the mpv playlist instead of
-playing them all at once.
-+
-You can find the script here: https://github.com/mpv-player/mpv/blob/master/TOOLS/umpv
-+
-It also works nicely with rapid hints:
-+
----
-:bind m spawn umpv {url}
-:bind M hint links spawn umpv {hint-url}
-:bind ;M hint --rapid links spawn umpv {hint-url}
----
-
-How do I use qutebrowser with mutt?::
-    Due to a Qt limitation, local files without `.html` extensions are
-    "downloaded" instead of displayed, see
-    https://github.com/qutebrowser/qutebrowser/issues/566[#566]. You can work
-    around this by using this in your `mailcap`:
-+
----
-    text/html; mv %s %s.html && qutebrowser %s.html >/dev/null 2>/dev/null; needsterminal;
----
-
-What is the difference between bookmarks and quickmarks?::
-    Bookmarks will always use the title of the website as their name, but with quickmarks
-    you can set your own title.
-+
-For example, if you bookmark multiple food recipe websites and use `:open`, 
-you have to type the title or address of the website.
-+
-When using quickmark, you can give them all names, like
-`foodrecipes1`, `foodrecipes2` and so on. When you type 
-`:open foodrecipes`, you will see a list of all the food recipe sites,
-without having to remember the exact website title or address.
-
-How do I use spell checking?::
-	Configuring spell checking in qutebrowser depends on the backend in use
-    (see https://github.com/qutebrowser/qutebrowser/issues/700[#700] for
-	a more detailed discussion).
-+
-For QtWebKit:
-
-. Install https://github.com/QupZilla/qtwebkit-plugins[qtwebkit-plugins].
-  . Note: with QtWebKit reloaded you may experience some issues. See
-    https://github.com/QupZilla/qtwebkit-plugins/issues/10[#10].
-. The dictionary to use is taken from the `DICTIONARY` environment variable.
-  The default is `en_US`. For example to use Dutch spell check set `DICTIONARY`
-  to `nl_NL`; you can't use multiple dictionaries or change them at runtime at
-  the moment.
-  (also see the README file for `qtwebkit-plugins`).
-. Remember to install the hunspell dictionaries if you don't have them already
-  (most distros should have packages for this).
-
-+
-For QtWebEngine:
-
-. Make sure your versions of PyQt and Qt are 5.8 or higher.
-. Use `dictcli.py` script to install dictionaries.
-  Run the script with `-h` for the parameter description.
-. Set `spellcheck.languages` to the desired list of languages, e.g.:
-  `:set spellcheck.languages "['en-US', 'pl-PL']"`
-
-How do I use Tor with qutebrowser?::
-    Start tor on your machine, and do `:set content.proxy socks://localhost:9050/`
-    in qutebrowser. Note this won't give you the same amount of fingerprinting
-    protection that the Tor Browser does, but it's useful to be able to access
-    `.onion` sites.
-
-Why does J move to the next (right) tab, and K to the previous (left) one?::
-    One reason is because https://bitbucket.org/portix/dwb[dwb] did it that way,
-    and qutebrowser's keybindings are designed to be compatible with dwb's.
-    The rationale behind it is that J is "down" in vim, and K is "up", which
-    corresponds nicely to "next"/"previous". It also makes much more sense with
-    vertical tabs (e.g. `:set tabs.position left`).
-
-What's the difference between insert and passthrough mode?::
-    They are quite similar, but insert mode has some bindings (like `Ctrl-e` to
-    open an editor) while passthrough mode only has escape bound. It might also
-    be useful to rebind escape to something else in passthrough mode only, to be
-    able to send an escape keypress to the website.
-
-Why takes it longer to open an URL in qutebrowser than in chromium?::
-    When opening an URL in an existing instance the normal qutebrowser
-    Python script is started and a few PyQt libraries need to be
-    loaded until it is detected that there is an instance running
-    where the URL is then passed to. This takes some time.
-    One workaround is to use this
-    https://github.com/qutebrowser/qutebrowser/blob/master/scripts/open_url_in_instance.sh[script]
-    and place it in your $PATH with the name "qutebrowser". This
-    script passes the URL via an unix socket to qutebrowser (if its
-    running already) using socat which is much faster and starts a new
-    qutebrowser if it is not running already. Also check if you want
-    to use webengine as backend in line 17 and change it to your
-    needs.
-
-How do I make qutebrowser use greasemonkey scripts?::
-    There is currently no UI elements to handle managing greasemonkey scripts.
-    All management of what scripts are installed or disabled is done in the
-    filesystem by you. qutebrowser reads all files that have an extension of
-    `.js` from the `<data>/greasemonkey/` folder and attempts to load them.
-    Where `<data>` is the qutebrowser data directory shown in the `Paths`
-    section of the page displayed by `:version`. If you want to disable a
-    script just rename it, for example, to have `.disabled` on the end, after
-    the `.js` extension. To reload scripts from that directory run the command
-    `:greasemonkey-reload`.
-+
-Troubleshooting: to check that your script is being loaded when
-`:greasemonkey-reload` runs you can start qutebrowser with the arguments
-`--debug --logfilter greasemonkey,js` and check the messages on the
-program's standard output for errors parsing or loading your script.
-You may also see javascript errors if your script is expecting an environment
-that we fail to provide.
-+
-Note that there are some missing features which you may run into:
-
-. Some scripts expect `GM_xmlhttpRequest` to ignore Cross Origin Resource
-  Sharing restrictions, this is currently not supported, so scripts making
-  requests to third party sites will often fail to function correctly.
-. If your backend is a QtWebEngine version 5.8, 5.9 or 5.10 then regular
-  expressions are not supported in `@include` or `@exclude` rules. If your
-  script uses them you can re-write them to use glob expressions or convert
-  them to `@match` rules.
-  See https://wiki.greasespot.net/Metadata_Block[the wiki] for more info.
-. Any greasemonkey API function to do with adding UI elements is not currently
-  supported. That means context menu extentensions and background pages.
-    
-== Troubleshooting
-
-Unable to view flash content.::
-    If you have flash installed for on your system, it's necessary to enable plugins
-    to use the flash plugin. Using the command `:set content.plugins true`
-    in qutebrowser will enable plugins. Packages for flash should
-    be provided for your platform or it can be obtained from
-    http://get.adobe.com/flashplayer/[Adobe].
-
-Experiencing freezing on sites like duckduckgo and youtube.::
-    This issue could be caused by stale plugin files installed by `mozplugger`
-    if mozplugger was subsequently removed.
-    Try exiting qutebrowser and removing `~/.mozilla/plugins/mozplugger*.so`.
-    See https://github.com/qutebrowser/qutebrowser/issues/357[Issue #357]
-    for more details.
-
-When using QtWebEngine, qutebrowser reports "Render Process Crashed" and the console prints a traceback on Gentoo Linux or another Source-Based Distro::
-    As stated in https://gcc.gnu.org/gcc-6/changes.html[GCC's Website] GCC 6 has introduced some optimizations that could break non-conforming codebases, like QtWebEngine. +
-    As a workaround, you can disable the nullpointer check optimization by adding the -fno-delete-null-pointer-checks flag while compiling. +
-    On gentoo, you just need to add it into your make.conf, like this: +
-    
-    CFLAGS="... -fno-delete-null-pointer-checks"
-    CXXFLAGS="... -fno-delete-null-pointer-checks"
-+
-And then re-emerging qtwebengine with: +
-    
-    emerge -1 qtwebengine
-
-Unable to view DRM content (Netflix, Spotify, etc.).::
-    You will need to install `widevine` and set `qt.args` to point to it.
-    Qt 5.9 currently only supports widevine up to Chrome version 61.
-+
-On Arch, simply install `qt5-webengine-widevine` from the AUR and run:
-+
----
-:set qt.args '["ppapi-widevine-path=/usr/lib/qt/plugins/ppapi/libwidevinecdmadapter.so"]'
-:restart
----
-+
-For other distributions, download the chromium tarball and widevine-cdm zip from
-https://aur.archlinux.org/packages/qt5-webengine-widevine/[the AUR page],
-extract `libwidevinecdmadapter.so` and `libwidevinecdm.so` files, respectively,
-and move them to the `ppapi` plugin directory in your Qt library directory (create it if it does not exist).
-+
-Lastly, set your `qt.args` to point to that directory and restart qutebrowser:
-+
----
-:set qt.args '["ppapi-widevine-path=/usr/lib64/qt5/plugins/ppapi/libwidevinecdmadapter.so"]'
-:restart
----
-
-My issue is not listed.::
-    If you experience any segfaults or crashes, you can report the issue in
-    https://github.com/qutebrowser/qutebrowser/issues[the issue tracker] or
-    using the `:report` command.
-    If you are reporting a segfault, make sure you read the
-    link:stacktrace.asciidoc[guide] on how to report them with all needed
-    information.
--- a/doc/help/commands.asciidoc
+++ b/doc/help/commands.asciidoc
--- a/doc/help/configuring.asciidoc
+++ b/doc/help/configuring.asciidoc
@@ -1,458 +0,0 @@
-Configuring qutebrowser
-=======================
-
-IMPORTANT: qutebrowser's configuration system was completely rewritten in
-September 2017. This information is not applicable to older releases, and older
-information elsewhere might be outdated.
-
-qutebrowser's config files
--------------------------
-
-qutebrowser releases before v1.0.0 had a `qutebrowser.conf` and `keys.conf`
-file. Those are not used anymore since that release - see
-<<migrating,"Migrating older configurations">> for information on how to
-migrate to the new config.
-
-When using `:set` and `:bind`, changes are saved to an `autoconfig.yml` file
-automatically. If you don't want to have a config file which is curated by
-hand, you can simply use those - see
-<<autoconfig,"Configuring qutebrowser via the user interface">> for details.
-
-For more advanced configuration, you can write a `config.py` file - see
-<<configpy,"Configuring qutebrowser via config.py">>. As soon as a `config.py`
-exists, the `autoconfig.yml` file **is not read anymore** by default. You need
-to <<configpy-autoconfig,load it by hand>> if you want settings done via
-`:set`/`:bind` to still persist.
-
-[[autoconfig]]
-Configuring qutebrowser via the user interface
----------------------------------------------
-
-The easy (but less flexible) way to configure qutebrowser is using its user
-interface or command line. Changes you make this way are immediately active
-(with the exception of a few settings, where this is pointed out in the
-documentation) and are persisted in an `autoconfig.yml` file.
-
-The `autoconfig.yml` file is located in the "config" folder listed on the
-link:qute://version[] page. On macOS, the "auto config" folder is used, which is
-different from where hand-written config files are kept.
-
-However, **do not** edit `autoconfig.yml` by hand. Instead, see the next
-section.
-
-If you want to customize many settings, you can open the link:qute://settings[]
-page by running `:set` without any arguments, where all settings are listed and
-customizable.
-
-Using the link:commands.html#set[`:set`] command and command completion, you
-can quickly set settings interactively, for example `:set tabs.position left`.
-
-Some settings are also customizable for a given
-https://developer.chrome.com/apps/match_patterns[URL pattern] by doing e.g.
-`:set --pattern=*://example.com/ content.images false`.
-
-To get more help about a setting, use e.g. `:help tabs.position`.
-
-To bind and unbind keys, you can use the link:commands.html#bind[`:bind`] and
-link:commands.html#unbind[`:unbind`] commands:
-
- Binding the key chain `,v` to the `:spawn mpv {url}` command:
-  `:bind ,v spawn mpv {url}`
- Unbinding the same key chain: `:unbind ,v`
-
-Key chains starting with a comma are ideal for custom bindings, as the comma key
-will never be used in a default keybinding.
-
-See the help pages linked above (or `:help :bind`, `:help :unbind`) for more
-information.
-
-Other useful commands for config manipulation are
-link:commands.html#config-unset[`:config-unset`] to reset a value to its default,
-link:commands.html#config-clear[`:config-clear`] to reset the entire configuration,
-and link:commands.html#config-cycle[`:config-cycle`] to cycle a setting between
-different values.
-
-[[configpy]]
-Configuring qutebrowser via config.py
-------------------------------------
-
-For more powerful configuration possibilities, you can create a `config.py`
-file. Since it's a Python file, you have much more flexibility for
-configuration. Note that qutebrowser will never touch this file - this means
-you'll be responsible for updating it when upgrading to a newer qutebrowser
-version.
-
-You can run `:config-edit` inside qutebrowser to open the file in your editor,
-`:config-source` to reload the file (`:config-edit` does this automatically), or
-`:config-write-py --defaults` to write a template file to work with.
-
-The file should be located in the "config" location listed on
-link:qute://version[], which is typically `~/.config/qutebrowser/config.py` on
-Linux, `~/.qutebrowser/config.py` on macOS, and
-`%APPDATA%/qutebrowser/config.py` on Windows.
-
-Two global objects are pre-defined when running `config.py`: `c` and `config`.
-
-Changing settings
-~~~~~~~~~~~~~~~~~
-
-While you can set settings using the `config.set()` method (which is explained
-in the next section), it's easier to use the `c` shorthand object to easily set
-settings like this:
-
-.config.py:
-[source,python]
----
-c.tabs.position = "left"
-c.completion.shrink = True
----
-
-Note that qutebrowser does some Python magic so it's able to warn you about
-mistyped config settings. As an example, if you do `c.tabs.possition = "left"`,
-you'll get an error when starting.
-
-See the link:settings.html[settings help page] for all available settings. The
-accepted values depend on the type of the option. Commonly used are:
-
- Strings: `c.tabs.position = "left"`
- Booleans: `c.completion.shrink = True`
- Integers: `c.messages.timeout = 5000`
- Dictionaries:
-  * `c.headers.custom = {'X-Hello': 'World', 'X-Awesome': 'yes'}` to override
-    any other values in the dictionary.
-  * `c.aliases['foo'] = 'message-info foo'` to add a single value.
- Lists:
-  * `c.url.start_pages = ["https://www.qutebrowser.org/"]` to override any
-    previous elements.
-  * `c.url.start_pages.append("https://www.python.org/")` to add a new value.
-
-Any other config types (e.g. a color) are specified as a string. The only
-exception is the `Regex` type, which can take either a string (with an `r`
-prefix to preserve backslashes) or a Python regex object:
-
- `c.hints.next_regexes.append(r'\bvor\b')`
- `c.hints.prev_regexes.append(re.compile(r'\bzurück\b'))`
-
-If you want to read a setting, you can use the `c` object to do so as well:
-`c.colors.tabs.even.bg = c.colors.tabs.odd.bg`.
-
-Using strings for setting names
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you want to set settings based on their name as a string, use the
-`config.set` method:
-
-.config.py:
-[source,python]
----
-# Equivalent to:
-# c.content.javascript.enabled = False
-config.set('content.javascript.enabled', False)
----
-
-To read a setting, use the `config.get` method:
-
-[source,python]
----
-# Equivalent to:
-# color = c.colors.completion.fg
-color = config.get('colors.completion.fg')
----
-
-Per-domain settings
-~~~~~~~~~~~~~~~~~~~
-
-Using `config.set`, some settings are also customizable for a given
-https://developer.chrome.com/apps/match_patterns[URL pattern]:
-
-[source,python]
----
-config.set('content.images', False, '*://example.com/')
----
-
-Alternatively, you can use `with config.pattern(...) as p:` to get a shortcut
-similar to `c.` which is scoped to the given domain:
-
-[source,python]
----
-with config.pattern('*://example.com/') as p:
-    p.content.images = False
----
-
-Binding keys
-~~~~~~~~~~~~
-
-While it's possible to change the `bindings.commands` setting to bind keys, it's
-preferred to use the `config.bind` command. Doing so ensures the commands are
-valid and normalizes different expressions which map to the same key.
-
-For details on how to specify keys and the available modes, see the
-link:settings.html#bindings.commands[documentation] for the `bindings.commands`
-setting.
-
-To bind a key:
-
-.config.py:
-[source,python]
----
-config.bind('<Ctrl-v>', 'spawn mpv {url}')
----
-
-To bind a key in a mode other than `'normal'`, add a `mode` argument:
-
-[source,python]
----
-config.bind('<Ctrl-y>', 'prompt-yes', mode='prompt')
----
-
-To unbind a key (either a key which has been bound before, or a default binding):
-
-[source,python]
----
-config.unbind('<Ctrl-v>', mode='normal')
----
-
-To bind keys without modifiers, specify a key chain to bind as a string. Key
-chains starting with a comma are ideal for custom bindings, as the comma key
-will never be used in a default keybinding.
-
-[source,python]
----
-config.bind(',v', 'spawn mpv {url}')
----
-
-To suppress loading of any default keybindings, you can set
-`c.bindings.default = {}`.
-
-[[configpy-autoconfig]]
-Loading `autoconfig.yml`
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-All customization done via the UI (`:set`, `:bind` and `:unbind`) is
-stored in the `autoconfig.yml` file, which is not loaded automatically as soon
-as a `config.py` exists. If you want those settings to be loaded, you'll need to
-explicitly load the `autoconfig.yml` file in your `config.py` by doing:
-
-.config.py:
-[source,python]
----
-config.load_autoconfig()
----
-
-If you do so at the top of your file, your `config.py` settings will take
-precedence as they overwrite the settings done in `autoconfig.yml`.
-
-Importing other modules
-~~~~~~~~~~~~~~~~~~~~~~~
-
-You can import any module from the
-https://docs.python.org/3/library/index.html[Python standard library] (e.g.
-`import os.path`), as well as any module installed in the environment
-qutebrowser is run with.
-
-If you have an `utils.py` file in your qutebrowser config folder, you can import
-that via `import utils` as well.
-
-While it's in some cases possible to import code from the qutebrowser
-installation, doing so is unsupported and discouraged.
-
-To read config data from a different file with `c` and `config` available, you
-can use `config.source('otherfile.py')` in your `config.py`.
-
-Getting the config directory
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you need to get the qutebrowser config directory, you can do so by reading
-`config.configdir`. Similarly, you can get the qutebrowser data directory via
-`config.datadir`.
-
-This gives you a https://docs.python.org/3/library/pathlib.html[`pathlib.Path`
-object], on which you can use `/` to add more directory parts, or `str(...)` to
-get a string:
-
-.config.py:
-[source,python]
----
-print(str(config.configdir / 'config.py'))
----
-
-Handling errors
-~~~~~~~~~~~~~~~
-
-If there are errors in your `config.py`, qutebrowser will try to apply as much
-of it as possible, and show an error dialog before starting.
-
-qutebrowser tries to display errors which are easy to understand even for people
-who are not used to writing Python. If you see a config error which you find
-confusing or you think qutebrowser could handle better, please
-https://github.com/qutebrowser/qutebrowser/issues[open an issue]!
-
-Recipes
-~~~~~~~
-
-Reading a YAML file
-^^^^^^^^^^^^^^^^^^^
-
-To read a YAML config like this:
-
-.config.yml:
----
-tabs.position: left
-tabs.show: switching
----
-
-You can use:
-
-.config.py:
-[source,python]
----
-import yaml
-
-with (config.configdir / 'config.yml').open() as f:
-    yaml_data = yaml.load(f)
-
-for k, v in yaml_data.items():
-    config.set(k, v)
----
-
-Reading a nested YAML file
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To read a YAML file with nested values like this:
-
-.colors.yml:
----
-colors:
-  statusbar:
-    normal:
-      bg: lime
-      fg: black
-    url:
-      fg: red
----
-
-You can use:
-
-.config.py:
-[source,python]
----
-import yaml
-
-with (config.configdir / 'colors.yml').open() as f:
-    yaml_data = yaml.load(f)
-
-def dict_attrs(obj, path=''):
-    if isinstance(obj, dict):
-        for k, v in obj.items():
-            yield from dict_attrs(v, '{}.{}'.format(path, k) if path else k)
-    else:
-        yield path, obj
-
-for k, v in dict_attrs(yaml_data):
-    config.set(k, v)
----
-
-Note that this won't work for values which are dictionaries.
-
-Binding chained commands
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have a lot of chained commands you want to bind, you can write a helper
-to do so:
-
-[source,python]
----
-def bind_chained(key, *commands):
-    config.bind(key, ' ;; '.join(commands))
-
-bind_chained('<Escape>', 'clear-keychain', 'search')
----
-
-Reading colors from Xresources
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can use something like this to read colors from an `~/.Xresources` file:
-
-[source,python]
----
-import subprocess
-
-def read_xresources(prefix):
-    props = {}
-    x = subprocess.run(['xrdb', '-query'], stdout=subprocess.PIPE)
-    lines = x.stdout.decode().split('\n')
-    for line in filter(lambda l : l.startswith(prefix), lines):
-        prop, _, value = line.partition(':\t')
-        props[prop] = value
-    return props
-
-xresources = read_xresources('*')
-c.colors.statusbar.normal.bg = xresources['*.background']
----
-
-Pre-built colorschemes
-^^^^^^^^^^^^^^^^^^^^^^
-
- A collection of https://github.com/chriskempson/base16[base16] color-schemes can be found in https://github.com/theova/base16-qutebrowser[base16-qutebrowser] and used with https://github.com/AuditeMarlow/base16-manager[base16-manager].
- Two implementations of the https://github.com/arcticicestudio/nord[Nord] colorscheme for qutebrowser exist: https://github.com/Linuus/nord-qutebrowser[Linuus], https://github.com/KnownAsDon/QuteBrowser-Nord-Theme[KnownAsDon]
-
-Avoiding flake8 errors
-^^^^^^^^^^^^^^^^^^^^^^
-
-If you use an editor with flake8 and pylint integration, it may have some
-complaints about invalid names, undefined variables, or missing docstrings.
-You can silence those with:
-
-[source,python]
----
-# pylint: disable=C0111
-c = c  # noqa: F821 pylint: disable=E0602,C0103
-config = config  # noqa: F821 pylint: disable=E0602,C0103
----
-
-For type annotation support (note that those imports aren't guaranteed to be
-stable across qutebrowser versions):
-
-[source,python]
----
-# pylint: disable=C0111
-from qutebrowser.config.configfiles import ConfigAPI  # noqa: F401
-from qutebrowser.config.config import ConfigContainer  # noqa: F401
-config = config  # type: ConfigAPI # noqa: F821 pylint: disable=E0602,C0103
-c = c  # type: ConfigContainer # noqa: F821 pylint: disable=E0602,C0103
----
-
-[[migrating]]
-Migrating older configurations
------------------------------
-
-qutebrowser does no automatic migration for the new configuration. However,
-there's a special link:qute://configdiff/old[configdiff] page
-(`qute://configdiff/old`) in qutebrowser, which will show you the changes you
-did in your old configuration, compared to the old defaults.
-
-Other changes in default settings:
-
- In v1.1.x and newer, `<Up>` and `<Down>` navigate through command history
-  if no text was entered yet.
-  With v1.0.x, they always navigate through command history instead of selecting
-  completion items. Use `<Tab>`/`<Shift-Tab>` to cycle through the completion
-  instead.
-  You can get back the old behavior by doing:
-+
----
-:bind -m command <Up> completion-item-focus prev
-:bind -m command <Down> completion-item-focus next
----
-+
-or always navigate through command history with
-+
----
-:bind -m command <Up> command-history-prev
-:bind -m command <Down> command-history-next
----
-
- The default for `completion.web_history_max_items` is now set to `-1`, showing
-  an unlimited number of items in the completion for `:open` as the new
-  sqlite-based completion is much faster. If the `:open` completion is too slow
-  on your machine, set an appropriate limit again.
--- a/doc/help/index.asciidoc
+++ b/doc/help/index.asciidoc
@@ -6,14 +6,10 @@ Documentation

 The following help pages are currently available:

-* link:../quickstart.html[Quick start guide]
-* link:../faq.html[Frequently asked questions]
-* link:../changelog.html[Change Log]
+* link:quickstart.html[Quick start guide]
+* link:FAQ.html[Frequently asked questions]
 * link:commands.html[Documentation of commands]
-* link:configuring.html[Configuring qutebrowser]
 * link:settings.html[Documentation of settings]
-* link:../userscripts.html[How to write userscripts]
-* link:../contributing.html[Contributing to qutebrowser]

 Getting help
 ------------
--- a/doc/help/settings.asciidoc
+++ b/doc/help/settings.asciidoc
--- a/doc/img/cheatsheet-big.png
+++ b/doc/img/cheatsheet-big.png
--- a/doc/img/cheatsheet-small.png
+++ b/doc/img/cheatsheet-small.png
--- a/doc/img/completion.png
+++ b/doc/img/completion.png
--- a/doc/img/downloads.png
+++ b/doc/img/downloads.png
--- a/doc/img/hints.png
+++ b/doc/img/hints.png
--- a/doc/img/main.png
+++ b/doc/img/main.png
--- a/doc/install.asciidoc
+++ b/doc/install.asciidoc
@@ -1,471 +0,0 @@
-Installing qutebrowser
-======================
-
-toc::[]
-
-NOTE: qutebrowser recently had some bigger dependency changes for v1.0.0, which
-means those instructions might be out of date in some places.
-https://github.com/qutebrowser/qutebrowser/blob/master/doc/contributing.asciidoc[Please help]
-updating them if you notice something being broken!
-
-On Debian / Ubuntu
------------------
-
-How to install qutebrowser depends a lot on the version of Debian/Ubuntu you're
-running.
-
-Debian Jessie / Ubuntu 14.04 LTS / Linux Mint < 18
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Those distributions only have Python 3.4 and a too old Qt version available,
-while qutebrowser requires Python 3.5 and Qt 5.7.1 or newer.
-
-It should be possible to install Python 3.5 e.g. from the
-https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa[deadsnakes PPA] or via
-https://github.com/pyenv/pyenv[pyenv], but nobody tried that yet.
-
-If you get qutebrowser running on those distributions, please
-https://github.com/qutebrowser/qutebrowser/blob/master/doc/contributing.asciidoc[contribute]
-to update this documentation!
-
-Ubuntu 16.04 LTS / Linux Mint 18
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Ubuntu 16.04 doesn't come with an up-to-date engine (a new enough QtWebKit, or
-QtWebEngine). However, it comes with Python 3.5, so you can
-<<tox,install qutebrowser via tox>>.
-
-You'll need some basic libraries to use the tox-installed PyQt:
-
----
-# apt install libglib2.0-0 libgl1 libfontconfig1 libx11-xcb1 libxi6 libxrender1 libdbus-1-3
----
-
-Debian Stretch / Ubuntu 17.04 and 17.10
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Those versions come with QtWebEngine in the repositories. This makes it possible
-to install qutebrowser via the Debian package.
-
-You'll need to download three packages:
-
- https://packages.debian.org/sid/all/python3-pypeg2/download[PyPEG2] (a library
-  used by qutebrowser which is not in the earlier repositories)
- https://packages.debian.org/sid/all/qutebrowser/download[qutebrowser] itself
- Either https://packages.debian.org/sid/all/qutebrowser-qtwebengine/download[qutebrowser-qtwebengine]
-  or https://packages.debian.org/sid/all/qutebrowser-qtwebkit/download[qutebrowser-qtwebkit]
-  (or both) depending on the backend you want to use. QtWebEngine is the
-  default/recommended choice.
-
-After downloading, install the packages (make sure to install all the
-downloaded qutebrowser deb files in one apt command):
-
----
-# apt install ./python3-pypeg2_*_all.deb
-# apt install ./qutebrowser*.deb
----
-
-For an update after the initial install, you only need to download/install the
-qutebrowser package.
-
-Debian Testing / Ubuntu 18.04
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-On Debian Testing, qutebrowser is in the official repositories, and you can
-install it with apt:
-
----
-# apt install qutebrowser
----
-
-Additional hints
-~~~~~~~~~~~~~~~~
-
- Alternatively, you can <<tox,install qutebrowser via tox>> to get a newer
-  QtWebEngine version.
- If running from git, run the following to generate the documentation for the
-  `:help` command:
-+
----
-# apt install --no-install-recommends asciidoc source-highlight
-$ python3 scripts/asciidoc2html.py
----
-
- If you prefer using QtWebKit, there's an up-to-date version available in
-  https://packages.debian.org/buster/libqt5webkit5[Debian Testing].
- If video or sound don't work with QtWebKit, try installing the gstreamer plugins:
-+
----
-# apt install gstreamer1.0-plugins-{bad,base,good,ugly}
----
-
-On Fedora
---------
-
-NOTE: Fedora's packages used to be outdated for a long time, but are
-now (November 2017) maintained and up-to-date again.
-
-qutebrowser is available in the official repositories:
-
-----
-# dnf install qutebrowser
-----
-
-However, note that Fedora 25/26 won't be updated to qutebrowser v1.0, so you
-might want to <<tox,install qutebrowser via tox>> instead there.
-
-Additional hints
-~~~~~~~~~~~~~~~~
-
-Fedora only ships free software in the repositories.
-To be able to play videos with proprietary codecs with QtWebEngine, you will
-need to install an additional package from the RPM Fusion Free repository.
-For more information see https://rpmfusion.org/Configuration.
-
-----
-# dnf install qt5-qtwebengine-freeworld
-----
-
-On Archlinux
------------
-
-qutebrowser is available in the official [community] repository.
-
----
-# pacman -S qutebrowser
----
-
-There is also a -git version available in the AUR:
-https://aur.archlinux.org/packages/qutebrowser-git/[qutebrowser-git].
-
-You can install it using `makepkg` like this:
-
----
-$ git clone https://aur.archlinux.org/qutebrowser-git.git
-$ cd qutebrowser-git
-$ makepkg -si
-$ cd ..
-$ rm -r qutebrowser-git
----
-
-or you could use an AUR helper, e.g. `yaourt -S qutebrowser-git`.
-
-If video or sound don't work with QtWebKit, try installing the gstreamer plugins:
-
----
-# pacman -S gst-plugins-{base,good,bad,ugly} gst-libav
----
-
-On Gentoo
---------
-
-NOTE: Gentoo's packages used to be severely outdated for a long time, but are
-now (October 2017) maintained and up-to-date again.
-
-qutebrowser is available in the main repository and can be installed with:
-
----
-# emerge -av qutebrowser
----
-
-To use QtWebKit instead of QtWebEngine, you'll need a newer QtWebKit using
-https://gist.github.com/annulen/309569fb61e5d64a703c055c1e726f71[this ebuild].
-
-If video or sound don't work with QtWebKit, try installing the gstreamer
-plugins:
-
----
-# emerge -av gst-plugins-{base,good,bad,ugly,libav}
----
-
-To be able to play videos with proprietary codecs with QtWebEngine, you will
-need to turn off the `bindist` flag for `dev-qt/qtwebengine`.
-
-See the https://wiki.gentoo.org/wiki/Qutebrowser#USE_flags[Gentoo Wiki] for
-more information.
-
-On Void Linux
-------------
-
-qutebrowser is available in the official repositories and can be installed
-with:
-
----
-# xbps-install qutebrowser
----
-
-It's currently recommended to install `python3-PyQt5-webengine` and
-`python3-PyQt5-opengl`, then start with `--backend webengine` to use the new
-backend.
-
-Since the v1.0 release, qutebrowser uses QtWebEngine by default.
-
-On NixOS
--------
-
-Nixpkgs collection contains `pkgs.qutebrowser` since June 2015. You can install
-it with:
-
----
-$ nix-env -i qutebrowser
----
-
-It's recommended to install `qt5.qtwebengine` and start with
-`--backend webengine` to use the new backend.
-
-Since the v1.0 release, qutebrowser uses QtWebEngine by default.
-
-On openSUSE
-----------
-
-There are prebuilt RPMs available at https://software.opensuse.org/download.html?project=network&package=qutebrowser[OBS].
-
-To use the QtWebEngine backend, install `libqt5-qtwebengine`.
-
-On OpenBSD
----------
-
-WARNING: OpenBSD only packages a legacy unmaintained version of QtWebKit (for
-which support was dropped in qutebrowser v1.0). It's advised to not use
-qutebrowser from OpenBSD ports for untrusted websites.
-
-qutebrowser is in http://cvsweb.openbsd.org/cgi-bin/cvsweb/ports/www/qutebrowser/[OpenBSD ports].
-
-Install the package:
-
----
-# pkg_add qutebrowser
----
-
-Or alternatively, use the ports system :
-
----
-# cd /usr/ports/www/qutebrowser
-# make install
----
-
-On FreeBSD
----------
-
-qutebrowser is in https://www.freshports.org/www/qutebrowser/[FreeBSD ports].
-
-It can be installed with:
-
----
-# cd /usr/ports/www/qutebrowser
-# make install clean
----
-
-At present, precompiled packages are not available for this port,
-and QtWebEngine backend is also not available.
-
-On Windows
----------
-
-There are different ways to install qutebrowser on Windows:
-
-Prebuilt binaries
-~~~~~~~~~~~~~~~~~
-
-Prebuilt standalone packages and installers
-https://github.com/qutebrowser/qutebrowser/releases[are built] for every
-release.
-
-Note that you'll need to upgrade to new versions manually (subscribe to the
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser-announce[qutebrowser-announce
-mailinglist] to get notified on new releases). You can install a newer version
-without uninstalling the older one.
-
-The binary release ships with a QtWebEngine built without proprietary codec
-support. To get support for e.g. h264/h265 videos, you'll need to build
-QtWebEngine from source yourself with support for that enabled.
-
-https://chocolatey.org/packages/qutebrowser[Chocolatey package]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* PackageManagement PowerShell module
----
-PS C:\> Install-Package qutebrowser
----
-* Chocolatey's client
----
-C:\> choco install qutebrowser
----
-* Scoop's client
----
-C:\> scoop bucket add extras
-C:\> scoop install qutebrowser
----
-
-Manual install
-~~~~~~~~~~~~~~
-
-* Use the installer from http://www.python.org/downloads[python.org] to get
-Python 3 (be sure to install pip).
-* Install https://testrun.org/tox/latest/index.html[tox] via
-https://pip.pypa.io/en/latest/[pip]:
-
----
-$ pip install tox
----
-
-Then <<tox,install qutebrowser via tox>>.
-
-On macOS
--------
-
-Prebuilt binary
-~~~~~~~~~~~~~~~
-
-The easiest way to install qutebrowser on macOS is to use the prebuilt `.app`
-files from the
-https://github.com/qutebrowser/qutebrowser/releases[release page].
-
-Note that you'll need to upgrade to new versions manually (subscribe to the
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser-announce[qutebrowser-announce
-mailinglist] to get notified on new releases).
-
-The binary release ships with a QtWebEngine built without proprietary codec
-support. To get support for e.g. h264/h265 videos, you'll need to build
-QtWebEngine from source yourself with support for that enabled.
-
-This binary is also available through the
-https://caskroom.github.io/[Homebrew Cask] package manager:
-
----
-$ brew cask install qutebrowser
----
-
-Manual Install
-~~~~~~~~~~~~~~
-
-Alternatively, you can install the dependencies via a package manager (like
-http://brew.sh/[Homebrew] or https://www.macports.org/[MacPorts]) and run
-qutebrowser from source.
-
-==== Homebrew
-
----
-$ brew install qt5
-$ pip3 install qutebrowser
----
-
-Since the v1.0 release, qutebrowser uses QtWebEngine by default.
-
-Homebrew's builds of Qt and PyQt don't come with QtWebKit (and `--with-qtwebkit`
-uses an old version of QtWebKit which qutebrowser doesn't support anymore). If
-you want QtWebKit support, you'll need to build an up-to-date QtWebKit
-https://github.com/annulen/webkit/wiki/Building-QtWebKit-on-OS-X[manually].
-
-Packagers
---------
-
-There are example .desktop and icon files provided. They would go in the
-standard location for your distro (`/usr/share/applications` and
-`/usr/share/pixmaps` for example).
-
-The normal `setup.py install` doesn't install these files, so you'll have to do
-it as part of the packaging process.
-
-[[tox]]
-Installing qutebrowser with tox
-------------------------------
-
-Getting the repository
-~~~~~~~~~~~~~~~~~~~~~~
-
-First of all, clone the repository using http://git-scm.org/[git] and switch
-into the repository folder:
-
----
-$ git clone https://github.com/qutebrowser/qutebrowser.git
-$ cd qutebrowser
----
-
-Installing dependencies (including Qt)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Then run tox inside the qutebrowser repository to set up a
-https://docs.python.org/3/library/venv.html[virtual environment]:
-
----
-$ tox -e mkvenv-pypi
----
-
-If your system comes with Python 3.5.3 or older (such as Ubuntu 16.04 LTS), use
-`tox -e mkvenv-pypi-old` instead. This installs an older Qt version (5.10) due
-to bugs in newer versions.
-
-This installs all needed Python dependencies in a `.venv` subfolder.
-
-This comes with an up-to-date Qt/PyQt including QtWebEngine, but has a few
-caveats:
-
- Make sure your `python3` is Python 3.5 or newer, otherwise you'll get a "No
-  matching distribution found" error. Note that qutebrowser itself also requires
-  this.
- It only works on 64-bit x86 systems, with other architectures you'll get the
-  same error.
- If your distribution uses OpenSSL 1.1 (like Debian Stretch or Archlinux),
-  you'll need to set `LD_LIBRARY_PATH` to the OpenSSL 1.0 directory
-  (`export LD_LIBRARY_PATH=/usr/lib/openssl-1.0` on Archlinux) before starting
-  qutebrowser if you want SSL to work in certain downloads (e.g. for
-  `:adblock-update` or `:download`).
- It comes with a QtWebEngine compiled without proprietary codec support (such
-  as h.264).
-
-See the next section for an alternative.
-
-Installing dependencies (system-wide Qt)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Alternatively, you can use `tox -e mkvenv` (without `-pypi`) to symlink your
-local Qt install instead of installing PyQt in the virtualenv. However, unless
-you have a new QtWebKit or QtWebEngine available, qutebrowser will not work. It
-also typically means you'll be using an older release of QtWebEngine.
-
-On Windows, run `set PYTHON=C:\path\to\python.exe` (CMD) or ``$Env:PYTHON =
-"..."` (Powershell) first.
-
-Creating a wrapper script
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Running `tox` does not install a system-wide `qutebrowser` script. You can
-launch qutebrowser by doing:
-
----
-.venv/bin/python3 -m qutebrowser
----
-
-You can create a simple wrapper script to start qutebrowser somewhere in your
-`$PATH` (e.g. `/usr/local/bin/qutebrowser` or `~/bin/qutebrowser`):
-
----
-#!/bin/bash
-~/path/to/qutebrowser/.venv/bin/python3 -m qutebrowser "$@"
----
-
-Building the docs
-~~~~~~~~~~~~~~~~~
-
-To build the documentation, install `asciidoc` (note that LaTeX which comes as
-optional/recommended dependency with some distributions is not required).
-
-Then, run:
-
----
-$ python3 scripts/asciidoc2html.py
----
-
-Updating
-~~~~~~~~
-
-When you updated your local copy of the code (e.g. by pulling the git repo, or
-extracting a new version), the virtualenv should automatically use the updated
-code. However, if dependencies got added, this won't be reflected in the
-virtualenv. Thus it's recommended to run the following command to recreate the
-virtualenv:
-
----
-$ tox -r -e mkvenv-pypi
----
--- a/doc/notes
+++ b/doc/notes
@@ -0,0 +1,82 @@
+henk's thoughts
+===============
+
+1. Power to the user! Protect privacy!
+Things the browser should only do with explicit consent from the user, if
+applicable the user should be able to choose which protocol/host/port triplets
+to white/blacklist:
+
+- load/run executable code, like js, flash, java applets, ... (think NoScript)
+- requests to other domains, ports or using a different protocol than what the
+  user requested (think RequestPolicy)
+- accept cookies
+- storing/saving/caching things, e.g. open tabs ("session"), cookies, page
+  contents, browsing/download history, form data, ...
+- send referrer
+- disclose any (presence, type, version, settings, capabilities, etc.)
+  information about OS, browser, installed fonts, plugins, addons, etc.
+
+2. Be efficient!
+I tend to leave a lot of tabs open and nobody can deny that some websites
+simply suck, so the browser should, unless told otherwise by the user:
+
+- load tabs only when needed
+- run code in tabs only when needed, i.e. when the tab is currently being
+  used/viewed (background tabs doing some JS magic even when they are not being
+  used can create a lot of unnecessary load on the machine)
+- finish requests to the domain the user requested (e.g. www.example.org)
+  before doing any requests to other subdomains (e.g. images.example.org) and
+  finish those before doing requests to thirdparty domains (e.g. example.com)
+
+3. Be stable!
+- one site should not make the complete browser crash, only that site's tab
+
+
+Upstream Bugs
+=============
+
+- Web inspector is blank unless .hide()/.show() is called.
+    Asked on SO: http://stackoverflow.com/q/23499159/2085149
+    TODO: Report to PyQt/Qt
+
+- Report some other crashes
+
+
+/u/angelic_sedition's thoughts
+==============================
+
+Well support for greasemonkey scripts and bookmarklets/js (which was mentioned
+in the arch forum post) would be a big addition. What I've usually missed when
+using other vim-like browsers is things that allow for different settings and
+key bindings for different contexts. With that implemented I think I could
+switch to a lightweight browser (and believe me, I'd like to) for the most part
+and only use firefox when I needed downthemall or something.
+
+For example, I have different bindings based on tab position that are reloaded
+with a pentadactyl autocmd so that <space><homerow keys> will take me to tab
+1-10 if I'm in that range or 2-20 if I'm in that range. I have an autocmd that
+will run on completed downloads that passes the file path to a script that will
+open ranger in a floating window with that file cut (this is basically like
+using ranger to save files instead of the crappy gui popup).
+
+I also have a few bindings based on tabgroups. Tabgroups are a firefox feature,
+but I find them very useful for sorting things by topic so that only the tabs
+I'm interested at the moment are visible.
+
+Pentadactyl has a feature it calls groups. You can create a group that will
+activate for sites/urls that match a pattern with some regex support. This
+allows me, for example, to set up different (more convenient) bindings for
+zooming only on images. I'll never need use the equivalent of vim n (next text
+search match), so I can bind that to zoom. This allows setting up custom
+quickmarks/gotos using the same keys for different websites. For example, on
+reddit I have different g(some key) bindings to go to different subreddits.
+This can also be used to pass certain keys directly to the site (e.g. for use
+with RES). For sites that don't have modifiable bindings, I can use this with
+pentadactyl's feedkeys or xdotool to create my own custom bindings. I even have
+a binding that will call out to bash script with different arguments depending
+on the site to download an image or an image gallery depending on the site (in
+some cases passing the url to some cli program).
+
+I've also noticed the lack of completion. For example, on "o" pentadactyl will
+show sites (e.g. from history) that can be completed. I think I've been spoiled
+by pentadactyl having completion for just about everything.
--- a/doc/quickstart.asciidoc
+++ b/doc/quickstart.asciidoc
@@ -5,36 +5,18 @@ The Compiler <mail@qutebrowser.org>
 NOTE: This page will only appear on the first start. To view it at a later
 time, use the `:help` command.

-Basic keybindings to get you started
------------------------------------
-
-* Use the arrow keys or `hjkl` to move around a webpage (vim-like syntax is used in quite a few places)
-* To go to a new webpage, press `o`, then type a url, then press Enter (Use `O` to open the url in a new tab, `go` to edit the current URL)
-* If what you've typed isn't a url, then a search engine will be used instead (DuckDuckGo, by default)
-* To switch between tabs, use `J` (next tab) and `K` (previous tab), or press `<Alt-num>`, where `num` is the position of the tab to switch to
-* To close the current tab, press `d` (and press `u` to undo closing a tab)
-* Use `H` and `L` to go back and forth in the history
-* To click on something without using the mouse, press `f` to show the hints, then type the keys next to what you want to click on (if that sounds weird, then just try pressing `f` and see what happens)
-* Press `:` to show the commandline
-* To search in a page, press `/`, type the phrase to search for, then press Enter. Use `n` and `N` to go back and forth through the matches, and press Esc to stop doing the search.
-* To close qutebrowser, press `Alt-F4`, or `:q`, or `:wq` to save the currently open tabs and quit (note that in the settings you can make qutebrowser always save the currently open tabs)
-
 What to do now
 --------------

-* View the link:https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-big.png[key binding cheatsheet]
-to make yourself familiar with the key bindings: +
-image:https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-small.png["qutebrowser key binding cheatsheet",link="https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/cheatsheet-big.png"]
-* There's also a https://www.shortcutfoo.com/app/dojos/qutebrowser[free training
-  course] on shortcutfoo for the keybindings - note that you need to be in
-  insert mode (i) for it to work.
-* Run `:adblock-update` to download adblock lists and activate adblocking.
+* View the http://qutebrowser.org/img/cheatsheet-big.png[keybinding cheatsheet]
+to make yourself familiar with the keybindings: +
+image:http://qutebrowser.org/img/cheatsheet-small.png["qutebrowser keybinding cheatsheet",link="http://qutebrowser.org/img/cheatsheet-big.png"]
 * If you just cloned the repository, you'll need to run
 `scripts/asciidoc2html.py` to generate the documentation.
 * Go to the link:qute://settings[settings page] to set up qutebrowser the way you want it.
 * Subscribe to
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[the mailinglist] or
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser-announce[the announce-only mailinglist].
+https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[the mailinglist]
+where there are weekly "what's new in qutebrowser" posts.
 * Let me know what features you are missing or things that need (even small!)
 improvements.

--- a/doc/qutebrowser.1.asciidoc
+++ b/doc/qutebrowser.1.asciidoc
@@ -7,24 +7,20 @@
 :man source: qutebrowser
 :man manual: qutebrowser manpage
 :toc:
-:homepage: https://www.qutebrowser.org/
+:homepage: http://www.qutebrowser.org/

 == NAME
-qutebrowser - a keyboard-driven, vim-like browser based on PyQt5.
+qutebrowser - a keyboard-driven, vim-like browser based on PyQt5 and QtWebKit.

 == SYNOPSIS
 *qutebrowser* ['-OPTION' ['...']] [':COMMAND' ['...']] ['URL' ['...']]

 == DESCRIPTION
-qutebrowser is a keyboard-focused browser with a minimal GUI. It's based
-on Python and Qt5 and is free software, licensed under the GPL.
+qutebrowser is a keyboard-focused browser with with a minimal GUI. It's based
+on Python, PyQt5 and QtWebKit and free software, licensed under the GPL.

 It was inspired by other browsers/addons like dwb and Vimperator/Pentadactyl.

-Note the commands and settings of qutebrowser are not described in this
-manpage, but in the help integrated in qutebrowser - use the ":help" command to
-show it.
-
 == OPTIONS
 // QUTE_OPTIONS_START
 === positional arguments
@@ -38,32 +34,14 @@ show it.
 *-h*, *--help*::
    show this help message and exit

-*-B* 'BASEDIR', *--basedir* 'BASEDIR'::
-    Base directory for all storage.
+*-c* 'CONFDIR', *--confdir* 'CONFDIR'::
+    Set config directory (empty for no config storage)

 *-V*, *--version*::
    Show version and quit.

-*-s* 'OPTION' 'VALUE', *--set* 'OPTION' 'VALUE'::
-    Set a temporary setting for this session.
-
-*-r* 'SESSION', *--restore* 'SESSION'::
-    Restore a named session.
-
-*-R*, *--override-restore*::
-    Don't restore a session even if one would be restored.
-
-*--target* '{auto,tab,tab-bg,tab-silent,tab-bg-silent,window}'::
-    How URLs should be opened if there is already a qutebrowser instance running.
-
-*--backend* '{webkit,webengine}'::
-    Which backend to use.
-
-*--enable-webengine-inspector*::
-    Enable the web inspector for QtWebEngine. Note that this is a SECURITY RISK and you should not visit untrusted websites with the inspector turned on. See https://bugreports.qt.io/browse/QTBUG-50725 for more details. This is not needed anymore since Qt 5.11 where the inspector is always enabled and secure.
-
 === debug arguments
-*-l* '{critical,error,warning,info,debug,vdebug}', *--loglevel* '{critical,error,warning,info,debug,vdebug}'::
+*-l* 'LOGLEVEL', *--loglevel* 'LOGLEVEL'::
    Set loglevel

 *--logfilter* 'LOGFILTER'::
@@ -72,53 +50,50 @@ show it.
 *--loglines* 'LOGLINES'::
    How many lines of the debug log to keep in RAM (-1: unlimited).

-*-d*, *--debug*::
+*--debug*::
    Turn on debugging options.

-*--json-logging*::
-    Output log lines in JSON format (one object per line).
-
 *--nocolor*::
    Turn off colored logging.

-*--force-color*::
-    Force colored logging
+*--harfbuzz* '{old,new,system,auto}'::
+    HarfBuzz engine version to use. Default: auto.

 *--nowindow*::
    Don't show the main window.

-*-T*, *--temp-basedir*::
-    Use a temporary basedir.
+*--debug-exit*::
+    Turn on debugging of late exit.

-*--no-err-windows*::
-    Don't show any error windows (used for tests/smoke.py).
+*--no-crash-dialog*::
+    Don't show a crash dialog.

-*--qt-arg* 'NAME' 'VALUE'::
-    Pass an argument with a value to Qt. For example, you can do `--qt-arg geometry 650x555+200+300` to set the window geometry.
+*--qt-style* 'STYLE'::
+    Set the Qt GUI style to use.

-*--qt-flag* 'QT_FLAG'::
-    Pass an argument to Qt as flag.
+*--qt-stylesheet* 'STYLESHEET'::
+    Override the Qt application stylesheet.

-*-D* 'DEBUG_FLAGS', *--debug-flag* 'DEBUG_FLAGS'::
-    Pass name of debugging feature to be turned on.
+*--qt-widgetcount*::
+    Print debug message at the end about number of widgets left undestroyed and maximum number of widgets existed at the same time.
+
+*--qt-reverse*::
+    Set the application's layout direction to right-to-left.
+
+*--qt-qmljsdebugger* 'port:PORT[,block]'::
+    Activate the QML/JS debugger with a specified port. 'block' is optional and will make the application wait until a debugger connects to it.
 // QUTE_OPTIONS_END

 == FILES

- '~/.config/qutebrowser/config.py': Configuration file.
- '~/.config/qutebrowser/autoconfig.yml': Configuration done via the GUI.
+- '~/.config/qutebrowser/qutebrowser.conf': Main config file.
 - '~/.config/qutebrowser/quickmarks': Saved quickmarks.
- '~/.local/share/qutebrowser/': Various state information.
- '~/.cache/qutebrowser/': Temporary data.
-
-Note qutebrowser conforms to the XDG basedir specification - if
-'XDG_CONFIG_HOME', 'XDG_DATA_HOME' or 'XDG_CACHE_HOME' are set in the
-environment, the directories configured there are used instead of the above
-defaults.
+- '~/.config/qutebrowser/keys.conf': Defined keybindings.
+- '~/.local/share/qutebrowser/': Various state information

 == BUGS
 Bugs are tracked in the Github issue tracker at 
-https://github.com/qutebrowser/qutebrowser/issues.
+https://github.com/The-Compiler/qutebrowser/issues.

 If you found a bug, use the built-in ':report' command to create a bug report
 with all information needed.
@@ -128,7 +103,7 @@ https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser[mailinglist] at
 mailto:qutebrowser@lists.qutebrowser.org[] instead.

 For security bugs, please contact me directly at me@the-compiler.org, GPG ID
-https://www.the-compiler.org/pubkey.asc[0xFD55A072].
+http://www.the-compiler.org/pubkey.asc[0xFD55A072].

 == COPYRIGHT
 This program is free software: you can redistribute it and/or modify it under
@@ -144,14 +119,12 @@ You should have received a copy of the GNU General Public License along with
 this program.  If not, see <http://www.gnu.org/licenses/>.

 == RESOURCES
-* Website: https://www.qutebrowser.org/
+* Website: http://www.qutebrowser.org/
 * Mailinglist: mailto:qutebrowser@lists.qutebrowser.org[] /
 https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser
-* Announce-only mailinglist: mailto:qutebrowser-announce@lists.qutebrowser.org[] /
-https://lists.schokokeks.org/mailman/listinfo.cgi/qutebrowser-announce
 * IRC: irc://irc.freenode.org/#qutebrowser[`#qutebrowser`] on
 http://freenode.net/[Freenode]
-* Github: https://github.com/qutebrowser/qutebrowser
+* Github: https://github.com/The-Compiler/qutebrowser

 == AUTHOR
 *qutebrowser* was written by Florian Bruhin. All contributors can be found in
--- a/doc/stacktrace.asciidoc
+++ b/doc/stacktrace.asciidoc
@@ -1,6 +1,5 @@
 Getting stacktraces on crashes
 ==============================
-:toc:
 The Compiler <mail@qutebrowser.org>

 When there is a fatal crash in qutebrowser - most of the times a
@@ -15,17 +14,10 @@ https://en.wikipedia.org/wiki/Debug_symbol[debugging symbols] is required.
 The rest of this guide is quite Linux specific, though there is a
 <<windows,section for Windows>> at the end.

-Crashes which can be reproduced
-------------------------------
-
-If a crash can be reproduced, packages with debugging symbols should be
-installed, and the crash should be reproduced under gdb.
-
 Getting debugging symbols
-~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------

-Debian/Ubuntu/...
-^^^^^^^^^^^^^^^^^
+.Debian/Ubuntu/...

 For Debian based systems (Debian, Ubuntu, Linux Mint, ...), debug information
 is available in the repositories:
@@ -34,71 +26,76 @@ is available in the repositories:
 # apt-get install python3-pyqt5-dbg python3-pyqt5.qtwebkit-dbg python3-dbg libqt5webkit5-dbg
 ----

-Archlinux
-^^^^^^^^^
+.Archlinux

-For Archlinux, no debug information is provided. You can either compile Qt
+For Archlinux, no debug informations are provided. You can either compile Qt
 yourself (which will take a few hours even on a modern machine) or use
-debugging symbols compiled/packaged by me (x86_64 only).
+debugging symbols compiled by me (x86_64 only).

-To install my pre-built packages
-++++++++++++++++++++++++++++++++
-
-First download and sign the key:
+To compile by yourself:

 ----
-# pacman-key -r 0xD6A1C70FE80A0C82
-$ pacman-key -f 0xD6A1C70FE80A0C82
-  Key fingerprint = 14AF EC28 70C6 4863 C5C7  ACCB D6A1 C70F E80A 0C82
-# pacman-key --lsign-key 0xD6A1C70FE80A0C82
----
-
-Then edit your `/etc/pacman.conf` to add the repository to the bottom:
-
----
-[qt-debug]
-Server = https://qutebrowser.org/qt-debug/$arch
----
-
-Then install the packages:
-
----
-# pacman -Suy pyqt5-common-debug python-pyqt5-debug qt5-base-debug qt5-webkit-debug qt5-webengine-debug
----
-
-The `-debug` packages conflict with the non-debug variants - it's safe to
-remove them.
-
-To compile by yourself
-++++++++++++++++++++++
-
-Note that building Qt will likely take multiple hours, even on a recent system.
-I'd also expect it to take around 6 GB of RAM and 30 GB of disk space for a
-successful compile run.
-
----
-$ git clone https://github.com/qutebrowser/qt-debug-pkgbuild.git
+$ git clone https://github.com/The-Compiler/qt-debug-pkgbuild.git
 $ cd qt-debug-pkgbuild
-$ export DEBUG_CFLAGS='-ggdb3 -fvar-tracking-assignments -Og'
-$ export DEBUG_CXXFLAGS='-ggdb3 -fvar-tracking-assignments -Og'
+$ git checkout symbols
 $ cd qt5
-$ makepkg -si --pkg qt5-base-debug,qt5-webkit-debug,qt5-webengine-debug
+$ makepkg -si
 $ cd ../pyqt5
-$ makepkg -si --pkg pyqt5-common-debug,python-pyqt5-debug
+$ makepkg -si
 ----

-Getting the stack trace
-~~~~~~~~~~~~~~~~~~~~~~~
-
-First install `gdb` on your system if it's not installed already.
-
-Then run qutebrowser directly inside gdb like this:
+To install my pre-built packages:

 ----
-$ gdb $(readlink -f $(which python3)) -ex 'run -m qutebrowser --debug'
+$ mkdir qt-debug
+$ cd qt-debug
+$ wget -r -l1 -A '*.tar.xz' -L -np -nd http://www.qutebrowser.org/qt-symbols-pkg/
+# pacman -U *.pkg.tar.xz
 ----

-After you reproduce the crash, you should now see something like:
+After you are done debugging, make sure to install the system packages again so
+you get updates. This can be done with this command:
+
+----
+# pacman -S qt5
+----
+
+Getting a core dump
+-------------------
+
+The next step is finding the core dump so we can get a stacktrace from it.
+
+First of all, try to reproduce your problem. If you can, run qutebrowser
+directly inside gdb like this:
+
+----
+$ gdb $(which python3) -ex 'run -m qutebrowser --debug'
+----
+
+If you cannot reproduce the problem, you need to check if a coredump got
+written somewhere.
+
+Check the file `/proc/sys/kernel/core_pattern` on your system. If it does not
+start with a `|` character (pipe), check if there is a file named `core` or
+`core.NNNN` in the directory from that file, or in the current directory.
+
+If so, execute gdb like this:
+
+----
+$ gdb $(which python3) /path/to/core
+----
+
+If your `/proc/sys/kernel/core_pattern` contains something like
+`|/usr/lib/systemd/systemd-coredump`, use `coredumpctl` as root to run gdb:
+
+----
+# coredumpctl gdb $(which python3)
+----
+
+Getting a stack trace
+---------------------
+
+Regardless of the way you used to open gdb, you should now see something like:

 ----
 Program received signal SIGSEGV, Segmentation fault.
@@ -110,58 +107,16 @@ Now enter these commands at the gdb prompt:

 ----
 (gdb) set logging on
-(gdb) bt full
-# you might have to press enter a few times until you get the prompt back
-(gdb) quit
----
-
-This will create a `gdb.txt` in your current directory.
-
-Copy the last few lines of the debug log (before you got the gdb prompt) and
-the full content of `gdb.txt` into the bug report. Please also add some words
-about what you were doing (or what pages you visited) before the crash
-happened.
-
-Crashes which can NOT be reproduced
-----------------------------------
-
-If you cannot reproduce the problem, you need to check if a coredump got
-written somewhere. You should not install debug symbols as they won't match the
-generated coredump.
-
-First install `gdb` on your system if it's not installed already.
-
-Then check the file `/proc/sys/kernel/core_pattern` on your system. If it does
-not start with a `|` character (pipe), check if there is a file named `core` or
-`core.NNNN` in the directory from that file, or in the current directory.
-
-If so, execute gdb like this:
-
----
-$ gdb $(readlink -f $(which python3)) /path/to/core
----
-
-If your `/proc/sys/kernel/core_pattern` contains something like
-`|/usr/lib/systemd/systemd-coredump`, use `coredumpctl` to run gdb:
-
----
-$ coredumpctl gdb $(readlink -f $(which python3))
----
-
-Getting the stack trace
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Now enter these commands at the gdb prompt:
-
----
-(gdb) set logging on
+(gdb) set logging redirect on
 (gdb) bt
 # you might have to press enter a few times until you get the prompt back
+(gdb) set logging redirect off
 (gdb) quit
 ----

-Copy the content of `gdb.txt` into the bug report. Please also add some words
-about what you were doing (or what pages you visited) before the crash
+Now copy the last few lines of the debug log (before you got the gdb prompt)
+and the full content of `gdb.txt` into the bug report. Please also add some
+words about what you were doing (or what pages you visited) before the crash
 happened.

 [[windows]]
@@ -174,10 +129,10 @@ When you see the _qutebrowser.exe has stopped working_ window, do not click
 file displayed there.

 Now install
-https://www.microsoft.com/en-us/download/details.aspx?id=49924[DebugDiag] from
-Microsoft, then run the *DebugDiag 2 Analysis* tool. There, check
-*CrashHangAnalysis* and add your crash dump via *Add Data files*. Then click
-*Start analysis*.
+http://www.microsoft.com/en-us/download/details.aspx?id=42933[DebugDiag] from
+Microsoft, then run the "DebugDiag 2 Analysis" tool. There, check
+"CrashHangAnalysis" and add your crash dump via "Add Data files". Then click
+"Start analysis".

 Close the Internet Explorer which opens when it's done and use the
 folder-button at the top left to get to the reports. There find the report file
--- a/doc/userscripts.asciidoc
+++ b/doc/userscripts.asciidoc
@@ -1,86 +0,0 @@
-Writing qutebrowser userscripts
-===============================
-The Compiler <mail@qutebrowser.org>
-
-qutebrowser is extensible by writing userscripts which can be called via the
-`:spawn --userscript` command, or via a key binding.
-
-You can also call a userscript via hints so they get the selected hint URL by
-calling `:hint links userscript ...`.
-
-These userscripts are similar to the (non-javascript) dwb userscripts. They can
-be written in any language which can read environment variables and write to a
-FIFO. Note they are *not* related to Greasemonkey userscripts.
-
-Note for simple things such as opening the current page with another browser or
-mpv, a simple key binding to something like `:spawn mpv {url}` should suffice.
-
-Also note userscripts need to have the executable bit set (`chmod +x`) for
-qutebrowser to run them.
-
-To call a userscript, it needs to be stored in your data directory under
-`userscripts` (for example: `~/.local/share/qutebrowser/userscripts/myscript`), 
-or just use an absolute path.
-
-NOTE: On Windows, only userscripts with `com`, `bat`, or `exe` extensions will be launched.
-
-Getting information
-------------------
-
-The following environment variables will be set when a userscript is launched:
-
- `QUTE_MODE`: Either `hints` (started via hints) or `command` (started via
-  command or key binding).
- `QUTE_USER_AGENT`: The currently set user agent, if customized.
- `QUTE_FIFO`: The FIFO or file to write commands to.
- `QUTE_HTML`: Path of a file containing the HTML source of the current page.
- `QUTE_TEXT`: Path of a file containing the plaintext of the current page.
- `QUTE_CONFIG_DIR`: Path of the directory containing qutebrowser's configuration.
- `QUTE_DATA_DIR`: Path of the directory containing qutebrowser's data.
- `QUTE_DOWNLOAD_DIR`: Path of the downloads directory.
- `QUTE_COMMANDLINE_TEXT`: Text currently in qutebrowser's command line.
-
-In `command` mode:
-
- `QUTE_URL`: The current URL.
- `QUTE_TITLE`: The title of the current page.
- `QUTE_SELECTED_TEXT`: The text currently selected on the page.
-
-In `hints` mode:
-
- `QUTE_URL`: The URL selected via hints.
- `QUTE_SELECTED_TEXT`: The plain text of the element selected via hints.
- `QUTE_SELECTED_HTML` The HTML of the element selected via hints.
-
-Sending commands
----------------
-
-Normal qutebrowser commands can be written to `$QUTE_FIFO` and will be
-executed.
-
-On Unix/macOS, this is a named pipe and commands written to it will get executed
-immediately.
-
-On Windows, this is a regular file, and the commands in it will be executed as
-soon as your userscript terminates. This means when writing multiple commands,
-you should append to the file (`>>` in bash) rather than overwrite it (`>`).
-
-Examples
--------
-
-Opening the currently selected word on http://www.dict.cc/[dict.cc]:
-
-[source,bash]
----
-#!/bin/bash
-
-echo "open -t http://www.dict.cc/?s=$QUTE_SELECTED_TEXT" >> "$QUTE_FIFO"
----
-
-Libraries
---------
-
-Some third-party libraries are available to make writing userscripts easier:
-
- Python: https://github.com/hiway/python-qutescript[python-qutescript]
- Node.js: https://www.npmjs.com/package/qutejs[qutejs]
--- a/icons/qutebrowser-128x128.png
+++ b/icons/qutebrowser-128x128.png
--- a/icons/qutebrowser-16x16.png
+++ b/icons/qutebrowser-16x16.png
--- a/icons/qutebrowser-24x24.png
+++ b/icons/qutebrowser-24x24.png
--- a/icons/qutebrowser-256x256.png
+++ b/icons/qutebrowser-256x256.png
--- a/icons/qutebrowser-32x32.png
+++ b/icons/qutebrowser-32x32.png
--- a/icons/qutebrowser-48x48.png
+++ b/icons/qutebrowser-48x48.png
--- a/icons/qutebrowser-512x512.png
+++ b/icons/qutebrowser-512x512.png
--- a/icons/qutebrowser-64x64.png
+++ b/icons/qutebrowser-64x64.png
--- a/icons/qutebrowser-96x96.png
+++ b/icons/qutebrowser-96x96.png
--- a/icons/qutebrowser-all.svg
+++ b/icons/qutebrowser-all.svg
--- a/icons/qutebrowser-favicon.svg
+++ b/icons/qutebrowser-favicon.svg
--- a/icons/qutebrowser.icns
+++ b/icons/qutebrowser.icns
--- a/icons/qutebrowser.ico
+++ b/icons/qutebrowser.ico
--- a/icons/qutebrowser.svg
+++ b/icons/qutebrowser.svg
--- a/icons/qutebrowser.xpm
+++ b/icons/qutebrowser.xpm
@@ -1,302 +0,0 @@
-/* XPM */
-static char * qutebrowser_xpm[] = {
-"32 32 267 2",
-"  	c None",
-". 	c #9FD4FD",
-"+ 	c #99CBFE",
-"@ 	c #90C3FE",
-"# 	c #89BFFE",
-"$ 	c #81BCFF",
-"% 	c #80BBFF",
-"& 	c #9BCAFD",
-"* 	c #A9DBFB",
-"= 	c #88D3FB",
-"- 	c #98CBFE",
-"; 	c #81BBFF",
-"> 	c #7EBAFF",
-", 	c #84BDFF",
-"' 	c #8DC2FF",
-") 	c #96C7FE",
-"! 	c #A0CCFE",
-"~ 	c #A9D1FE",
-"{ 	c #CEE5FD",
-"] 	c #C7E3FC",
-"^ 	c #8AD3FB",
-"/ 	c #9DCFFD",
-"( 	c #C3DFFD",
-"_ 	c #CDE4FD",
-": 	c #A3CEFE",
-"< 	c #94C6FE",
-"[ 	c #CAE5FC",
-"} 	c #7DD0FB",
-"| 	c #9ECDFD",
-"1 	c #A1CDFE",
-"2 	c #8BC1FF",
-"3 	c #87BFFF",
-"4 	c #ADD4FE",
-"5 	c #C6E1FD",
-"6 	c #CCE3FC",
-"7 	c #A7DAFB",
-"8 	c #9DCBFE",
-"9 	c #78AFF1",
-"0 	c #6096D4",
-"a 	c #4B82C0",
-"b 	c #5A84B3",
-"c 	c #6589B1",
-"d 	c #6F92B9",
-"e 	c #90AED0",
-"f 	c #C4DBF5",
-"g 	c #6286AE",
-"h 	c #7D9EC2",
-"i 	c #BADFFC",
-"j 	c #85BDFE",
-"k 	c #78B4F8",
-"l 	c #4C83C0",
-"m 	c #1E4F87",
-"n 	c #0A396E",
-"o 	c #345D8D",
-"p 	c #CDE4FC",
-"q 	c #88A7CA",
-"r 	c #1D497C",
-"s 	c #799BBF",
-"t 	c #8AC1FD",
-"u 	c #5E97D7",
-"v 	c #14457B",
-"w 	c #4F76A0",
-"x 	c #A9D5FC",
-"y 	c #95C9FD",
-"z 	c #4C82C1",
-"A 	c #0A3A6F",
-"B 	c #C9E3FD",
-"C 	c #95CCFC",
-"D 	c #629BDB",
-"E 	c #0B3A6F",
-"F 	c #0C3B6F",
-"G 	c #4E749F",
-"H 	c #8CACCE",
-"I 	c #6185AD",
-"J 	c #CBE4FD",
-"K 	c #89C0FF",
-"L 	c #98CDFA",
-"M 	c #27558A",
-"N 	c #144175",
-"O 	c #9BB8D8",
-"P 	c #335D8C",
-"Q 	c #AFC9E6",
-"R 	c #AFD4FE",
-"S 	c #91C7FD",
-"T 	c #A0C0DE",
-"U 	c #194779",
-"V 	c #80A1C5",
-"W 	c #C8E1F9",
-"X 	c #9CB9D8",
-"Y 	c #7799BE",
-"Z 	c #6489B0",
-"` 	c #7092B9",
-" .	c #6E9DCF",
-"..	c #79B5F9",
-"+.	c #83BDFE",
-"@.	c #7395BA",
-"#.	c #315C8B",
-"$.	c #7C9EC2",
-"%.	c #C0D9F3",
-"&.	c #7294BA",
-"*.	c #5C94D4",
-"=.	c #91CCFC",
-"-.	c #88CBFA",
-";.	c #5179A3",
-">.	c #6E91B7",
-",.	c #6084AC",
-"'.	c #96B3D4",
-").	c #275283",
-"!.	c #0C3C71",
-"~.	c #629CDC",
-"{.	c #94C6FD",
-"].	c #A7D2FC",
-"^.	c #36659A",
-"/.	c #2C5788",
-"(.	c #9DBAD9",
-"_.	c #B4CEEA",
-":.	c #476E9A",
-"<.	c #7EB9FE",
-"[.	c #8DC3FD",
-"}.	c #8CC2FE",
-"|.	c #2F619B",
-"1.	c #87A6C9",
-"2.	c #7A9BC0",
-"3.	c #CBE2FB",
-"4.	c #C7DFF8",
-"5.	c #6C8FB5",
-"6.	c #113F73",
-"7.	c #0F3D71",
-"8.	c #547AA4",
-"9.	c #9CBAD9",
-"0.	c #B9D3EE",
-"a.	c #A3C0DE",
-"b.	c #31629A",
-"c.	c #659EE0",
-"d.	c #87BFFE",
-"e.	c #C3E0FD",
-"f.	c #4371A4",
-"g.	c #7496BB",
-"h.	c #90AFD1",
-"i.	c #245081",
-"j.	c #416A96",
-"k.	c #B0CBE7",
-"l.	c #CCE4FD",
-"m.	c #7DB8FD",
-"n.	c #1E5088",
-"o.	c #497EBC",
-"p.	c #C9E3FC",
-"q.	c #7193B9",
-"r.	c #C6E0FB",
-"s.	c #A2CDFE",
-"t.	c #97C8FE",
-"u.	c #A7D0FE",
-"v.	c #BDDCFD",
-"w.	c #9EC2E8",
-"x.	c #416996",
-"y.	c #366AA6",
-"z.	c #C0DEFC",
-"A.	c #A2BFDD",
-"B.	c #326299",
-"C.	c #649DDF",
-"D.	c #71ABED",
-"E.	c #3569A4",
-"F.	c #0D3C71",
-"G.	c #6998CD",
-"H.	c #30639D",
-"I.	c #A8D3F8",
-"J.	c #2B5686",
-"K.	c #3A679B",
-"L.	c #ADCAEA",
-"M.	c #85A6C9",
-"N.	c #33639B",
-"O.	c #9CCBFD",
-"P.	c #86C2F7",
-"Q.	c #0E3C71",
-"R.	c #1B4C83",
-"S.	c #5D95D5",
-"T.	c #557BA5",
-"U.	c #85C0F6",
-"V.	c #55A8EF",
-"W.	c #94B3D3",
-"X.	c #1C497C",
-"Y.	c #13437A",
-"Z.	c #487DBB",
-"`.	c #7BB7FB",
-" +	c #76B1F5",
-".+	c #4E85C3",
-"++	c #ACD3FE",
-"@+	c #2F5989",
-"#+	c #7597BC",
-"$+	c #53A7EF",
-"%+	c #C6E1FC",
-"&+	c #B6D5F7",
-"*+	c #5890D0",
-"=+	c #4076B2",
-"-+	c #619ADB",
-";+	c #7CB7FC",
-">+	c #7DB9FE",
-",+	c #5087C6",
-"'+	c #134479",
-")+	c #23548D",
-"!+	c #24558D",
-"~+	c #8AAACC",
-"{+	c #A2C1E1",
-"]+	c #86C1F5",
-"^+	c #B4D7FE",
-"/+	c #6CA5E8",
-"(+	c #22548C",
-"_+	c #6D94BF",
-":+	c #98B6D6",
-"<+	c #134174",
-"[+	c #84BDF5",
-"}+	c #CAE4FC",
-"|+	c #CBE3FD",
-"1+	c #8FC3FF",
-"2+	c #3F72AD",
-"3+	c #49719C",
-"4+	c #0C3B70",
-"5+	c #9CBBDB",
-"6+	c #79B7F3",
-"7+	c #BFDCFD",
-"8+	c #7FBBFF",
-"9+	c #7E9FC3",
-"0+	c #77B6F3",
-"a+	c #A5CEF7",
-"b+	c #9FCBFE",
-"c+	c #3267A1",
-"d+	c #A4CDF7",
-"e+	c #B9D9FA",
-"f+	c #C7E1FD",
-"g+	c #90C3FF",
-"h+	c #15457C",
-"i+	c #558CCB",
-"j+	c #2E5889",
-"k+	c #7B9CC1",
-"l+	c #C4DDF6",
-"m+	c #BBDAFA",
-"n+	c #CDE5FD",
-"o+	c #B3D6FE",
-"p+	c #80BAFF",
-"q+	c #4E84C3",
-"r+	c #3E73AF",
-"s+	c #78B3F7",
-"t+	c #5991D1",
-"u+	c #477DBA",
-"v+	c #4075B2",
-"w+	c #5783B6",
-"x+	c #BDD6F0",
-"y+	c #A1CBF6",
-"z+	c #90C4FF",
-"A+	c #BCDBFD",
-"B+	c #73B0F1",
-"C+	c #C5E0FB",
-"D+	c #91C5FF",
-"E+	c #AED3FE",
-"F+	c #C9E2FC",
-"G+	c #76B2F2",
-"H+	c #8BBFF9",
-"I+	c #81BBFE",
-"J+	c #9ECBFE",
-"K+	c #84B8F3",
-"L+	c #79B4F4",
-"M+	c #88BEFA",
-"N+	c #83BCFE",
-"O+	c #A4CFFC",
-"P+	c #A6CDF6",
-"Q+	c #82B8F2",
-"R+	c #529BEC",
-"                      . + @ # $ % & * =                         ",
-"                  - ; > > , ' ) ! ~ { { { ] ^                   ",
-"              / ; > > > > ; ( _ : < { { { { { [ }               ",
-"            | 1 2 > > > 2 3 4 5 { { { { { 6 { { { 7             ",
-"          8 $ < 9 0 a b c d e { { { { f g h { { { { i           ",
-"        j k l m n n n n n n o { { p q r n s { { { { { i         ",
-"      t u v n n n n n n n n o { { w n n n s { { { { { { x       ",
-"    y z A n n n n n n n n n o { { o n n n s { { { { { { B C     ",
-"    D E n n n F G H I n n n o { { o n n n s { { { { { J K %     ",
-"  L M n n n N O { { s n n n o { { o n n P Q { { { { { R > > S   ",
-"  T n n n n H { { { s n n n o { { o U V 6 W X Y Z `  ...> > +.  ",
-"  @.n n n #.{ { { { s n n n o { { $.%.W &.U n n n n n v *.> > =.",
-"-.;.n n n >.{ { { { s n n n ,.{ { { '.).n n n n n n n n !.~.> {.",
-"].^.n n n q { { { { s n /.(.{ { _.:.n n n n n n n n n n n m <.[.",
-"}.|.n n n H { { { { 1.2.3.{ 4.5.6.n n n 7.8.9.0.a.b.n n n n c.d.",
-"e.f.n n n g.{ { { { { { { h.i.n n n n j.k.{ { { l.m.n.n n n o.$ ",
-"p.q.n n n /.r.s.t.u.v.w.x.n n n n i.h.{ { { { { { u.o.n n n y.$ ",
-"z.A.n n n n B.C.D.u E.F.n n n 6.5.4.{ 3.2.1.{ { { { G.n n n H.d.",
-"I.p J.n n n n n n n n n n n K.L.{ { (./.n s { { { { M.n n n N.O.",
-"P.{ (.Q.n n n n n n n n R.S.> K _ ,.n n n s { { { { 5.n n n T.U.",
-"V.{ { W.X.n n n n n Y.Z.`. +.+> ++o n n n s { { { { @+n n n #+$+",
-"  %+{ { &+*+Z.=+a -+;+>+,+'+)+> > !+n n n s { { { ~+n n n n {+  ",
-"  ]+{ { ^+> > > > > /+(+n n )+> > )+n n n _+{ { :+<+n n n o [+  ",
-"    }+{ |+1+> > > > l n n n )+> > )+n n n 2+~+3+E n n n 4+5+    ",
-"    6+{ { 7+8+> > > l n n n )+> > )+n n n n n n n n n F 9+0+    ",
-"      a+{ { b+> > > l n n n c+> > )+n n n n n n n n r O d+      ",
-"        e+{ f+g+> > l n h+i+<.> > )+n n n n n E j+k+l+m+        ",
-"          e+{ n+o+p+q+r+s+> > > > t+u+v+w+2.W.x+{ { e+          ",
-"            y+{ { z+>+> > > > > > > > > A+{ { { { d+            ",
-"              B+C+) > > > > > > > > D+E+{ { { F+G+              ",
-"                  H+I+> > > > > > J+{ { { C+K+                  ",
-"                      L+M+# N+; 8+O+P+Q+R+                      "};
--- a/misc/Makefile
+++ b/misc/Makefile
@@ -1,33 +0,0 @@
-PYTHON = python3
-PREFIX = /usr/local
-DESTDIR =
-ICONSIZES = 16 24 32 48 64 128 256 512
-
-SETUPTOOLSOPTIONS =
-ifdef DESTDIR
-SETUPTOOLSOPTS = --root="$(DESTDIR)"
-endif
-
-.PHONY: install
-
-doc/qutebrowser.1.html:
-	a2x -f manpage doc/qutebrowser.1.asciidoc
-
-install: doc/qutebrowser.1.html
-	$(PYTHON) setup.py install --prefix="$(PREFIX)" --optimize=1 $(SETUPTOOLSOPTS)
-	install -Dm644 misc/qutebrowser.appdata.xml \
-		"$(DESTDIR)$(PREFIX)/share/metainfo/qutebrowser.appdata.xml"
-	install -Dm644 doc/qutebrowser.1 \
-		"$(DESTDIR)$(PREFIX)/share/man/man1/qutebrowser.1"
-	install -Dm644 misc/qutebrowser.desktop \
-		"$(DESTDIR)$(PREFIX)/share/applications/qutebrowser.desktop"
-	$(foreach i,$(ICONSIZES),install -Dm644 "icons/qutebrowser-$(i)x$(i).png" \
-			"$(DESTDIR)$(PREFIX)/share/icons/hicolor/$(i)x$(i)/apps/qutebrowser.png";)
-	install -Dm644 icons/qutebrowser.svg \
-		"$(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/qutebrowser.svg"
-	install -Dm755 -t "$(DESTDIR)$(PREFIX)/share/qutebrowser/userscripts/" \
-		$(wildcard misc/userscripts/*)
-	install -Dm755 -t "$(DESTDIR)$(PREFIX)/share/qutebrowser/scripts/" \
-		$(filter-out scripts/__init__.py scripts/__pycache__ scripts/dev \
-		  scripts/testbrowser scripts/asciidoc2html.py scripts/setupcommon.py \
-			scripts/link_pyqt.py,$(wildcard scripts/*))
--- a/misc/apparmor/usr.bin.qutebrowser
+++ b/misc/apparmor/usr.bin.qutebrowser
@@ -29,8 +29,6 @@ profile qutebrowser /usr/{local/,}bin/qutebrowser {

    /proc/*/mounts r,
    owner /tmp/** rwkl,
-    owner /run/user/*/ rw,
-    owner /run/user/*/** krw,

    @{HOME}/.config/qutebrowser/** krw,
    @{HOME}/.local/share/qutebrowser/** krw,
--- a/misc/cheatsheet.svg
+++ b/misc/cheatsheet.svg
--- a/misc/qutebrowser.appdata.xml
+++ b/misc/qutebrowser.appdata.xml
@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Copyright 2017 suve <veg@svgames.pl> -->
-<component type="desktop">
-	<id>org.qutebrowser.qutebrowser</id>
-	<metadata_license>CC-BY-SA-3.0</metadata_license>
-	<project_license>GPL-3.0</project_license>
-	<name>qutebrowser</name>
-	<summary>A keyboard-driven web browser</summary>
-	<description>
-		<p>
-			qutebrowser is a keyboard-focused browser with a minimal GUI.
-			It was inspired by other browsers/addons like dwb and Vimperator/Pentadactyl,
-			and is based on Python and PyQt5.
-		</p>
-	</description>
-	<categories>
-		<category>Network</category>
-		<category>WebBrowser</category>
-	</categories>
-	<provides>
-		<binary>qutebrowser</binary>
-	</provides>
-	<launchable type="desktop-id">qutebrowser.desktop</launchable>
-	<screenshots>
-		<screenshot type="default">
-			<image>https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/main.png</image>
-		</screenshot>
-		<screenshot>
-			<image>https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/downloads.png</image>
-		</screenshot>
-		<screenshot>
-			<image>https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/completion.png</image>
-		</screenshot>
-		<screenshot>
-			<image>https://raw.githubusercontent.com/qutebrowser/qutebrowser/master/doc/img/hints.png</image>
-		</screenshot>
-	</screenshots>
-	<url type="homepage">https://www.qutebrowser.org</url>
-	<url type="faq">https://qutebrowser.org/doc/faq.html</url>
-	<url type="help">https://qutebrowser.org/doc/help/</url>
-	<url type="bugtracker">https://github.com/qutebrowser/qutebrowser/issues/</url>
-	<url type="donation">https://github.com/qutebrowser/qutebrowser#donating</url>
-	<releases>
-		<release version="1.3.0" date="2018-05-04"/>
-		<release version="1.2.1" date="2018-03-14"/>
-		<release version="1.2.0" date="2018-03-09"/>
-	</releases>
-</component>
--- a/misc/qutebrowser.nsi
+++ b/misc/qutebrowser.nsi
@@ -1,79 +0,0 @@
-Name "qutebrowser"
-
-Unicode true
-RequestExecutionLevel admin
-SetCompressor /solid lzma
-
-!ifdef X64
-  OutFile "..\dist\qutebrowser-${VERSION}-amd64.exe"
-  InstallDir "$ProgramFiles64\qutebrowser"
-!else
-  OutFile "..\dist\qutebrowser-${VERSION}-win32.exe"
-  InstallDir "$ProgramFiles\qutebrowser"
-!endif
-
-;Default installation folder
-  
-!include "MUI2.nsh"
-;!include "MultiUser.nsh"
-
-!define MUI_ABORTWARNING
-;!define MULTIUSER_MUI
-;!define MULTIUSER_INSTALLMODE_COMMANDLINE
-!define MUI_ICON "../icons/qutebrowser.ico"
-!define MUI_UNICON "../icons/qutebrowser.ico"
-
-!insertmacro MUI_PAGE_LICENSE "..\LICENSE"
-!insertmacro MUI_PAGE_DIRECTORY
-!insertmacro MUI_PAGE_INSTFILES
-!insertmacro MUI_UNPAGE_CONFIRM
-!insertmacro MUI_UNPAGE_INSTFILES
-
-!insertmacro MUI_LANGUAGE "English"
-
-; depends on admin status
-;SetShellVarContext current
-
-
-Section "Install"
-
-  ; Uninstall old versions
-  ExecWait 'MsiExec.exe /quiet /qn /norestart /X{633F41F9-FE9B-42D1-9CC4-718CBD01EE11}'
-  ExecWait 'MsiExec.exe /quiet /qn /norestart /X{9331D947-AC86-4542-A755-A833429C6E69}'
-  RMDir /r "$INSTDIR\*.*"
-  CreateDirectory "$INSTDIR"
-
-  SetOutPath "$INSTDIR"
-  
-  !ifdef X64
-	file /r "..\dist\qutebrowser-${VERSION}-x64\*.*"
-  !else
-	file /r "..\dist\qutebrowser-${VERSION}-x86\*.*"
-  !endif
-
-  SetShellVarContext all
-  CreateShortCut "$SMPROGRAMS\qutebrowser.lnk" "$INSTDIR\qutebrowser.exe"
-  
-  ;Create uninstaller
-  WriteUninstaller "$INSTDIR\uninst.exe"
-
-  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\qutebrowser" "DisplayName" "qutebrowser"
-  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\qutebrowser" "UninstallString" '"$INSTDIR\uninst.exe"'
-  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\qutebrowser" "QuietUninstallString" '"$INSTDIR\uninst.exe" /S'
-
-SectionEnd
-
-;--------------------------------
-;Uninstaller Section
-
-Section "Uninstall"
-
-  SetShellVarContext all
-  Delete "$SMPROGRAMS\qutebrowser.lnk"
-
-  RMDir /r "$INSTDIR\*.*"
-  RMDir "$INSTDIR"
-
-  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\qutebrowser"
-
-SectionEnd
--- a/misc/qutebrowser.spec
+++ b/misc/qutebrowser.spec
@@ -1,76 +0,0 @@
-# -*- mode: python -*-
-
-import sys
-import os
-
-sys.path.insert(0, os.getcwd())
-from scripts import setupcommon
-
-block_cipher = None
-
-
-def get_data_files():
-    data_files = [
-        ('../qutebrowser/html', 'html'),
-        ('../qutebrowser/img', 'img'),
-        ('../qutebrowser/javascript', 'javascript'),
-        ('../qutebrowser/html/doc', 'html/doc'),
-        ('../qutebrowser/git-commit-id', '.'),
-        ('../qutebrowser/config/configdata.yml', 'config'),
-    ]
-
-    # if os.path.exists(os.path.join('qutebrowser', '3rdparty', 'pdfjs')):
-    #     data_files.append(('../qutebrowser/3rdparty/pdfjs', '3rdparty/pdfjs'))
-    # else:
-    #     print("Warning: excluding pdfjs as it's not present!")
-
-    return data_files
-
-
-setupcommon.write_git_file()
-
-
-if os.name == 'nt':
-    icon = 'icons/qutebrowser.ico'
-elif sys.platform == 'darwin':
-    icon = 'icons/qutebrowser.icns'
-else:
-    icon = None
-
-
-a = Analysis(['../qutebrowser/__main__.py'],
-             pathex=['misc'],
-             binaries=None,
-             datas=get_data_files(),
-             hiddenimports=['PyQt5.QtOpenGL', 'PyQt5._QOpenGLFunctions_2_0'],
-             hookspath=[],
-             runtime_hooks=[],
-             excludes=['tkinter'],
-             win_no_prefer_redirects=False,
-             win_private_assemblies=False,
-             cipher=block_cipher)
-pyz = PYZ(a.pure, a.zipped_data,
-             cipher=block_cipher)
-exe = EXE(pyz,
-          a.scripts,
-          exclude_binaries=True,
-          name='qutebrowser',
-          icon=icon,
-          debug=False,
-          strip=False,
-          upx=False,
-          console=False,
-          version='misc/file_version_info.txt')
-coll = COLLECT(exe,
-               a.binaries,
-               a.zipfiles,
-               a.datas,
-               strip=False,
-               upx=False,
-               name='qutebrowser')
-
-app = BUNDLE(coll,
-             name='qutebrowser.app',
-             icon=icon,
-             # https://github.com/pyinstaller/pyinstaller/blob/b78bfe530cdc2904f65ce098bdf2de08c9037abb/PyInstaller/hooks/hook-PyQt5.QtWebEngineWidgets.py#L24
-             bundle_identifier='org.qt-project.Qt.QtWebEngineCore')
--- a/misc/requirements/README.md
+++ b/misc/requirements/README.md
@@ -1,20 +0,0 @@
-This directory contains various `requirements` files which are used by `tox` to
-have reproducible tests with pinned versions.
-
-The files are generated based on unpinned requirements in `*.txt-raw` files.
-
-Those files can also contain some special commands:
-
- Add an additional comment to a line: `#@ comment: <package> <comment here>`
- Filter a line for requirements.io: `#@ filter: <package> <filter>`
- Don't include a package in the output: `#@ ignore: <package>` (or multiple packages)
- Replace a part of a frozen package specification with another: `#@ replace <regex> <replacement>`
-
-Some examples:
-
-```
-#@ comment: mypkg blah blub
-#@ filter: mypkg != 1.0.0
-#@ ignore: mypkg, otherpkg
-#@ replace: foo bar
-```
--- a/misc/requirements/requirements-check-manifest.txt
+++ b/misc/requirements/requirements-check-manifest.txt
@@ -1,3 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-check-manifest==0.37
--- a/misc/requirements/requirements-check-manifest.txt-raw
+++ b/misc/requirements/requirements-check-manifest.txt-raw
@@ -1 +0,0 @@
-check-manifest
--- a/misc/requirements/requirements-codecov.txt
+++ b/misc/requirements/requirements-codecov.txt
@@ -1,9 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-certifi==2018.4.16
-chardet==3.0.4
-codecov==2.0.15
-coverage==4.5.1
-idna==2.7
-requests==2.19.1
-urllib3==1.22
--- a/misc/requirements/requirements-codecov.txt-raw
+++ b/misc/requirements/requirements-codecov.txt-raw
@@ -1 +0,0 @@
-codecov
--- a/misc/requirements/requirements-flake8.txt
+++ b/misc/requirements/requirements-flake8.txt
@@ -1,27 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-attrs==18.1.0
-flake8==3.5.0
-flake8-bugbear==18.2.0
-flake8-builtins==1.4.1  # rq.filter: != 1.4.0
-flake8-comprehensions==1.4.1
-flake8-copyright==0.2.0
-flake8-debugger==3.1.0
-flake8-deprecated==1.3
-flake8-docstrings==1.3.0
-flake8-future-import==0.4.4
-flake8-mock==0.3
-flake8-per-file-ignores==0.6
-flake8-polyfill==1.0.2
-flake8-string-format==0.2.3
-flake8-tidy-imports==1.1.0
-flake8-tuple==0.2.13
-mccabe==0.6.1
-pathmatch==0.2.1
-pep8-naming==0.7.0
-pycodestyle==2.3.1  # rq.filter: < 2.4.0
-pydocstyle==2.1.1
-pyflakes==2.0.0
-six==1.11.0
-snowballstemmer==1.2.1
-typing==3.6.4
--- a/misc/requirements/requirements-flake8.txt-raw
+++ b/misc/requirements/requirements-flake8.txt-raw
@@ -1,23 +0,0 @@
-flake8
-flake8-bugbear
-flake8-builtins!=1.4.0
-flake8-comprehensions
-flake8-copyright
-flake8-debugger
-flake8-deprecated
-flake8-docstrings
-flake8-future-import
-flake8-mock
-flake8-per-file-ignores
-flake8-string-format
-flake8-tidy-imports
-flake8-tuple
-pep8-naming
-pydocstyle
-pyflakes
-
-# https://github.com/PyCQA/pycodestyle/issues/741
-#@ filter: pycodestyle < 2.4.0
-
-# https://github.com/gforcada/flake8-builtins/issues/36
-#@ filter: flake8-builtins != 1.4.0
--- a/misc/requirements/requirements-pip.txt
+++ b/misc/requirements/requirements-pip.txt
@@ -1,8 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-appdirs==1.4.3
-packaging==17.1
-pyparsing==2.2.0
-setuptools==39.2.0
-six==1.11.0
-wheel==0.31.1
--- a/misc/requirements/requirements-pyinstaller.txt
+++ b/misc/requirements/requirements-pyinstaller.txt
@@ -1,7 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-altgraph==0.15
-future==0.16.0
-macholib==1.9
-pefile==2017.11.5
-PyInstaller==3.3.1
--- a/misc/requirements/requirements-pyinstaller.txt-raw
+++ b/misc/requirements/requirements-pyinstaller.txt-raw
@@ -1 +0,0 @@
-PyInstaller
--- a/misc/requirements/requirements-pylint-master.txt
+++ b/misc/requirements/requirements-pylint-master.txt
@@ -1,18 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-e git+https://github.com/PyCQA/astroid.git#egg=astroid
-certifi==2018.4.16
-chardet==3.0.4
-github3.py==1.1.0
-idna==2.7
-isort==4.3.4
-lazy-object-proxy==1.3.1
-mccabe==0.6.1
-e git+https://github.com/PyCQA/pylint.git#egg=pylint
-python-dateutil==2.7.3
-./scripts/dev/pylint_checkers
-requests==2.19.1
-six==1.11.0
-uritemplate==3.0.0
-urllib3==1.22
-wrapt==1.10.11
--- a/misc/requirements/requirements-pylint-master.txt-raw
+++ b/misc/requirements/requirements-pylint-master.txt-raw
@@ -1,11 +0,0 @@
-e git+https://github.com/PyCQA/astroid.git#egg=astroid
-e git+https://github.com/PyCQA/pylint.git#egg=pylint
-./scripts/dev/pylint_checkers
-requests
-github3.py
-
-# remove @commit-id for scm installs
-#@ replace: @.*# #
-
-# fix qute-pylint location
-#@ replace: qute-pylint==.* ./scripts/dev/pylint_checkers
--- a/misc/requirements/requirements-pylint.txt
+++ b/misc/requirements/requirements-pylint.txt
@@ -1,18 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-astroid==1.6.5
-certifi==2018.4.16
-chardet==3.0.4
-github3.py==1.1.0
-idna==2.7
-isort==4.3.4
-lazy-object-proxy==1.3.1
-mccabe==0.6.1
-pylint==1.9.2
-python-dateutil==2.7.3
-./scripts/dev/pylint_checkers
-requests==2.19.1
-six==1.11.0
-uritemplate==3.0.0
-urllib3==1.22
-wrapt==1.10.11
--- a/misc/requirements/requirements-pylint.txt-raw
+++ b/misc/requirements/requirements-pylint.txt-raw
@@ -1,7 +0,0 @@
-pylint
-./scripts/dev/pylint_checkers
-requests
-github3.py
-
-# fix qute-pylint location
-#@ replace: qute-pylint==.* ./scripts/dev/pylint_checkers
--- a/misc/requirements/requirements-pyqt.txt
+++ b/misc/requirements/requirements-pyqt.txt
@@ -1,4 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-PyQt5==5.11.2
-PyQt5-sip==4.19.11
--- a/misc/requirements/requirements-pyqt.txt-raw
+++ b/misc/requirements/requirements-pyqt.txt-raw
@@ -1 +0,0 @@
-PyQt5
--- a/misc/requirements/requirements-pyroma.txt
+++ b/misc/requirements/requirements-pyroma.txt
@@ -1,4 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-docutils==0.14
-pyroma==2.3.1
--- a/misc/requirements/requirements-pyroma.txt-raw
+++ b/misc/requirements/requirements-pyroma.txt-raw
@@ -1 +0,0 @@
-pyroma
--- a/misc/requirements/requirements-qutebrowser.txt-raw
+++ b/misc/requirements/requirements-qutebrowser.txt-raw
@@ -1,9 +0,0 @@
-Jinja2
-Pygments
-pyPEG2
-PyYAML!=4.1
-colorama
-cssutils
-attrs
-
-#@ filter: PyYAML != 4.1
--- a/misc/requirements/requirements-tests-git.txt
+++ b/misc/requirements/requirements-tests-git.txt
@@ -1,38 +0,0 @@
-bzr+lp:beautifulsoup
-git+https://github.com/cherrypy/cheroot.git
-hg+https://bitbucket.org/ned/coveragepy
-git+https://github.com/micheles/decorator.git
-git+https://github.com/pallets/flask.git
-git+https://github.com/miracle2k/python-glob2.git
-git+https://github.com/HypothesisWorks/hypothesis-python.git
-git+https://github.com/pallets/itsdangerous.git
-git+https://bitbucket.org/zzzeek/mako.git
-git+https://github.com/r1chardj0n3s/parse.git
-git+https://github.com/jenisys/parse_type.git
-hg+https://bitbucket.org/pytest-dev/py
-git+https://github.com/pytest-dev/pytest.git@features
-git+https://github.com/pytest-dev/pytest-bdd.git
-git+https://github.com/pytest-dev/pytest-cov.git
-git+https://github.com/pytest-dev/pytest-faulthandler.git
-git+https://github.com/pytest-dev/pytest-instafail.git
-git+https://github.com/pytest-dev/pytest-mock.git
-git+https://github.com/pytest-dev/pytest-qt.git
-git+https://github.com/pytest-dev/pytest-repeat.git
-git+https://github.com/pytest-dev/pytest-rerunfailures.git
-git+https://github.com/abusalimov/pytest-travis-fold.git
-git+https://github.com/The-Compiler/pytest-xvfb.git
-hg+https://bitbucket.org/gutworth/six
-hg+https://bitbucket.org/jendrikseipp/vulture
-git+https://github.com/pallets/werkzeug.git
-
-
-## qutebrowser dependencies
-
-git+https://github.com/tartley/colorama.git
-hg+https://bitbucket.org/cthedot/cssutils
-git+https://github.com/pallets/jinja.git
-git+https://github.com/pallets/markupsafe.git
-hg+http://bitbucket.org/birkenfeld/pygments-main
-hg+https://bitbucket.org/fdik/pypeg
-git+https://github.com/python-attrs/attrs.git
-git+https://github.com/yaml/pyyaml.git
--- a/misc/requirements/requirements-tests.txt
+++ b/misc/requirements/requirements-tests.txt
@@ -1,40 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-attrs==18.1.0
-beautifulsoup4==4.6.0
-cheroot==6.3.2
-click==6.7
-# colorama==0.3.9
-coverage==4.5.1
-EasyProcess==0.2.3
-fields==5.0.0
-Flask==1.0.2
-glob2==0.6
-hunter==2.0.2
-hypothesis==3.65.0
-itsdangerous==0.24
-# Jinja2==2.10
-Mako==1.0.7
-# MarkupSafe==1.0
-more-itertools==4.2.0
-parse==1.8.4
-parse-type==0.4.2
-pluggy==0.6.0
-py==1.5.4
-py-cpuinfo==4.0.0
-pytest==3.6.2
-pytest-bdd==2.21.0
-pytest-benchmark==3.1.1
-pytest-cov==2.5.1
-pytest-faulthandler==1.5.0
-pytest-instafail==0.4.0
-pytest-mock==1.10.0
-pytest-qt==2.4.1
-pytest-repeat==0.4.1
-pytest-rerunfailures==4.1
-pytest-travis-fold==1.3.0
-pytest-xvfb==1.1.0
-PyVirtualDisplay==0.2.1
-six==1.11.0
-vulture==0.27
-Werkzeug==0.14.1
--- a/misc/requirements/requirements-tests.txt-raw
+++ b/misc/requirements/requirements-tests.txt-raw
@@ -1,21 +0,0 @@
-beautifulsoup4
-cheroot
-coverage
-Flask
-hunter
-hypothesis
-pytest
-pytest-bdd
-pytest-benchmark
-pytest-cov
-pytest-faulthandler
-pytest-instafail
-pytest-mock
-pytest-qt
-pytest-repeat
-pytest-rerunfailures
-pytest-travis-fold
-pytest-xvfb
-vulture
-
-#@ ignore: Jinja2, MarkupSafe, colorama
--- a/misc/requirements/requirements-tox.txt
+++ b/misc/requirements/requirements-tox.txt
@@ -1,7 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-pluggy==0.6.0
-py==1.5.4
-six==1.11.0
-tox==3.0.0
-virtualenv==16.0.0
--- a/misc/requirements/requirements-tox.txt-raw
+++ b/misc/requirements/requirements-tox.txt-raw
@@ -1 +0,0 @@
-tox
--- a/misc/requirements/requirements-vulture.txt
+++ b/misc/requirements/requirements-vulture.txt
@@ -1,3 +0,0 @@
-# This file is automatically generated by scripts/dev/recompile_requirements.py
-
-vulture==0.27
--- a/misc/requirements/requirements-vulture.txt-raw
+++ b/misc/requirements/requirements-vulture.txt-raw
@@ -1 +0,0 @@
-vulture
--- a/misc/userscripts/cast
+++ b/misc/userscripts/cast
@@ -1,156 +0,0 @@
-#!/usr/bin/env bash
-#
-# Behaviour
-#   Userscript for qutebrowser which casts the url passed in $1 to the default
-#   ChromeCast device in the network using the program `castnow`
-#
-# Usage
-#   You can launch the script from qutebrowser as follows:
-#       spawn --userscript ${PATH_TO_FILE} {url}
-#
-#   Then, you can control the chromecast by launching the simple command
-#   `castnow` in a shell which will connect to the running castnow instance.
-#
-#   For stopping the script, issue the command `pkill -f castnow` which would
-#   then let the rest of the userscript execute for cleaning temporary file.
-#
-# Thanks
-#   This userscript borrows Thorsten Wißmann's javascript code from his `mpv`
-#   userscript.
-#
-# Dependencies
-#   - castnow, https://github.com/xat/castnow
-#
-# Author
-#   Simon Désaulniers <sim.desaulniers@gmail.com>
-
-if [ -z "$QUTE_FIFO" ] ; then
-    cat 1>&2 <<EOF
-Error: $0 can not be run as a standalone script.
-
-It is a qutebrowser userscript. In order to use it, call it using
-'spawn --userscript' as described in qute://help/userscripts.html
-EOF
-    exit 1
-fi
-
-msg() {
-    local cmd="$1"
-    shift
-    local msg="$*"
-    if [ -z "$QUTE_FIFO" ] ; then
-        echo "$cmd: $msg" >&2
-    else
-        echo "message-$cmd '${msg//\'/\\\'}'" >> "$QUTE_FIFO"
-    fi
-}
-
-js() {
-cat <<EOF
-
-    function descendantOfTagName(child, ancestorTagName) {
-        // tells whether child has some (proper) ancestor
-        // with the tag name ancestorTagName
-        while (child.parentNode != null) {
-            child = child.parentNode;
-            if (typeof child.tagName === 'undefined') break;
-            if (child.tagName.toUpperCase() == ancestorTagName.toUpperCase()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    var App = {};
-
-    var all_videos = [];
-    all_videos.push.apply(all_videos, document.getElementsByTagName("video"));
-    all_videos.push.apply(all_videos, document.getElementsByTagName("object"));
-    all_videos.push.apply(all_videos, document.getElementsByTagName("embed"));
-    App.backup_videos = Array();
-    App.all_replacements = Array();
-    for (i = 0; i < all_videos.length; i++) {
-        var video = all_videos[i];
-        if (descendantOfTagName(video, "object")) {
-            // skip tags that are contained in an object, because we hide
-            // the object anyway.
-            continue;
-        }
-        var replacement = document.createElement("div");
-        replacement.innerHTML = "
-            <p style=\\"margin-bottom: 0.5em\\">
-            The video is being cast on your ChromeCast device.
-            </p>
-            <p>
-            In order to restore this particular video
-            <a style=\\"font-weight: bold;
-                        color: white;
-                        background: transparent;
-                     \\"
-               onClick=\\"restore_video(this, " + i + ");\\"
-               href=\\"javascript: restore_video(this, " + i + ")\\"
-              >click here</a>.
-            </p>
-        ";
-        replacement.style.position = "relative";
-        replacement.style.zIndex = "100003000000";
-        replacement.style.fontSize = "1rem";
-        replacement.style.textAlign = "center";
-        replacement.style.verticalAlign = "middle";
-        replacement.style.height = "100%";
-        replacement.style.background = "#101010";
-        replacement.style.color = "white";
-        replacement.style.border = "4px dashed #545454";
-        replacement.style.padding = "2em";
-        replacement.style.margin = "auto";
-        App.all_replacements[i] = replacement;
-        App.backup_videos[i] = video;
-        video.parentNode.replaceChild(replacement, video);
-    }
-
-    function restore_video(obj, index) {
-        obj = App.all_replacements[index];
-        video = App.backup_videos[index];
-        console.log(video);
-        obj.parentNode.replaceChild(video, obj);
-    }
-
-    /** force repainting the video, thanks to:
-     * http://martinwolf.org/2014/06/10/force-repaint-of-an-element-with-javascript/
-     */
-    var siteHeader = document.getElementById('header');
-    siteHeader.style.display='none';
-    siteHeader.offsetHeight; // no need to store this anywhere, the reference is enough
-    siteHeader.style.display='block';
-
-EOF
-}
-
-printjs() {
-    js | sed 's,//.*$,,' | tr '\n' ' '
-}
-echo "jseval -q $(printjs)" >> "$QUTE_FIFO"
-
-tmpdir=$(mktemp -d)
-file_to_cast=${tmpdir}/qutecast
-program_=$(command -v castnow)
-
-if [[ "${program_}" == "" ]]; then
-    msg error "castnow can't be found..."
-    exit 1
-fi
-
-# kill any running instance of castnow
-pkill -f "${program_}"
-
-# start youtube download in stream mode (-o -) into temporary file
-youtube-dl -qo - "$1" > "${file_to_cast}" &
-ytdl_pid=$!
-
-msg info "Casting $1" >> "$QUTE_FIFO"
-# start castnow in stream mode to cast on ChromeCast
-tail -F "${file_to_cast}" | ${program_} -
-
-# cleanup remaining background process and file on disk
-kill ${ytdl_pid}
-rm -rf "${tmpdir}"
--- a/misc/userscripts/dmenu_qutebrowser
+++ b/misc/userscripts/dmenu_qutebrowser
@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-# Copyright 2015 Zach-Button <zachrey.button@gmail.com>
-# Copyright 2015-2017 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-# Pipes history, quickmarks, and URL into dmenu.
-#
-# If run from qutebrowser as a userscript, it runs :open on the URL
-# If not, it opens a new qutebrowser window at the URL
-#
-# Ideal for use with tabs_are_windows. Set a hotkey to launch this script, then:
-#	:bind o spawn --userscript dmenu_qutebrowser
-#
-# Use the hotkey to open in new tab/window, press 'o' to open URL in current tab/window
-# You can simulate "go" by pressing "o<tab>", as the current URL is always first in the list
-#
-# I personally use "<Mod4>o" to launch this script. For me, my workflow is:
-#	Default	keys		Keys with this script
-#	O			<Mod4>o
-#	o			o
-#	go			o<Tab>
-#	gO			gC, then o<Tab>
-#				(This is unnecessarily long. I use this rarely, feel free to make this script accept parameters.)
-#
-
-[ -z "$QUTE_URL" ] && QUTE_URL='http://google.com'
-
-url=$(echo "$QUTE_URL" | cat - "$QUTE_CONFIG_DIR/quickmarks" "$QUTE_DATA_DIR/history" | dmenu -l 15 -p qutebrowser)
-url=$(echo "$url" | sed -E 's/[^ ]+ +//g' | grep -E "https?:" || echo "$url")
-
-[ -z "${url// }" ] && exit
-
-echo "open $url" >> "$QUTE_FIFO" || qutebrowser "$url"
--- a/misc/userscripts/format_json
+++ b/misc/userscripts/format_json
@@ -1,42 +0,0 @@
-#!/bin/sh
-set -euo pipefail
-#
-# Behavior:
-#   Userscript for qutebrowser which will take the raw JSON text of the current
-#   page, format it using `jq`, will add syntax highlighting using `pygments`,
-#   and open the syntax highlighted pretty printed html in a new tab. If the file
-#   is larger than 10MB then this script will only indent the json and will forego
-#   syntax highlighting using pygments.
-#
-#   In order to use this script, just start it using `spawn --userscript` from
-#   qutebrowser. I recommend using an alias, e.g. put this in the
-#   [alias]-section of qutebrowser.conf:
-#
-#     json = spawn --userscript /path/to/json_format
-#
-#   Note that the color style defaults to monokai, but a different pygments style
-#   can be passed as the first parameter to the script. A full list of the pygments
-#   styles can be found at: https://help.farbox.com/pygments.html
-#
-# Bryan Gilbert, 2017
-
-# do not run pygmentize on files larger than this amount of bytes
-MAX_SIZE_PRETTIFY=10485760  # 10 MB
-# default style to monokai if none is provided
-STYLE=${1:-monokai}
-
-TEMP_FILE="$(mktemp)"
-jq . "$QUTE_TEXT" >"$TEMP_FILE"
-
-# try GNU stat first and then OSX stat if the former fails
-FILE_SIZE=$(
-  stat --printf="%s" "$TEMP_FILE" 2>/dev/null ||
-  stat -f%z "$TEMP_FILE" 2>/dev/null
-)
-if [ "$FILE_SIZE" -lt "$MAX_SIZE_PRETTIFY" ]; then
-    pygmentize -l json -f html -O full,style="$STYLE" <"$TEMP_FILE" >"${TEMP_FILE}_"
-    mv -f "${TEMP_FILE}_" "$TEMP_FILE"
-fi
-
-# send the command to qutebrowser to open the new file containing the formatted json
-echo "open -t file://$TEMP_FILE" >> "$QUTE_FIFO"
--- a/misc/userscripts/getbib
+++ b/misc/userscripts/getbib
@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-"""Qutebrowser userscript scraping the current web page for DOIs and downloading
-corresponding bibtex information.
-
-Set the environment variable 'QUTE_BIB_FILEPATH' to indicate the path to
-download to. Otherwise, bibtex information is downloaded to '/tmp' and hence
-deleted at reboot.
-
-Installation: see qute://help/userscripts.html
-
-Inspired by
-https://ocefpaf.github.io/python4oceanographers/blog/2014/05/19/doi2bibtex/
-"""
-
-import os
-import sys
-import shutil
-import re
-from collections import Counter
-from urllib import parse as url_parse
-from urllib import request as url_request
-
-
-FIFO_PATH = os.getenv("QUTE_FIFO")
-
-def message_fifo(message, level="warning"):
-    """Send message to qutebrowser FIFO. The level must be one of 'info',
-    'warning' (default) or 'error'."""
-    with open(FIFO_PATH, "w") as fifo:
-        fifo.write("message-{} '{}'".format(level, message))
-
-
-source = os.getenv("QUTE_TEXT")
-with open(source) as f:
-    text = f.read()
-
-# find DOIs on page using regex
-dval = re.compile(r'(10\.(\d)+/([^(\s\>\"\<)])+)')
-# https://stackoverflow.com/a/10324802/3865876, too strict
-# dval = re.compile(r'\b(10[.][0-9]{4,}(?:[.][0-9]+)*/(?:(?!["&\'<>])\S)+)\b')
-dois = dval.findall(text)
-dois = Counter(e[0] for e in dois)
-try:
-    doi = dois.most_common(1)[0][0]
-except IndexError:
-    message_fifo("No DOIs found on page")
-    sys.exit()
-message_fifo("Found {} DOIs on page, selecting {}".format(len(dois), doi),
-             level="info")
-
-# get bibtex data corresponding to DOI
-url = "http://dx.doi.org/" + url_parse.quote(doi)
-headers = dict(Accept='text/bibliography; style=bibtex')
-request = url_request.Request(url, headers=headers)
-response = url_request.urlopen(request)
-status_code = response.getcode()
-if status_code >= 400:
-    message_fifo("Request returned {}".format(status_code))
-    sys.exit()
-
-# obtain content and format it
-bibtex = response.read().decode("utf-8").strip()
-bibtex = bibtex.replace(" ", "\n    ", 1).\
-    replace("}, ", "},\n    ").replace("}}", "}\n}")
-
-# append to file
-bib_filepath = os.getenv("QUTE_BIB_FILEPATH", "/tmp/qute.bib")
-with open(bib_filepath, "a") as f:
-    f.write(bibtex + "\n\n")
--- a/misc/userscripts/open_download
+++ b/misc/userscripts/open_download
@@ -1,115 +0,0 @@
-#!/usr/bin/env bash
-# Both standalone script and qutebrowser userscript that opens a rofi menu with
-# all files from the download director and opens the selected file. It works
-# both as a userscript and a standalone script that is called from outside of
-# qutebrowser.
-#
-# Suggested keybinding (for "show downloads"):
-# spawn --userscript ~/.config/qutebrowser/open_download
-#     sd
-#
-# Requirements:
-#  - rofi (in a recent version)
-#  - xdg-open and xdg-mime
-#  - You should configure qutebrowser to download files to a single directory
-#  - It comes in handy if you enable downloads.remove_finished. If you want to
-#    see the recent downloads, just press "sd".
-#
-# Thorsten Wißmann, 2015 (thorsten` on freenode)
-# Any feedback is welcome!
-
-set -e
-
-# open a file from the download directory using rofi
-DOWNLOAD_DIR=${DOWNLOAD_DIR:-$QUTE_DOWNLOAD_DIR}
-DOWNLOAD_DIR=${DOWNLOAD_DIR:-$HOME/Downloads}
-# the name of the rofi command
-ROFI_CMD=${ROFI_CMD:-rofi}
-ROFI_ARGS=${ROFI_ARGS:-}
-
-msg() {
-    local cmd="$1"
-    shift
-    local msg="$*"
-    if [ -z "$QUTE_FIFO" ] ; then
-        echo "$cmd: $msg" >&2
-    else
-        echo "message-$cmd '${msg//\'/\\\'}'" >> "$QUTE_FIFO"
-    fi
-}
-die() {
-    msg error "$*"
-    if [ -n "$QUTE_FIFO" ] ; then
-        # when run as a userscript, the above error message already informs the
-        # user about the failure, and no additional "userscript exited with status
-        # 1" is needed.
-        exit 0;
-    else
-        exit 1;
-    fi
-}
-
-if ! [ -d "$DOWNLOAD_DIR" ] ; then
-    die "Download directory »$DOWNLOAD_DIR« not found!"
-fi
-if ! command -v "${ROFI_CMD}" > /dev/null ; then
-    die "Rofi command »${ROFI_CMD}« not found in PATH!"
-fi
-
-rofi_default_args=(
-        -monitor -2 # place above window
-        -location 6 # aligned at the bottom
-        -width 100  # use full window width
-        -i
-        -no-custom
-        -format i   # make rofi return the index
-        -l 10
-        -p 'Open download:' -dmenu
-    )
-
-crop-first-column() {
-    local maxlength=${1:-40}
-    local expression='s|^\([^\t]\{0,'"$maxlength"'\}\)[^\t]*\t|\1\t|'
-    sed "$expression"
-}
-
-ls-files() {
-    # add the slash at the end of the download dir enforces to follow the
-    # symlink, if the DOWNLOAD_DIR itself is a symlink
-    # shellcheck disable=SC2010
-    ls -Q --quoting-style escape    -h  -o -1 -A -t "${DOWNLOAD_DIR}/" \
-        | grep '^[-]' \
-        | cut -d' ' -f3- \
-        | sed 's,^\(.*[^\]\) \(.*\)$,\2\t\1,' \
-        | sed 's,\\\(.\),\1,g'
-}
-
-mapfile -t entries < <(ls-files)
-
-# we need to manually check that there are items, because rofi doesn't show up
-# if there are no items and -no-custom is passed to rofi.
-if [ "${#entries[@]}" -eq 0 ] ; then
-    die "Download directory »${DOWNLOAD_DIR}« empty"
-fi
-
-line=$(printf '%s\n' "${entries[@]}"  \
-       | crop-first-column 55 \
-       | column -s $'\t' -t \
-       | $ROFI_CMD "${rofi_default_args[@]}" "$ROFI_ARGS") || true
-if [ -z "$line" ];  then
-    exit 0
-fi
-
-file="${entries[$line]}"
-file="${file%%$'\t'*}"
-path="$DOWNLOAD_DIR/$file"
-filetype=$(xdg-mime query filetype "$path")
-application=$(xdg-mime query default "$filetype")
-
-if [ -z "$application" ] ; then
-    die "Do not know how to open »$file« of type $filetype"
-fi
-
-msg info "Opening »$file« (of type $filetype) with ${application%.desktop}"
-
-xdg-open "$path" &
--- a/misc/userscripts/openfeeds
+++ b/misc/userscripts/openfeeds
@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# Copyright 2015 jnphilipp <me@jnphilipp.org>
-# Copyright 2016-2017 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-# Opens all links to feeds defined in the head of a site
-#
-# Ideal for use with tabs_are_windows. Set a hotkey to launch this script, then:
-#   :bind gF spawn --userscript openfeeds
-#
-# Use the hotkey to open the feeds in new tab/window, press 'gF' to open
-#
-
-import os
-import re
-
-from bs4 import BeautifulSoup
-from urllib.parse import urljoin
-
-with open(os.environ['QUTE_HTML'], 'r') as f:
-    soup = BeautifulSoup(f)
-with open(os.environ['QUTE_FIFO'], 'w') as f:
-    for link in soup.find_all('link', rel='alternate', type=re.compile(r'application/((rss|rdf|atom)\+)?xml|text/xml')):
-        f.write('open -t %s\n' % urljoin(os.environ['QUTE_URL'], link.get('href')))
--- a/misc/userscripts/password_fill
+++ b/misc/userscripts/password_fill
@@ -1,381 +0,0 @@
-#!/usr/bin/env bash
-help() {
-    blink=$'\e[1;31m' reset=$'\e[0m'
-cat <<EOF
-This script can only be used as a userscript for qutebrowser
-2015, Thorsten Wißmann <edu _at_ thorsten-wissmann _dot_ de>
-In case of questions or suggestions, do not hesitate to send me an E-Mail or to
-directly ask me via IRC (nickname thorsten\`) in #qutebrowser on freenode.
-
-  $blink!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!$reset
-  WARNING: the passwords are stored in qutebrowser's
-           debug log reachable via the url qute://log
-  $blink!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!$reset
-
-Usage: run as a userscript form qutebrowser, e.g.:
-  spawn --userscript ~/.config/qutebrowser/password_fill
-
-Pass backend: (see also passwordstore.org)
-  This script expects pass to store the credentials of each page in an extra
-  file, where the filename (or filepath) contains the domain of the respective
-  page. The first line of the file must contain the password, the login name
-  must be contained in a later line beginning with "user:", "login:", or
-  "username:" (configurable by the user_pattern variable).
-
-Behavior:
-  It will try to find a username/password entry in the configured backend
-  (currently only pass) for the current website and will load that pair of
-  username and password to any form on the current page that has some password
-  entry field. If multiple entries are found, a zenity menu is offered.
-
-  If no entry is found, then it crops subdomains from the url if at least one
-  entry is found in the backend. (In that case, it always shows a menu)
-
-Configuration:
-  This script loads the bash script ~/.config/qutebrowser/password_fill_rc (if
-  it exists), so you can change any configuration variable and overwrite any
-  function you like.
-
-EOF
-}
-
-set -o errexit
-set -o pipefail
-shopt -s nocasematch # make regexp matching in bash case insensitive
-
-if [ -z "$QUTE_FIFO" ] ; then
-    help
-    exit
-fi
-
-error() {
-    local msg="$*"
-    echo "message-error '${msg//\'/\\\'}'" >> "$QUTE_FIFO"
-}
-msg() {
-    local msg="$*"
-    echo "message-info '${msg//\'/\\\'}'" >> "$QUTE_FIFO"
-}
-die() {
-    error "$*"
-    exit 0
-}
-
-javascript_escape() {
-    # print the first argument in an escaped way, such that it can safely
-    # be used within javascripts double quotes
-    sed "s,[\\\\'\"],\\\\&,g" <<< "$1"
-}
-
-# ======================================================= #
-# CONFIGURATION
-# ======================================================= #
-# The configuration file is per default located in
-# ~/.config/qutebrowser/password_fill_rc and is a bash script that is loaded
-# later in the present script. So basically you can replace all of the
-# following definitions and make them fit your needs.
-
-# The following simplifies a URL to the domain (e.g. "wiki.qutebrowser.org")
-# which is later used to search the correct entries in the password backend. If
-# you e.g. don't want the "www." to be removed or if you want to distinguish
-# between different paths on the same domain.
-
-simplify_url() {
-    simple_url="${1##*://}" # remove protocol specification
-    simple_url="${simple_url%%\?*}" # remove GET parameters
-    simple_url="${simple_url%%/*}" # remove directory path
-    simple_url="${simple_url%:*}" # remove port
-    simple_url="${simple_url##www.}" # remove www. subdomain
-}
-
-# no_entries_found() is called if the first query_entries() call did not find
-# any matching entries. Multiple implementations are possible:
-# The easiest behavior is to quit:
-#no_entries_found() {
-#    if [ 0 -eq "${#files[@]}" ] ; then
-#        die "No entry found for »$simple_url«"
-#    fi
-#}
-# But you could also fill the files array with all entries from your pass db
-# if the first db query did not find anything
-# no_entries_found() {
-#     if [ 0 -eq "${#files[@]}" ] ; then
-#         query_entries ""
-#         if [ 0 -eq "${#files[@]}" ] ; then
-#             die "No entry found for »$simple_url«"
-#         fi
-#     fi
-# }
-
-# Another behavior is to drop another level of subdomains until search hits
-# are found:
-no_entries_found() {
-    while [ 0 -eq "${#files[@]}" ] && [ -n "$simple_url" ]; do
-        shorter_simple_url=$(sed 's,^[^.]*\.,,' <<< "$simple_url")
-        if [ "$shorter_simple_url" = "$simple_url" ] ; then
-            # if no dot, then even remove the top level domain
-            simple_url=""
-            query_entries "$simple_url"
-            break
-        fi
-        simple_url="$shorter_simple_url"
-        query_entries "$simple_url"
-        #die "No entry found for »$simple_url«"
-        # enforce menu if we do "fuzzy" matching
-        menu_if_one_entry=1
-    done
-    if [ 0 -eq "${#files[@]}" ] ; then
-        die "No entry found for »$simple_url«"
-    fi
-}
-
-# Backend implementations tell, how the actual password store is accessed.
-# Right now, there is only one fully functional password backend, namely for
-# the program "pass".
-# A password backend consists of three actions:
-#  - init() initializes backend-specific things and does sanity checks.
-#  - query_entries() is called with a simplified url and is expected to fill
-#    the bash array $files with the names of matching password entries. There
-#    are no requirements how these names should look like.
-#  - open_entry() is called with some specific entry of the $files array and is
-#    expected to write the username of that entry to the $username variable and
-#    the corresponding password to $password
-
-reset_backend() {
-    init() { true ; }
-    query_entries() { true ; }
-    open_entry() { true ; }
-}
-
-# choose_entry() is expected to choose one entry from the array $files and
-# write it to the variable $file.
-choose_entry() {
-    choose_entry_zenity
-}
-
-# The default implementation chooses a random entry from the array. So if there
-# are multiple matching entries, multiple calls to this userscript will
-# eventually pick the "correct" entry. I.e. if this userscript is bound to
-# "zl", the user has to press "zl" until the correct username shows up in the
-# login form.
-choose_entry_random() {
-    local nr=${#files[@]}
-    file="${files[$((RANDOM % nr))]}"
-    # Warn user, that there might be other matching password entries
-    if [ "$nr" -gt 1 ] ; then
-        msg "Picked $file out of $nr entries: ${files[*]}"
-    fi
-}
-
-# another implementation would be to ask the user via some menu (like rofi or
-# dmenu or zenity or even qutebrowser completion in future?) which entry to
-# pick
-MENU_COMMAND=( head -n 1 )
-# whether to show the menu if there is only one entry in it
-menu_if_one_entry=0
-choose_entry_menu() {
-    local nr=${#files[@]}
-    if [ "$nr" -eq 1 ] && ! ((menu_if_one_entry)) ; then
-        file="${files[0]}"
-    else
-        file=$( printf '%s\n' "${files[@]}" | "${MENU_COMMAND[@]}" )
-    fi
-}
-
-choose_entry_rofi() {
-    MENU_COMMAND=( rofi -p "qutebrowser> " -dmenu
-                        -mesg $'Pick a password entry for <b>'"${QUTE_URL//&/&amp;}"'</b>' )
-    choose_entry_menu || true
-}
-
-choose_entry_zenity() {
-    MENU_COMMAND=( zenity --list --title "qutebrowser password fill"
-                          --text "Pick the password entry:"
-                          --column "Name" )
-    choose_entry_menu || true
-}
-
-choose_entry_zenity_radio() {
-    zenity_helper() {
-        awk '{ print $0 ; print $0 }'                   \
-        | zenity --list --radiolist                     \
-                 --title "qutebrowser password fill"    \
-                 --text "Pick the password entry:"      \
-                 --column " " --column "Name"
-    }
-    MENU_COMMAND=( zenity_helper )
-    choose_entry_menu || true
-}
-
-# =======================================================
-# backend: PASS
-
-# configuration options:
-match_filename=1 # whether allowing entry match by filepath
-match_line=0     # whether allowing entry match by URL-Pattern in file
-                 # Note: match_line=1 gets very slow, even for small password stores!
-match_line_pattern='^url: .*' # applied using grep -iE
-user_pattern='^(user|username|login): '
-
-GPG_OPTS=( "--quiet" "--yes" "--compress-algo=none" "--no-encrypt-to" )
-GPG="gpg"
-export GPG_TTY="${GPG_TTY:-$(tty 2>/dev/null)}"
-command -v gpg2 &>/dev/null && GPG="gpg2"
-[[ -n $GPG_AGENT_INFO || $GPG == "gpg2" ]] && GPG_OPTS+=( "--batch" "--use-agent" )
-
-pass_backend() {
-    init() {
-        PREFIX="${PASSWORD_STORE_DIR:-$HOME/.password-store}"
-        if ! [ -d "$PREFIX" ] ; then
-            die "Can not open password store dir »$PREFIX«"
-        fi
-    }
-    query_entries() {
-        local url="$1"
-
-        if ((match_line)) ; then
-            # add entries with matching URL-tag
-            while read -r -d "" passfile ; do
-                if $GPG "${GPG_OPTS[@]}" -d "$passfile" \
-                     | grep --max-count=1 -iE "${match_line_pattern}${url}" > /dev/null
-                then
-                    passfile="${passfile#$PREFIX}"
-                    passfile="${passfile#/}"
-                    files+=( "${passfile%.gpg}" )
-                fi
-            done < <(find -L "$PREFIX" -iname '*.gpg' -print0)
-        fi
-        if ((match_filename)) ; then
-            # add entries with matching filepath
-            while read -r passfile ; do
-                passfile="${passfile#$PREFIX}"
-                passfile="${passfile#/}"
-                files+=( "${passfile%.gpg}" )
-            done < <(find -L "$PREFIX" -iname '*.gpg' | grep "$url")
-        fi
-    }
-    open_entry() {
-        local path="$PREFIX/${1}.gpg"
-        password=""
-        local firstline=1
-        while read -r line ; do
-            if ((firstline)) ; then
-                password="$line"
-                firstline=0
-            else
-                if [[ $line =~ $user_pattern ]] ; then
-                    # remove the matching prefix "user: " from the beginning of the line
-                    username=${line#${BASH_REMATCH[0]}}
-                    break
-                fi
-            fi
-        done < <($GPG "${GPG_OPTS[@]}" -d "$path" )
-    }
-}
-# =======================================================
-
-# =======================================================
-# backend: secret
-secret_backend() {
-    init() {
-        return
-    }
-    query_entries() {
-        local domain="$1"
-        while read -r line ; do
-            if [[ "$line" == "attribute.username = "* ]] ; then
-                files+=("$domain ${line:21}")
-            fi
-        done < <( secret-tool search --unlock --all domain "$domain" 2>&1 )
-    }
-    open_entry() {
-        local domain="${1%% *}"
-        username="${1#* }"
-        password=$(secret-tool lookup domain "$domain" username "$username")
-    }
-}
-# =======================================================
-
-# load some sane default backend
-reset_backend
-pass_backend
-# load configuration
-QUTE_CONFIG_DIR=${QUTE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/qutebrowser/}
-PWFILL_CONFIG=${PWFILL_CONFIG:-${QUTE_CONFIG_DIR}/password_fill_rc}
-if [ -f "$PWFILL_CONFIG" ] ; then
-    # shellcheck source=/dev/null
-    source "$PWFILL_CONFIG"
-fi
-init
-
-simplify_url "$QUTE_URL"
-query_entries "${simple_url}"
-no_entries_found
-# remove duplicates
-mapfile -t files < <(printf '%s\n' "${files[@]}" | sort | uniq )
-choose_entry
-if [ -z "$file" ] ; then
-    # choose_entry didn't want any of these entries
-    exit 0
-fi
-open_entry "$file"
-#username="$(date)"
-#password="XYZ"
-#msg "$username, ${#password}"
-
-[ -n "$username" ] || die "Username not set in entry $file"
-[ -n "$password" ] || die "Password not set in entry $file"
-
-js() {
-cat <<EOF
-    function isVisible(elem) {
-        var style = elem.ownerDocument.defaultView.getComputedStyle(elem, null);
-
-        if (style.getPropertyValue("visibility") !== "visible" ||
-            style.getPropertyValue("display") === "none" ||
-            style.getPropertyValue("opacity") === "0") {
-            return false;
-        }
-
-        return elem.offsetWidth > 0 && elem.offsetHeight > 0;
-    };
-    function hasPasswordField(form) {
-        var inputs = form.getElementsByTagName("input");
-        for (var j = 0; j < inputs.length; j++) {
-            var input = inputs[j];
-            if (input.type == "password") {
-                return true;
-            }
-        }
-        return false;
-    };
-    function loadData2Form (form) {
-        var inputs = form.getElementsByTagName("input");
-        for (var j = 0; j < inputs.length; j++) {
-            var input = inputs[j];
-            if (isVisible(input) && (input.type == "text" || input.type == "email")) {
-                input.focus();
-                input.value = "$(javascript_escape "${username}")";
-                input.blur();
-            }
-            if (input.type == "password") {
-                input.focus();
-                input.value = "$(javascript_escape "${password}")";
-                input.blur();
-            }
-        }
-    };
-
-    var forms = document.getElementsByTagName("form");
-    for (i = 0; i < forms.length; i++) {
-        if (hasPasswordField(forms[i])) {
-            loadData2Form(forms[i]);
-        }
-    }
-EOF
-}
-
-printjs() {
-    js | sed 's,//.*$,,' | tr '\n' ' '
-}
-echo "jseval -q $(printjs)" >> "$QUTE_FIFO"
--- a/misc/userscripts/qute-keepass
+++ b/misc/userscripts/qute-keepass
@@ -1,261 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2018 Jay Kamat <jaygkamat@gmail.com>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-"""This userscript allows for insertion of usernames and passwords from keepass
-databases using pykeepass. Since it is a userscript, it must be run from
-qutebrowser.
-
-A sample invocation of this script is:
-
-:spawn --userscript qute-keepass -p ~/KeePassFiles/MainDatabase.kdbx
-
-And a sample binding
-
-:bind --mode=insert <ctrl-i> spawn --userscript qute-keepass -p ~/KeePassFiles/MainDatabase.kdbx
-
-p or --path is a required argument.
-
--keyfile-path allows you to specify a keepass keyfile. If you only use a
-keyfile, also add --no-password as well. Specifying --no-password without
--keyfile-path will lead to an error.
-
-login information is inserted using :insert-text and :fake-key <Tab>, which
-means you must have a cursor in position before initiating this userscript. If
-you do not do this, you will get 'element not editable' errors.
-
-If keepass takes a while to open the DB, you might want to consider reducing
-the number of transform rounds in your database settings.
-
-Dependencies: pykeepass (in python3), PyQt5. Without pykeepass, you will get an
-exit code of 100.
-
-********************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!******************
-
-WARNING: The login details are viewable as plaintext in qutebrowser's debug log
-(qute://log) and could be compromised if you decide to submit a crash report!
-
-********************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!******************
-
-"""
-
-# pylint: disable=bad-builtin
-
-import argparse
-import enum
-import functools
-import os
-import shlex
-import subprocess
-import sys
-
-from PyQt5.QtCore import QUrl
-from PyQt5.QtWidgets import QApplication, QInputDialog, QLineEdit
-
-try:
-    import pykeepass
-except ImportError as e:
-    print("pykeepass not found: {}".format(str(e)), file=sys.stderr)
-
-    # Since this is a common error, try to print it to the FIFO if we can.
-    if 'QUTE_FIFO' in os.environ:
-        with open(os.environ['QUTE_FIFO'], 'w') as fifo:
-            fifo.write('message-error "pykeepass failed to be imported."\n')
-            fifo.flush()
-    sys.exit(100)
-
-argument_parser = argparse.ArgumentParser(
-    description="Fill passwords using keepass.",
-    formatter_class=argparse.RawDescriptionHelpFormatter,
-    epilog=__doc__)
-argument_parser.add_argument('url', nargs='?', default=os.getenv('QUTE_URL'))
-argument_parser.add_argument('--path', '-p', required=True,
-                             help='Path to the keepass db.')
-argument_parser.add_argument('--keyfile-path', '-k', default=None,
-                             help='Path to a keepass keyfile')
-argument_parser.add_argument(
-    '--no-password', action='store_true',
-    help='Supply if no password is required to unlock this database. '
-    'Only allowed with --keyfile-path')
-argument_parser.add_argument(
-    '--dmenu-invocation', '-d', default='dmenu',
-    help='Invocation used to execute a dmenu-provider')
-argument_parser.add_argument(
-    '--dmenu-format', '-f', default='{title}: {username}',
-    help='Format string for keys to display in dmenu.'
-    ' Must generate a unique string.')
-argument_parser.add_argument(
-    '--no-insert-mode', '-n', dest='insert_mode', action='store_false',
-    help="Don't automatically enter insert mode")
-argument_parser.add_argument(
-    '--io-encoding', '-i', default='UTF-8',
-    help='Encoding used to communicate with subprocesses')
-group = argument_parser.add_mutually_exclusive_group()
-group.add_argument('--username-fill-only', '-e',
-                   action='store_true', help='Only insert username')
-group.add_argument('--password-fill-only', '-w',
-                   action='store_true', help='Only insert password')
-
-CMD_DELAY = 50
-
-
-class ExitCodes(enum.IntEnum):
-    """Stores various exit codes groups to use."""
-    SUCCESS = 0
-    FAILURE = 1
-    # 1 is automatically used if Python throws an exception
-    NO_CANDIDATES = 2
-    USER_QUIT = 3
-    DB_OPEN_FAIL = 4
-
-    INTERNAL_ERROR = 10
-
-
-def qute_command(command):
-    with open(os.environ['QUTE_FIFO'], 'w') as fifo:
-        fifo.write(command + '\n')
-        fifo.flush()
-
-
-def stderr(to_print):
-    """Extra functionality to echo out errors to qb ui."""
-    print(to_print, file=sys.stderr)
-    qute_command('message-error "{}"'.format(to_print))
-
-
-def dmenu(items, invocation, encoding):
-    """Runs dmenu with given arguments."""
-    command = shlex.split(invocation)
-    process = subprocess.run(command, input='\n'.join(items).encode(encoding),
-                             stdout=subprocess.PIPE)
-    return process.stdout.decode(encoding).strip()
-
-
-def get_password():
-    """Get a keepass db password from user."""
-    _app = QApplication(sys.argv)
-    text, ok = QInputDialog.getText(
-        None, "KeePass DB Password",
-        "Please enter your KeePass Master Password",
-        QLineEdit.Password)
-    if not ok:
-        stderr('Password Prompt Rejected.')
-        sys.exit(ExitCodes.USER_QUIT)
-    return text
-
-
-def find_candidates(args, host):
-    """Finds candidates that match host"""
-    file_path = os.path.expanduser(args.path)
-
-    # TODO find a way to keep the db open, so we don't open (and query
-    # password) it every time
-
-    pw = None
-    if not args.no_password:
-        pw = get_password()
-
-    kf = args.keyfile_path
-    if kf:
-        kf = os.path.expanduser(kf)
-
-    try:
-        kp = pykeepass.PyKeePass(file_path, password=pw, keyfile=kf)
-    except Exception as e:
-        stderr("There was an error opening the DB: {}".format(str(e)))
-
-    return kp.find_entries(url="{}{}{}".format(".*", host, ".*"), regex=True)
-
-
-def candidate_to_str(args, candidate):
-    """Turns candidate into a human readable string for dmenu"""
-    return args.dmenu_format.format(title=candidate.title,
-                                    url=candidate.url,
-                                    username=candidate.username,
-                                    path=candidate.path,
-                                    uuid=candidate.uuid)
-
-
-def candidate_to_secret(candidate):
-    """Turns candidate into a generic (user, password) tuple"""
-    return (candidate.username, candidate.password)
-
-
-def run(args):
-    """Runs qute-keepass"""
-    if not args.url:
-        argument_parser.print_help()
-        return ExitCodes.FAILURE
-
-    url_host = QUrl(args.url).host()
-
-    if not url_host:
-        stderr('{} was not parsed as a valid URL!'.format(args.url))
-        return ExitCodes.INTERNAL_ERROR
-
-    # Find candidates matching the host of the given URL
-    candidates = find_candidates(args, url_host)
-    if not candidates:
-        stderr('No candidates for URL {!r} found!'.format(args.url))
-        return ExitCodes.NO_CANDIDATES
-
-    # Create a map so we can get turn the resulting string from dmenu back into
-    # a candidate
-    candidates_strs = list(map(functools.partial(candidate_to_str, args),
-                               candidates))
-    candidates_map = dict(zip(candidates_strs, candidates))
-
-    if len(candidates) == 1:
-        selection = candidates.pop()
-    else:
-        selection = dmenu(candidates_strs,
-                          args.dmenu_invocation,
-                          args.io_encoding)
-
-        if selection not in candidates_map:
-            stderr("'{}' was not a valid entry!").format(selection)
-            return ExitCodes.USER_QUIT
-
-        selection = candidates_map[selection]
-
-    username, password = candidate_to_secret(selection)
-
-    insert_mode = ';; enter-mode insert' if args.insert_mode else ''
-    if args.username_fill_only:
-        qute_command('insert-text {}{}'.format(username, insert_mode))
-    elif args.password_fill_only:
-        qute_command('insert-text {}{}'.format(password, insert_mode))
-    else:
-        # Enter username and password using insert-key and fake-key <Tab>
-        # (which supports more passwords than fake-key only), then switch back
-        # into insert-mode, so the form can be directly submitted by hitting
-        # enter afterwards. It dosen't matter when we go into insert mode, but
-        # the other commands need to be be executed sequentially, so we add
-        # delays with later.
-        qute_command('insert-text {} ;;'
-                     'later {} fake-key <Tab> ;;'
-                     'later {} insert-text {}{}'
-                     .format(username, CMD_DELAY,
-                             CMD_DELAY * 2, password, insert_mode))
-
-    return ExitCodes.SUCCESS
-
-
-if __name__ == '__main__':
-    arguments = argument_parser.parse_args()
-    sys.exit(run(arguments))
--- a/misc/userscripts/qute-lastpass
+++ b/misc/userscripts/qute-lastpass
@@ -1,172 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2017 Chris Braun (cryzed) <cryzed@googlemail.com>
-# Adapted for LastPass by Wayne Cheng (welps) <waynethecheng@gmail.com>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published bjy
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Insert login information using lastpass CLI and a dmenu-compatible application (e.g. dmenu, rofi -dmenu, ...). 
-A short demonstration can be seen here: https://i.imgur.com/zA61NrF.gifv.
-"""
-
-USAGE = """The domain of the site has to be in the name of the LastPass entry, for example: "github.com/cryzed" or
-"websites/github.com".  The login information is inserted by emulating key events using qutebrowser's fake-key command in this manner:
-[USERNAME]<Tab>[PASSWORD], which is compatible with almost all login forms.
-
-You must log into LastPass CLI using `lpass login <email>` prior to use of this script. The LastPass CLI agent only holds your master password for an hour by default. If you wish to change this, please see `man lpass`.
-
-To use in qutebrowser, run: `spawn --userscript qute-lastpass`
-"""
-
-EPILOG = """Dependencies: tldextract (Python 3 module), LastPass CLI (1.3 or newer)
-
-WARNING: The login details are viewable as plaintext in qutebrowser's debug log (qute://log) and might be shared if
-you decide to submit a crash report!"""
-
-import argparse
-import enum
-import fnmatch
-import functools
-import os
-import re
-import shlex
-import subprocess
-import sys
-import json
-import tldextract
-
-argument_parser = argparse.ArgumentParser(
-    description=__doc__, usage=USAGE, epilog=EPILOG)
-argument_parser.add_argument('url', nargs='?', default=os.getenv('QUTE_URL'))
-argument_parser.add_argument('--dmenu-invocation', '-d', default='rofi -dmenu',
-                             help='Invocation used to execute a dmenu-provider')
-argument_parser.add_argument('--no-insert-mode', '-n', dest='insert_mode', action='store_false',
-                             help="Don't automatically enter insert mode")
-argument_parser.add_argument('--io-encoding', '-i', default='UTF-8',
-                             help='Encoding used to communicate with subprocesses')
-argument_parser.add_argument('--merge-candidates', '-m', action='store_true',
-                             help='Merge pass candidates for fully-qualified and registered domain name')
-group = argument_parser.add_mutually_exclusive_group()
-group.add_argument('--username-only', '-e',
-                   action='store_true', help='Only insert username')
-group.add_argument('--password-only', '-w',
-                   action='store_true', help='Only insert password')
-
-stderr = functools.partial(print, file=sys.stderr)
-
-class ExitCodes(enum.IntEnum):
-    SUCCESS = 0
-    FAILURE = 1
-    # 1 is automatically used if Python throws an exception
-    NO_PASS_CANDIDATES = 2
-    COULD_NOT_MATCH_USERNAME = 3
-    COULD_NOT_MATCH_PASSWORD = 4
-
-def qute_command(command):
-    with open(os.environ['QUTE_FIFO'], 'w') as fifo:
-        fifo.write(command + '\n')
-        fifo.flush()
-
-def pass_(domain, encoding):
-    args = ['lpass', 'show', '-x', '-j', '-G', '.*{:s}.*'.format(domain)]
-    process = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-    err = process.stderr.decode(encoding).strip()
-    if err:
-        msg = "LastPass CLI returned for {:s} - {:s}".format(domain, err)
-        stderr(msg)
-        return '[]'
-
-    out = process.stdout.decode(encoding).strip()
-
-    return out
-
-def dmenu(items, invocation, encoding):
-    command = shlex.split(invocation)
-    process = subprocess.run(command, input='\n'.join(
-        items).encode(encoding), stdout=subprocess.PIPE)
-    return process.stdout.decode(encoding).strip()
-
-
-def fake_key_raw(text):
-    for character in text:
-        # Escape all characters by default, space requires special handling
-        sequence = '" "' if character == ' ' else '\{}'.format(character)
-        qute_command('fake-key {}'.format(sequence))
-
-
-def main(arguments):
-    if not arguments.url:
-        argument_parser.print_help()
-        return ExitCodes.FAILURE
-
-    extract_result = tldextract.extract(arguments.url)
-
-    # Try to find candidates using targets in the following order: fully-qualified domain name (includes subdomains),
-    # the registered domain name and finally: the IPv4 address if that's what
-    # the URL represents
-    candidates = []
-    for target in filter(None, [extract_result.fqdn, extract_result.registered_domain, extract_result.subdomain + extract_result.domain, extract_result.domain, extract_result.ipv4]):
-        target_candidates = json.loads(pass_(target, arguments.io_encoding))
-        if not target_candidates:
-            continue
-
-        candidates = candidates + target_candidates
-        if not arguments.merge_candidates:
-            break
-    else:
-        if not candidates:
-            stderr('No pass candidates for URL {!r} found!'.format(
-                arguments.url))
-            return ExitCodes.NO_PASS_CANDIDATES
-
-    if len(candidates) == 1:
-        selection = candidates.pop()
-    else:
-        choices = ["{:s} | {:s} | {:s} | {:s}".format(c["id"], c["name"], c["url"], c["username"]) for c in candidates]
-        choice = dmenu(choices, arguments.dmenu_invocation, arguments.io_encoding)
-        choiceId = choice.split("|")[0].strip()
-        selection = next((c for (i, c) in enumerate(candidates) if c["id"] == choiceId), None)
-
-    # Nothing was selected, simply return
-    if not selection:
-        return ExitCodes.SUCCESS
-
-    username = selection["username"]
-    password = selection["password"]
-
-    if arguments.username_only:
-        fake_key_raw(username)
-    elif arguments.password_only:
-        fake_key_raw(password)
-    else:
-        # Enter username and password using fake-key and <Tab> (which seems to work almost universally), then switch
-        # back into insert-mode, so the form can be directly submitted by
-        # hitting enter afterwards
-        fake_key_raw(username)
-        qute_command('fake-key <Tab>')
-        fake_key_raw(password)
-
-    if arguments.insert_mode:
-        qute_command('enter-mode insert')
-
-    return ExitCodes.SUCCESS
-
-
-if __name__ == '__main__':
-    arguments = argument_parser.parse_args()
-    sys.exit(main(arguments))
--- a/misc/userscripts/qute-pass
+++ b/misc/userscripts/qute-pass
@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2017 Chris Braun (cryzed) <cryzed@googlemail.com>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Insert login information using pass and a dmenu-compatible application (e.g. dmenu, rofi -dmenu, ...). A short
-demonstration can be seen here: https://i.imgur.com/KN3XuZP.gif.
-"""
-
-USAGE = """The domain of the site has to appear as a segment in the pass path, for example: "github.com/cryzed" or
-"websites/github.com". How the username and password are determined is freely configurable using the CLI arguments. The
-login information is inserted by emulating key events using qutebrowser's fake-key command in this manner:
-[USERNAME]<Tab>[PASSWORD], which is compatible with almost all login forms."""
-
-EPILOG = """Dependencies: tldextract (Python 3 module), pass.
-For issues and feedback please use: https://github.com/cryzed/qutebrowser-userscripts.
-
-WARNING: The login details are viewable as plaintext in qutebrowser's debug log (qute://log) and might be shared if
-you decide to submit a crash report!"""
-
-import argparse
-import enum
-import fnmatch
-import functools
-import os
-import re
-import shlex
-import subprocess
-import sys
-
-import tldextract
-
-argument_parser = argparse.ArgumentParser(description=__doc__, usage=USAGE, epilog=EPILOG)
-argument_parser.add_argument('url', nargs='?', default=os.getenv('QUTE_URL'))
-argument_parser.add_argument('--password-store', '-p', default=os.path.expanduser('~/.password-store'),
-                             help='Path to your pass password-store')
-argument_parser.add_argument('--username-pattern', '-u', default=r'.*/(.+)',
-                             help='Regular expression that matches the username')
-argument_parser.add_argument('--username-target', '-U', choices=['path', 'secret'], default='path',
-                             help='The target for the username regular expression')
-argument_parser.add_argument('--password-pattern', '-P', default=r'(.*)',
-                             help='Regular expression that matches the password')
-argument_parser.add_argument('--dmenu-invocation', '-d', default='rofi -dmenu',
-                             help='Invocation used to execute a dmenu-provider')
-argument_parser.add_argument('--no-insert-mode', '-n', dest='insert_mode', action='store_false',
-                             help="Don't automatically enter insert mode")
-argument_parser.add_argument('--io-encoding', '-i', default='UTF-8',
-                             help='Encoding used to communicate with subprocesses')
-argument_parser.add_argument('--merge-candidates', '-m', action='store_true',
-                             help='Merge pass candidates for fully-qualified and registered domain name')
-group = argument_parser.add_mutually_exclusive_group()
-group.add_argument('--username-only', '-e', action='store_true', help='Only insert username')
-group.add_argument('--password-only', '-w', action='store_true', help='Only insert password')
-
-stderr = functools.partial(print, file=sys.stderr)
-
-
-class ExitCodes(enum.IntEnum):
-    SUCCESS = 0
-    FAILURE = 1
-    # 1 is automatically used if Python throws an exception
-    NO_PASS_CANDIDATES = 2
-    COULD_NOT_MATCH_USERNAME = 3
-    COULD_NOT_MATCH_PASSWORD = 4
-
-
-def qute_command(command):
-    with open(os.environ['QUTE_FIFO'], 'w') as fifo:
-        fifo.write(command + '\n')
-        fifo.flush()
-
-
-def find_pass_candidates(domain, password_store_path):
-    candidates = []
-    for path, directories, file_names in os.walk(password_store_path):
-        if directories or domain not in path.split(os.path.sep):
-            continue
-
-        # Strip password store path prefix to get the relative pass path
-        pass_path = path[len(password_store_path) + 1:]
-        secrets = fnmatch.filter(file_names, '*.gpg')
-        candidates.extend(os.path.join(pass_path, os.path.splitext(secret)[0]) for secret in secrets)
-    return candidates
-
-
-def pass_(path, encoding):
-    process = subprocess.run(['pass', path], stdout=subprocess.PIPE)
-    return process.stdout.decode(encoding).strip()
-
-
-def dmenu(items, invocation, encoding):
-    command = shlex.split(invocation)
-    process = subprocess.run(command, input='\n'.join(items).encode(encoding), stdout=subprocess.PIPE)
-    return process.stdout.decode(encoding).strip()
-
-
-def fake_key_raw(text):
-    for character in text:
-        # Escape all characters by default, space requires special handling
-        sequence = '" "' if character == ' ' else '\{}'.format(character)
-        qute_command('fake-key {}'.format(sequence))
-
-
-def main(arguments):
-    if not arguments.url:
-        argument_parser.print_help()
-        return ExitCodes.FAILURE
-
-    extract_result = tldextract.extract(arguments.url)
-
-    # Expand potential ~ in paths, since this script won't be called from a shell that does it for us
-    password_store_path = os.path.expanduser(arguments.password_store)
-
-    # Try to find candidates using targets in the following order: fully-qualified domain name (includes subdomains),
-    # the registered domain name and finally: the IPv4 address if that's what the URL represents
-    candidates = set()
-    for target in filter(None, [extract_result.fqdn, extract_result.registered_domain, extract_result.ipv4]):
-        target_candidates = find_pass_candidates(target, password_store_path)
-        if not target_candidates:
-            continue
-
-        candidates.update(target_candidates)
-        if not arguments.merge_candidates:
-            break
-    else:
-        if not candidates:
-            stderr('No pass candidates for URL {!r} found!'.format(arguments.url))
-            return ExitCodes.NO_PASS_CANDIDATES
-
-    selection = candidates.pop() if len(candidates) == 1 else dmenu(sorted(candidates), arguments.dmenu_invocation,
-                                                                    arguments.io_encoding)
-    # Nothing was selected, simply return
-    if not selection:
-        return ExitCodes.SUCCESS
-
-    secret = pass_(selection, arguments.io_encoding)
-
-    # Match username
-    target = selection if arguments.username_target == 'path' else secret
-    match = re.match(arguments.username_pattern, target)
-    if not match:
-        stderr('Failed to match username pattern on {}!'.format(arguments.username_target))
-        return ExitCodes.COULD_NOT_MATCH_USERNAME
-    username = match.group(1)
-
-    # Match password
-    match = re.match(arguments.password_pattern, secret)
-    if not match:
-        stderr('Failed to match password pattern on secret!')
-        return ExitCodes.COULD_NOT_MATCH_PASSWORD
-    password = match.group(1)
-
-    if arguments.username_only:
-        fake_key_raw(username)
-    elif arguments.password_only:
-        fake_key_raw(password)
-    else:
-        # Enter username and password using fake-key and <Tab> (which seems to work almost universally), then switch
-        # back into insert-mode, so the form can be directly submitted by hitting enter afterwards
-        fake_key_raw(username)
-        qute_command('fake-key <Tab>')
-        fake_key_raw(password)
-
-    if arguments.insert_mode:
-        qute_command('enter-mode insert')
-
-    return ExitCodes.SUCCESS
-
-
-if __name__ == '__main__':
-    arguments = argument_parser.parse_args()
-    sys.exit(main(arguments))
--- a/misc/userscripts/qutedmenu
+++ b/misc/userscripts/qutedmenu
@@ -1,54 +0,0 @@
-#!/usr/bin/env bash
-# Handle open -s && open -t with bemenu
-
-#:bind o spawn --userscript /path/to/userscripts/qutedmenu open
-#:bind O spawn --userscript /path/to/userscripts/qutedmenu tab
-
-# If you would like to set a custom colorscheme/font use these dirs.
-# https://github.com/halfwit/dotfiles/blob/master/.config/dmenu/bemenucolors
-readonly confdir=${XDG_CONFIG_HOME:-$HOME/.config}
-
-readonly optsfile=$confdir/dmenu/bemenucolors
-
-create_menu() {
-    # Check quickmarks
-    while read -r url; do
-        printf -- '%s\n' "$url"
-    done < "$QUTE_CONFIG_DIR"/quickmarks
-
-    # Next bookmarks
-    while read -r url _; do
-        printf -- '%s\n' "$url"
-    done < "$QUTE_CONFIG_DIR"/bookmarks/urls
-
-    # Finally history
-    while read -r _ url; do
-        printf -- '%s\n' "$url"
-    done < "$QUTE_DATA_DIR"/history
-    }
-
-get_selection() {
-    opts+=(-p qutebrowser)
-    #create_menu | dmenu -l 10 "${opts[@]}"
-    create_menu | bemenu -l 10 "${opts[@]}"
-}
-
-# Main
-# https://github.com/halfwit/dotfiles/blob/master/.config/dmenu/font
-[[ -s $confdir/dmenu/font ]] && read -r font < "$confdir"/dmenu/font
-
-[[ $font ]] && opts+=(-fn "$font")
-
-# shellcheck source=/dev/null
-[[ -s $optsfile ]] && source "$optsfile"
-
-url=$(get_selection)
-url=${url/*http/http}
-
-# If no selection is made, exit (escape pressed, e.g.)
-[[ ! $url ]] && exit 0
-
-case $1 in
-    open) printf '%s' "open $url" >> "$QUTE_FIFO" || qutebrowser "$url" ;;
-    tab)    printf '%s' "open -t $url" >> "$QUTE_FIFO" || qutebrowser "$url"  ;;
-esac
--- a/misc/userscripts/readability
+++ b/misc/userscripts/readability
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-#
-# Executes python-readability on current page and opens the summary as new tab.
-#
-# Depends on the python-readability package, or its fork:
-#
-#   - https://github.com/buriy/python-readability
-#   - https://github.com/bookieio/breadability
-#
-# Usage:
-#   :spawn --userscript readability
-#
-from __future__ import absolute_import
-import codecs, os
-
-tmpfile = os.path.join(
-    os.environ.get('QUTE_DATA_DIR',
-                   os.path.expanduser('~/.local/share/qutebrowser')),
-    'userscripts/readability.html')
-
-if not os.path.exists(os.path.dirname(tmpfile)):
-    os.makedirs(os.path.dirname(tmpfile))
-
-with codecs.open(os.environ['QUTE_HTML'], 'r', 'utf-8') as source:
-    data = source.read()
-
-    try:
-        from breadability.readable import Article as reader
-        doc = reader(data)
-        content = doc.readable
-    except ImportError:
-        from readability import Document
-        doc = Document(data)
-        content = doc.summary().replace('<html>', '<html><head><title>%s</title></head>' % doc.title())
-
-    with codecs.open(tmpfile, 'w', 'utf-8') as target:
-        target.write('<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />')
-        target.write(content)
-
-    with open(os.environ['QUTE_FIFO'], 'w') as fifo:
-        fifo.write('open -t %s' % tmpfile)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Florian Bruhin	d9d5b2df0c	Release v0.1.2	2015-01-09 22:30:04 +01:00
Florian Bruhin	d6fd5a817e	Regenerate docs.	2015-01-09 22:28:25 +01:00
Florian Bruhin	301186d407	Use qurl_from_user_input() in urlutils.is_url(). It seems `354018efcd` broke IPv6 IPs on older Qt versions: ====================================================================== FAIL: test_urls (qutebrowser.test.utils.test_urlutils.IsUrlTests) (url='2001:41d0:2:6c11::1') Test things which are URLs. ---------------------------------------------------------------------- Traceback (most recent call last): File "/var/lib/buildbot/slaves/slave/ubuntu-utopic/build/qutebrowser/test/utils/test_urlutils.py", line 168, in test_urls self.assertTrue(urlutils.is_url(url), url) AssertionError: False is not true : 2001:41d0:2:6c11::1	2015-01-09 22:26:35 +01:00
Florian Bruhin	ab121a98da	Enter KeyMode.normal directly in ModeManager. We used to enter KeyMode.none and then with a zero-time singleShot QTimer enter the normal mode. This doesn't really make sense, and caused an exception if a keypress was processed before the timer fired. Fixes #433.	2015-01-09 22:26:35 +01:00
Florian Bruhin	a463038834	Make sure QUrl::fromUserInput is valid in is_url. Fixes #460. Without this fix, it's possible for URLs to be valid according to is_url, but not according to QUrl::fromUserInput, e.g. "http:foo:0". This caused an exception later because fuzzy_url runs qtutils.ensure_valid.	2015-01-09 22:26:35 +01:00
Florian Bruhin	22761b4373	Switch Qt style to Fusion on OS X on Qt 5.4. Fixes #462. See #459. Upstream bugs: https://bugreports.qt.io/browse/QTBUG-42948 https://bugreports.qt.io/browse/QTBUG-43070	2015-01-09 19:27:44 +01:00
Florian Bruhin	78f6f3a0e1	Fix error handling for local files in :adblock-update	2015-01-09 07:17:47 +01:00
Florian Bruhin	6166ea51e2	Hide 2 more Qt warnings.	2015-01-09 07:17:47 +01:00
Florian Bruhin	4d4065dfac	Add !important to all hint properties.	2015-01-09 07:17:47 +01:00
Error 800	81f350ee99	Added !important to hint styles Prevents websites from overriding hint styles	2015-01-09 07:16:44 +01:00
Florian Bruhin	4b98e6e9ce	Make init_venv.py work with multiple sip .so files. On my Debian jessie there's a sip.cpython-34m-x86_64-linux-gnu.so and a sip.cpython-34dm-x86_64-linux-gnu.so.	2015-01-09 07:16:44 +01:00
Florian Bruhin	11f8ab1f85	Fix maxsplit-splitting with empty args (""/''). Fixes #453.	2015-01-09 07:16:44 +01:00
Florian Bruhin	0449da048f	Uncheck sending of debug log with private browsing. Fixes #436.	2015-01-09 07:16:44 +01:00
Error 800	c78e938dea	Added !important to hint styles Prevents websites from overriding hint styles	2015-01-09 07:16:44 +01:00
Error 800	99fb8a5d87	Fixed uppercase hints option Corrected CSS property from 'texttransform' to 'text-transform'	2015-01-09 07:16:44 +01:00
Matthias Lisin	b1e0b8f119	Commas are awesome Fixes #438 Fixes #439	2015-01-09 07:16:43 +01:00
Florian Bruhin	8d49e001e9	Abort blocking questions when new page is loaded. Fixes #430. Fixes #431. Hopefully fixes #354. Hopefully fixes #434. Conflicts: qutebrowser/browser/network/networkmanager.py	2015-01-09 07:16:32 +01:00
Florian Bruhin	965c176acf	Fix validation of ShellCommand config type. Fixes #432.	2015-01-09 07:15:44 +01:00
Florian Bruhin	896da1c27e	Add SSL info to version info.	2015-01-09 07:15:44 +01:00
Florian Bruhin	8f33fcfc52	Replace unencodable chars in download filenames. Fixes #427.	2015-01-09 07:15:44 +01:00
Florian Bruhin	91b0a33ab0	Update copyright years	2015-01-09 07:15:43 +01:00
Florian Bruhin	b059f4058f	Remove hosts-file.net from blocker default lists.	2015-01-09 07:15:43 +01:00
Florian Bruhin	b63ce438b4	Fix user-stylesheet setting with an empty value.	2015-01-09 07:15:43 +01:00