Merge branch 'master' into staging

doc/manual.xml

···
   <xi:include href="functions.xml" />
   <xi:include href="meta.xml" />
   <xi:include href="languages-frameworks/index.xml" />
+  <xi:include href="platform-notes.xml" />
   <xi:include href="package-notes.xml" />
   <xi:include href="overlays.xml" />
   <xi:include href="coding-conventions.xml" />

doc/platform-notes.xml

···
+<chapter xmlns="http://docbook.org/ns/docbook"
+         xmlns:xlink="http://www.w3.org/1999/xlink"
+         xml:id="chap-platform-nodes">
+
+<title>Platform Notes</title>
+
+<section xml:id="sec-darwin">
+
+<title>Darwin (macOS)</title>
+<para>Some common issues when packaging software for darwin:</para>
+
+<itemizedlist>
+
+  <listitem>
+    <para>
+      The darwin <literal>stdenv</literal> uses clang instead of gcc.
+      When referring to the compiler <varname>$CC</varname> or <command>cc</command>
+      will work in both cases.  Some builds hardcode gcc/g++ in their
+      build scripts, that can usually be fixed with using something
+      like <literal>makeFlags = [ "CC=cc" ];</literal> or by patching
+      the build scripts.
+    </para>
+
+    <programlisting>
+      stdenv.mkDerivation {
+        name = "libfoo-1.2.3";
+        # ...
+        buildPhase = ''
+          $CC -o hello hello.c
+        '';
+      }
+    </programlisting>
+  </listitem>
+
+  <listitem>
+    <para>
+      On darwin libraries are linked using absolute paths, libraries
+      are resolved by their <literal>install_name</literal> at link
+      time.  Sometimes packages won't set this correctly causing the
+      library lookups to fail at runtime.  This can be fixed by adding
+      extra linker flags or by running <command>install_name_tool -id</command>
+      during the <function>fixupPhase</function>.
+    </para>
+
+    <programlisting>
+      stdenv.mkDerivation {
+        name = "libfoo-1.2.3";
+        # ...
+        makeFlags = stdenv.lib.optional stdenv.isDarwin "LDFLAGS=-Wl,-install_name,$(out)/lib/libfoo.dylib";
+      }
+    </programlisting>
+  </listitem>
+
+  <listitem>
+    <para>
+      Some packages assume xcode is available and use <command>xcrun</command>
+      to resolve build tools like <command>clang</command>, etc.
+      This causes errors like <code>xcode-select: error: no developer tools were found at '/Applications/Xcode.app'</code>
+      while the build doesn't actually depend on xcode.
+    </para>
+
+    <programlisting>
+      stdenv.mkDerivation {
+        name = "libfoo-1.2.3";
+        # ...
+        prePatch = ''
+          substituteInPlace Makefile \
+              --replace '/usr/bin/xcrun clang' clang
+        '';
+      }
+    </programlisting>
+
+    <para>
+      The package <literal>xcbuild</literal> can be used to build projects
+      that really depend on Xcode, however projects that build some kind of
+      graphical interface won't work without using Xcode in an impure way.
+    </para>
+  </listitem>
+
+</itemizedlist>
+</section>
+
+</chapter>

lib/maintainers.nix

···
   aneeshusa = "Aneesh Agrawal <[e-mail]>";
   ankhers = "Justin Wood <[e-mail]>";
   antono = "Antono Vasiljev <[e-mail]>";
+  antonxy = "Anton Schirg <[e-mail]>";
   apeschar = "Albert Peschar <[e-mail]>";
   apeyroux = "Alexandre Peyroux <[e-mail]>";
   ardumont = "Antoine R. Dumont <[e-mail]>";
···
   bramd = "Bram Duvigneau <[e-mail]>";
   bstrik = "Berno Strik <[e-mail]>";
   bzizou = "Bruno Bzeznik <[e-mail]>";
+  c0bw3b = "Renaud <[e-mail]>";
   c0dehero = "CodeHero <[e-mail]>";
   calbrecht = "Christian Albrecht <[e-mail]>";
   calrama = "Moritz Maxeiner <[e-mail]>";
···
   KibaFox = "Kiba Fox <[e-mail]>";
   kierdavis = "Kier Davis <[e-mail]>";
   kiloreux = "Kiloreux Emperex <[e-mail]>";
+  kini = "Keshav Kini <[e-mail]>";
   kkallio = "Karn Kallio <[e-mail]>";
   knedlsepp = "Josef Kemetmüller <[e-mail]>";
   konimex = "Muhammad Herdiansyah <[e-mail]>";
···
   schristo = "Scott Christopher <[e-mail]>";
   scolobb = "Sergiu Ivanov <[e-mail]>";
   sdll = "Sasha Illarionov <[e-mail]>";
+  SeanZicari = "Sean Zicari <[e-mail]>";
   sepi = "Raffael Mancini <[e-mail]>";
   seppeljordan = "Sebastian Jordan <[e-mail]>";
   shanemikel = "Shane Pearlman <[e-mail]>";
···
   ThomasMader = "Thomas Mader <[e-mail]>";
   thoughtpolice = "Austin Seipp <[e-mail]>";
   timbertson = "Tim Cuthbertson <[e-mail]>";
+  timokau = "Timo Kaufmann <[e-mail]>";
   titanous = "Jonathan Rudenberg <[e-mail]>";
   tnias = "Philipp Bartsch <[e-mail]>";
   tohl = "Tomas Hlavaty <[e-mail]>";

lib/modules.nix

···
     # Type-check the remaining definitions, and merge them.
     mergedValue = foldl' (res: def:
       if type.check def.value then res
-      else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.description}.")
+      else throw "The option value `${showOption loc}' in `${def.file}' is not of type `${type.description}'.")
       (type.merge loc defsFinal) defsFinal;
 
     isDefined = defsFinal != [];

lib/systems/platforms.nix

···
 rec {
   pcBase = {
     name = "pc";
-    uboot = null;
     kernelHeadersBaseConfig = "defconfig";
     kernelBaseConfig = "defconfig";
     # Build whatever possible as a module, if not stated in the extra config.
···
     kernelTarget = "uImage";
     # TODO reenable once manual-config's config actually builds a .dtb and this is checked to be working
     #kernelDTB = true;
-
-    # XXX can be anything non-null, pkgs actually only cares if it is set or not
-    uboot = "pogoplug4";
   };
 
   sheevaplug = {
···
     '';
     kernelMakeFlags = [ "LOADADDR=0x0200000" ];
     kernelTarget = "uImage";
-    uboot = "sheevaplug";
-    # Only for uboot = uboot :
-    ubootConfig = "sheevaplug_config";
     kernelDTB = true; # Beyond 3.10
     gcc = {
       arch = "armv5te";
···
       LATENCYTOP y
     '';
     kernelTarget = "zImage";
-    uboot = null;
     gcc = {
       arch = "armv6";
       fpu = "vfp";
···
       XEN? n
     '';
     kernelTarget = "zImage";
-    uboot = null;
   };
 
   scaleway-c1 = armv7l-hf-multiplatform // {
···
     kernelMakeFlags = [ "LOADADDR=0x10800000" ];
     kernelTarget = "uImage";
     kernelDTB = true;
-    uboot = true; #XXX: any non-null value here is needed so that mkimage is present to build kernelTarget uImage
     gcc = {
       cpu = "cortex-a9";
       fpu = "neon";
···
       FTRACE n
     '';
     kernelTarget = "vmlinux";
-    uboot = null;
     gcc = {
       arch = "loongson2f";
       abi = "n32";
···
     kernelAutoModules = false;
     kernelExtraConfig = ""; # TBD kernel config
     kernelTarget = "zImage";
-    uboot = null;
   };
 
   armv7l-hf-multiplatform = {
···
     kernelDTB = true;
     kernelAutoModules = true;
     kernelPreferBuiltin = true;
-    uboot = null;
     kernelTarget = "zImage";
     kernelExtraConfig = ''
       # Fix broken sunxi-sid nvmem driver.
···
       # which our initrd builder can't currently do easily.
       USB_XHCI_TEGRA m
     '';
-    uboot = null;
     kernelTarget = "Image";
     gcc = {
       arch = "armv8-a";

lib/tests/modules.sh

···
 checkConfigOutput "false" config.enable ./declare-enable.nix
 checkConfigError 'The option .* defined in .* does not exist.' config.enable ./define-enable.nix
 
+# Check integer types.
+# unsigned
+checkConfigOutput "42" config.value ./declare-int-unsigned-value.nix ./define-value-int-positive.nix
+checkConfigError 'The option value .* in .* is not of type.*unsigned integer.*' config.value ./declare-int-unsigned-value.nix ./define-value-int-negative.nix
+# positive
+checkConfigError 'The option value .* in .* is not of type.*positive integer.*' config.value ./declare-int-positive-value.nix ./define-value-int-zero.nix
+# between
+checkConfigOutput "42" config.value ./declare-int-between-value.nix ./define-value-int-positive.nix
+checkConfigError 'The option value .* in .* is not of type.*between.*-21 and 43.*inclusive.*' config.value ./declare-int-between-value.nix ./define-value-int-negative.nix
+
 # Check mkForce without submodules.
 set -- config.enable ./declare-enable.nix ./define-enable.nix
 checkConfigOutput "true" "$@"
···
 # Check coerced value.
 checkConfigOutput "\"42\"" config.value ./declare-coerced-value.nix
 checkConfigOutput "\"24\"" config.value ./declare-coerced-value.nix ./define-value-string.nix
-checkConfigError 'The option value .* in .* is not a string or integer.' config.value ./declare-coerced-value.nix ./define-value-list.nix
+checkConfigError 'The option value .* in .* is not.*string or signed integer.*' config.value ./declare-coerced-value.nix ./define-value-list.nix
 
 cat <<EOF
 ====== module tests ======

lib/tests/modules/declare-int-between-value.nix

···
+{ lib, ... }:
+
+{
+  options = {
+    value = lib.mkOption {
+      type = lib.types.ints.between (-21) 43;
+    };
+  };
+}

lib/tests/modules/declare-int-positive-value.nix

···
+{ lib, ... }:
+
+{
+  options = {
+    value = lib.mkOption {
+      type = lib.types.ints.positive;
+    };
+  };
+}

lib/tests/modules/declare-int-unsigned-value.nix

···
+{ lib, ... }:
+
+{
+  options = {
+    value = lib.mkOption {
+      type = lib.types.ints.unsigned;
+    };
+  };
+}

lib/tests/modules/define-value-int-negative.nix

···
+{
+  value = -23;
+}

lib/tests/modules/define-value-int-positive.nix

···
+{
+  value = 42;
+}

lib/tests/modules/define-value-int-zero.nix

···
+{
+  value = 0;
+}

lib/types.nix

···
     };
 
     int = mkOptionType rec {
-      name = "int";
-      description = "integer";
-      check = isInt;
-      merge = mergeOneOption;
-    };
+        name = "int";
+        description = "signed integer";
+        check = isInt;
+        merge = mergeOneOption;
+      };
+
+    # Specialized subdomains of int
+    ints =
+      let
+        betweenDesc = lowest: highest:
+          "${toString lowest} and ${toString highest} (both inclusive)";
+        between = lowest: highest: assert lowest <= highest;
+          addCheck int (x: x >= lowest && x <= highest) // {
+            name = "intBetween";
+            description = "integer between ${betweenDesc lowest highest}";
+          };
+        ign = lowest: highest: name: docStart:
+          between lowest highest // {
+            inherit name;
+            description = docStart + "; between ${betweenDesc lowest highest}";
+          };
+        unsign = bit: range: ign 0 (range - 1)
+          "unsignedInt${toString bit}" "${toString bit} bit unsigned integer";
+        sign = bit: range: ign (0 - (range / 2)) (range / 2 - 1)
+          "signedInt${toString bit}" "${toString bit} bit signed integer";
+
+      in rec {
+        /* An int with a fixed range.
+        *
+        * Example:
+        *   (ints.between 0 100).check (-1)
+        *   => false
+        *   (ints.between 0 100).check (101)
+        *   => false
+        *   (ints.between 0 0).check 0
+        *   => true
+        */
+        inherit between;
+
+        unsigned = addCheck types.int (x: x >= 0) // {
+          name = "unsignedInt";
+          description = "unsigned integer, meaning >=0";
+        };
+        positive = addCheck types.int (x: x > 0) // {
+          name = "positiveInt";
+          description = "positive integer, meaning >0";
+        };
+        u8 = unsign 8 256;
+        u16 = unsign 16 65536;
+        # the biggest int a 64-bit Nix accepts is 2^63 - 1 (9223372036854775808), for a 32-bit Nix it is 2^31 - 1 (2147483647)
+        # the smallest int a 64-bit Nix accepts is -2^63 (-9223372036854775807), for a 32-bit Nix it is -2^31 (-2147483648)
+        # u32 = unsign 32 4294967296;
+        # u64 = unsign 64 18446744073709551616;
+
+        s8 = sign 8 256;
+        s16 = sign 16 65536;
+        # s32 = sign 32 4294967296;
+      };
 
     str = mkOptionType {
       name = "str";
···
     };
 
     # drop this in the future:
-    list = builtins.trace "`types.list' is deprecated; use `types.listOf' instead" types.listOf;
+    list = builtins.trace "`types.list` is deprecated; use `types.listOf` instead" types.listOf;
 
     listOf = elemType: mkOptionType rec {
       name = "listOf";
···
               ).optionalValue
             ) def.value
           else
-            throw "The option value `${showOption loc}' in `${def.file}' is not a list.") defs)));
+            throw "The option value `${showOption loc}` in `${def.file}` is not a list.") defs)));
       getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
       getSubModules = elemType.getSubModules;
       substSubModules = m: listOf (elemType.substSubModules m);
···
         let nrNulls = count (def: def.value == null) defs; in
         if nrNulls == length defs then null
         else if nrNulls != 0 then
-          throw "The option `${showOption loc}' is defined both null and not null, in ${showFiles (getFiles defs)}."
+          throw "The option `${showOption loc}` is defined both null and not null, in ${showFiles (getFiles defs)}."
         else elemType.merge loc defs;
       getSubOptions = elemType.getSubOptions;
       getSubModules = elemType.getSubModules;

maintainers/scripts/update-python-libraries

···
 import re
 import requests
 import toolz
+from concurrent.futures import ThreadPoolExecutor as pool
 
 INDEX = "https://pypi.io/pypi"
 """url of PyPI"""
···
 
     packages = map(os.path.abspath, args.package)
 
-    count = list(map(_update, packages))
+    with pool() as p:
+        count = list(p.map(_update, packages))
 
     logging.info("{} package(s) updated".format(sum(count)))
 

nixos/doc/manual/development/option-types.xml

···
         <literal>false</literal>.</para></listitem>
   </varlistentry>
   <varlistentry>
-    <term><varname>types.int</varname></term>
-    <listitem><para>An integer.</para></listitem>
-  </varlistentry>
-  <varlistentry>
     <term><varname>types.path</varname></term>
     <listitem><para>A filesystem path, defined as anything that when coerced to 
         a string starts with a slash. Even if derivations can be considered as 
···
   </varlistentry>
 </variablelist>
 
-<para>String related types:</para>
+<para>Integer-related types:</para>
+
+<variablelist>
+  <varlistentry>
+    <term><varname>types.int</varname></term>
+    <listitem><para>A signed integer.</para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>
+      <varname>types.ints.{s8, s16, s32}</varname>
+    </term>
+    <listitem>
+      <para>Signed integers with a fixed length (8, 16 or 32 bits).
+        They go from
+        <inlineequation><mathphrase>−2<superscript>n</superscript>/2</mathphrase>
+        </inlineequation> to <inlineequation>
+        <mathphrase>2<superscript>n</superscript>/2−1</mathphrase>
+        </inlineequation>
+        respectively (e.g. <literal>−128</literal> to <literal>127</literal>
+        for 8 bits).
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>
+      <varname>types.ints.unsigned</varname>
+    </term>
+    <listitem><para>An unsigned integer (that is >= 0).
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>
+      <varname>types.ints.{u8, u16, u32}</varname>
+    </term>
+    <listitem>
+      <para>Unsigned integers with a fixed length (8, 16 or 32 bits).
+        They go from
+        <inlineequation><mathphrase>0</mathphrase></inlineequation> to <inlineequation>
+        <mathphrase>2<superscript>n</superscript>−1</mathphrase>
+        </inlineequation>
+        respectively (e.g. <literal>0</literal> to <literal>255</literal>
+        for 8 bits).
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>
+      <varname>types.ints.positive</varname>
+    </term>
+    <listitem><para>A positive integer (that is > 0).
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+
+<para>String-related types:</para>
 
 <variablelist>
   <varlistentry>
···
 
  <section><title>Value Types</title>
 
-   <para>Value types are type that take a value parameter.</para>
+   <para>Value types are types that take a value parameter.</para>
 
 <variablelist>
   <varlistentry>
···
     <listitem><para>A string with a custom separator
         <replaceable>sep</replaceable>, e.g. <literal>types.separatedString
           "|"</literal>.</para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>
+      <varname>types.ints.between</varname>
+      <replaceable>lowest</replaceable>
+      <replaceable>highest</replaceable>
+    </term>
+    <listitem><para>An integer between <replaceable>lowest</replaceable>
+        and <replaceable>highest</replaceable> (both inclusive).
+        Useful for creating types like <literal>types.port</literal>.
+    </para></listitem>
   </varlistentry>
   <varlistentry>
     <term><varname>types.submodule</varname> <replaceable>o</replaceable></term>

nixos/doc/manual/release-notes/rl-1803.xml

···
       That means that old configuration is not overwritten by default when update to the znc options are made.
     </para>
   </listitem>
-  <listitem>
-    <para>
-      The option <option>services.xserver.desktopManager.default</option> is now <literal>none</literal> by default.
-      An assertion failure is thrown if WM's and DM's default are <literal>none</literal>.
-      To explicitly run a plain X session without and DM or WM, the newly introduced option <option>services.xserver.plainX</option>
-      must be set to true.
-    </para>
-  </listitem>
 </itemizedlist>
 
 </section>

nixos/modules/misc/ids.nix

···
       ripple-data-api = 186;
       mediatomb = 187;
       rdnssd = 188;
-      # ihaskell = 189; # unused
+      ihaskell = 189;
       i2p = 190;
       lambdabot = 191;
       asterisk = 192;
       plex = 193;
+      plexpy = 195;
       grafana = 196;
       skydns = 197;
       # ripple-rest = 198; # unused, removed 2017-08-12
···
       #ripple-data-api = 186; #unused
       mediatomb = 187;
       #rdnssd = 188; # unused
-      # ihaskell = 189; # unused
+      ihaskell = 189;
       i2p = 190;
       lambdabot = 191;
       asterisk = 192;

nixos/modules/module-list.nix

···
   ./services/misc/gogs.nix
   ./services/misc/gollum.nix
   ./services/misc/gpsd.nix
-  #./services/misc/ihaskell.nix
+  ./services/misc/ihaskell.nix
   ./services/misc/irkerd.nix
   ./services/misc/jackett.nix
   ./services/misc/logkeys.nix
···
   ./services/networking/asterisk.nix
   ./services/networking/atftpd.nix
   ./services/networking/avahi-daemon.nix
+  ./services/networking/babeld.nix
   ./services/networking/bind.nix
   ./services/networking/autossh.nix
   ./services/networking/bird.nix

nixos/modules/services/monitoring/graphite.nix

···
       ];
     })
 
-    (mkIf cfg.web.enable {
+    (mkIf cfg.web.enable (let
+      python27' = pkgs.python27.override {
+        packageOverrides = self: super: {
+          django = self.django_1_8;
+          django_tagging = self.django_tagging_0_4_3;
+        };
+      };
+      pythonPackages = python27'.pkgs;
+    in {
       systemd.services.graphiteWeb = {
         description = "Graphite Web Interface";
         wantedBy = [ "multi-user.target" ];
···
           PYTHONPATH = let
               penv = pkgs.python.buildEnv.override {
                 extraLibs = [
-                  pkgs.python27Packages.graphite_web
-                  pkgs.python27Packages.pysqlite
+                  pythonPackages.graphite_web
+                  pythonPackages.pysqlite
                 ];
               };
               penvPack = "${penv}/${pkgs.python.sitePackages}";
···
           fi
 
           # Only collect static files when graphite_web changes.
-          if ! [ "${dataDir}/current_graphite_web" -ef "${pkgs.python27Packages.graphite_web}" ]; then
+          if ! [ "${dataDir}/current_graphite_web" -ef "${pythonPackages.graphite_web}" ]; then
             mkdir -p ${staticDir}
             ${pkgs.pythonPackages.django_1_8}/bin/django-admin.py collectstatic  --noinput --clear
             chown -R graphite:graphite ${staticDir}
-            ln -sfT "${pkgs.python27Packages.graphite_web}" "${dataDir}/current_graphite_web"
+            ln -sfT "${pythonPackages.graphite_web}" "${dataDir}/current_graphite_web"
           fi
         '';
       };
 
-      environment.systemPackages = [ pkgs.python27Packages.graphite_web ];
-    })
+      environment.systemPackages = [ pythonPackages.graphite_web ];
+    }))
 
     (mkIf cfg.api.enable {
       systemd.services.graphiteApi = {

nixos/modules/services/networking/babeld.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.services.babeld;
+
+  paramsString = params:
+    concatMapStringsSep "" (name: "${name} ${boolToString (getAttr name params)}")
+                   (attrNames params);
+
+  interfaceConfig = name:
+    let
+      interface = getAttr name cfg.interfaces;
+    in
+    "interface ${name} ${paramsString interface}\n";
+
+  configFile = with cfg; pkgs.writeText "babeld.conf" (
+    (optionalString (cfg.interfaceDefaults != null) ''
+      default ${paramsString cfg.interfaceDefaults}
+    '')
+    + (concatMapStrings interfaceConfig (attrNames cfg.interfaces))
+    + extraConfig);
+
+in
+
+{
+
+  ###### interface
+
+  options = {
+
+    services.babeld = {
+
+      enable = mkOption {
+        default = false;
+        description = ''
+          Whether to run the babeld network routing daemon.
+        '';
+      };
+
+      interfaceDefaults = mkOption {
+        default = null;
+        description = ''
+          A set describing default parameters for babeld interfaces.
+          See <citerefentry><refentrytitle>babeld</refentrytitle><manvolnum>8</manvolnum></citerefentry> for options.
+        '';
+        type = types.nullOr (types.attrsOf types.unspecified);
+        example =
+          {
+            wired = true;
+            "split-horizon" = true;
+          };
+      };
+
+      interfaces = mkOption {
+        default = {};
+        description = ''
+          A set describing babeld interfaces.
+          See <citerefentry><refentrytitle>babeld</refentrytitle><manvolnum>8</manvolnum></citerefentry> for options.
+        '';
+        type = types.attrsOf (types.attrsOf types.unspecified);
+        example =
+          { enp0s2 =
+            { wired = true;
+              "hello-interval" = 5;
+              "split-horizon" = "auto";
+            };
+          };
+      };
+
+      extraConfig = mkOption {
+        default = "";
+        description = ''
+          Options that will be copied to babeld.conf.
+          See <citerefentry><refentrytitle>babeld</refentrytitle><manvolnum>8</manvolnum></citerefentry> for details.
+        '';
+      };
+    };
+
+  };
+
+
+  ###### implementation
+
+  config = mkIf config.services.babeld.enable {
+
+    systemd.services.babeld = {
+      description = "Babel routing daemon";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig.ExecStart = "${pkgs.babeld}/bin/babeld -c ${configFile}";
+    };
+
+  };
+
+}

nixos/modules/services/networking/networkmanager.nix

···
     ipv6.ip6-privacy=2
     ethernet.cloned-mac-address=${cfg.ethernet.macAddress}
     wifi.cloned-mac-address=${cfg.wifi.macAddress}
+    ${optionalString (cfg.wifi.powersave != null)
+      ''wifi.powersave=${if cfg.wifi.powersave then "3" else "2"}''}
+
+    [device]
+    wifi.scan-rand-mac-address=${if cfg.wifi.scanRandMacAddress then "yes" else "no"}
   '';
 
   /*
···
       };
 
       ethernet.macAddress = macAddressOpt;
-      wifi.macAddress = macAddressOpt;
+
+      wifi = {
+        macAddress = macAddressOpt;
+
+        powersave = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''
+            Whether to enable Wi-Fi power saving.
+          '';
+        };
+
+        scanRandMacAddress = mkOption {
+          type = types.bool;
+          default = true;
+          description = ''
+            Whether to enable MAC address randomization of a Wi-Fi device
+            during scanning.
+          '';
+        };
+      };
 
       useDnsmasq = mkOption {
         type = types.bool;

nixos/modules/services/networking/wireguard.nix

···
         description = "WireGuard Tunnel - ${name}";
         after = [ "network.target" ];
         wantedBy = [ "multi-user.target" ];
+        environment.DEVICE = name;
 
         serviceConfig = {
           Type = "oneshot";

nixos/modules/services/x11/desktop-managers/default.nix

···
 
       default = mkOption {
         type = types.str;
-        default = "none";
-        example = "plasma5";
+        default = "";
+        example = "none";
         description = "Default desktop manager loaded if none have been chosen.";
         apply = defaultDM:
           if defaultDM == "" && cfg.session.list != [] then

nixos/modules/services/x11/desktop-managers/plasma5.nix

···
         theme = mkDefault "breeze";
       };
 
+      boot.plymouth = {
+        theme = mkDefault "breeze";
+        themePackages = mkDefault [ pkgs.breeze-plymouth ];
+      };
+
       security.pam.services.kde = { allowNullPassword = true; };
 
       # Doing these one by one seems silly, but we currently lack a better

nixos/modules/services/x11/xserver.nix

···
         '';
       };
 
-      plainX = mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-          Whether the X11 session can be plain (without DM/WM) and
-          the Xsession script will be used as fallback or not.
-        '';
-      };
-
       autorun = mkOption {
         type = types.bool;
         default = true;
···
                 + "${toString (length primaryHeads)} heads set to primary: "
                 + concatMapStringsSep ", " (x: x.output) primaryHeads;
       })
-      { assertion = cfg.desktopManager.default == "none" && cfg.windowManager.default == "none" -> cfg.plainX;
-        message = "Either the desktop manager or the window manager shouldn't be `none`! To explicitly allow this, you can also set `services.xserver.plainX` to `true`.";
-      }
     ];
 
     environment.etc =

nixos/modules/system/boot/plymouth.nix

···
       moduleName="$(sed -n 's,ModuleName *= *,,p' ${themesEnv}/share/plymouth/themes/${cfg.theme}/${cfg.theme}.plymouth)"
 
       mkdir -p $out/lib/plymouth/renderers
-      cp ${plymouth}/lib/plymouth/{text,details,$moduleName}.so $out/lib/plymouth
+      # module might come from a theme
+      cp ${themesEnv}/lib/plymouth/{text,details,$moduleName}.so $out/lib/plymouth
       cp ${plymouth}/lib/plymouth/renderers/{drm,frame-buffer}.so $out/lib/plymouth/renderers
 
       mkdir -p $out/share/plymouth/themes
       cp ${plymouth}/share/plymouth/plymouthd.defaults $out/share/plymouth
-      cp -r ${themesEnv}/share/plymouth/themes/{text,details,${cfg.theme}} $out/share/plymouth/themes
+
+      # copy themes into working directory for patching
+      mkdir themes
+      # use -L to copy the directories proper, not the symlinks to them
+      cp -r -L ${themesEnv}/share/plymouth/themes/{text,details,${cfg.theme}} themes
+
+      # patch out any attempted references to the theme or plymouth's themes directory
+      chmod -R +w themes
+      find themes -type f | while read file
+      do
+        sed -i "s,/nix/.*/share/plymouth/themes,$out/share/plymouth/themes,g" $file
+      done
+
+      cp -r themes/* $out/share/plymouth/themes
       cp ${cfg.logo} $out/share/plymouth/logo.png
     '';
 

pkgs/applications/audio/ncmpc/default.nix

···
 { stdenv, fetchFromGitHub, meson, ninja, pkgconfig, glib, ncurses
 , mpd_clientlib, gettext }:
 
-let
-  rpath = stdenv.lib.makeLibraryPath [
-    glib ncurses mpd_clientlib
-  ];
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   name = "ncmpc-${version}";
   version = "0.28";
 
···
 
   buildInputs = [ glib ncurses mpd_clientlib ];
   nativeBuildInputs = [ meson ninja pkgconfig gettext ];
-
-  postFixup = ''
-    for elf in "$out"/bin/*; do
-      patchelf --set-rpath '${rpath}':"$out/lib" "$elf"
-    done
-  '';
 
   meta = with stdenv.lib; {
     description = "Curses-based interface for MPD (music player daemon)";

pkgs/applications/audio/quodlibet/default.nix

···
-{ stdenv, fetchurl, python2Packages, intltool
-, gst-python, withGstPlugins ? false, gst-plugins-base ? null
-, gst-plugins-good ? null, gst-plugins-ugly ? null, gst-plugins-bad ? null }:
-
-assert withGstPlugins -> gst-plugins-base != null
-                         || gst-plugins-good != null
-                         || gst-plugins-ugly != null
-                         || gst-plugins-bad != null;
+{ stdenv, fetchurl, python2Packages, wrapGAppsHook, gettext, intltool, libsoup, gnome3,
+  tag ? "",
+  gst_all_1, withGstPlugins ? true,
+  xineBackend ? false, xineLib,
+  withDbusPython ? false, withPyInotify ? false, withMusicBrainzNgs ? false, withPahoMqtt ? false,
+  webkitgtk ? null,
+  keybinder3 ? null, gtksourceview ? null, libmodplug ? null, kakasi ? null, libappindicator-gtk3 ? null }:
 
-let
-  version = "2.6.3";
-  inherit (python2Packages) buildPythonApplication python mutagen pygtk pygobject2 dbus-python;
-in buildPythonApplication {
-  # call the package quodlibet and just quodlibet
-  name = "quodlibet${stdenv.lib.optionalString (!withGstPlugins) "-without-gst-plugins"}-${version}";
+let optionals = stdenv.lib.optionals; in
+python2Packages.buildPythonApplication rec {
+  name = "quodlibet${tag}-${version}";
+  version = "3.9.1";
 
   # XXX, tests fail
   doCheck = false;
 
-  srcs = [
-    (fetchurl {
-      url = "https://bitbucket.org/lazka/quodlibet-files/raw/default/releases/quodlibet-${version}.tar.gz";
-      sha256 = "0ilasi4b0ay8r6v6ba209wsm80fq2nmzigzc5kvphrk71jwypx6z";
-     })
-    (fetchurl {
-      url = "https://bitbucket.org/lazka/quodlibet-files/raw/default/releases/quodlibet-plugins-${version}.tar.gz";
-      sha256 = "1rv08rhdjad8sjhplqsspcf4vkazgkxyshsqmbfbrrk5kvv57ybc";
-     })
-  ];
-
-  preConfigure = ''
-    # TODO: for now don't a apply gdist overrides, will be needed for shipping icons, gtk, etc
-    sed -i /distclass/d setup.py
-  '';
-
-  sourceRoot = "quodlibet-${version}";
-
-  postUnpack = ''
-    # the patch searches for plugins in directory ../plugins
-    # so link the appropriate directory there
-    ln -sf quodlibet-plugins-${version} plugins
-  '';
+  src = fetchurl {
+    url = "https://github.com/quodlibet/quodlibet/releases/download/release-${version}/quodlibet-${version}.tar.gz";
+    sha256 = "d2b42df5d439213973dc97149fddc779a6c90cec389c24baf1c0bdcc39ffe591";
+  };
 
-  patches = [ ./quodlibet-package-plugins.patch ];
+  nativeBuildInputs = [ wrapGAppsHook gettext intltool ];
+  # ++ (with python2Packages; [ pytest pyflakes pycodestyle polib ]); # test deps
 
-  buildInputs = stdenv.lib.optionals withGstPlugins [
-    gst-plugins-base gst-plugins-good gst-plugins-ugly gst-plugins-bad
-  ];
+  buildInputs = [ gnome3.defaultIconTheme libsoup webkitgtk keybinder3 gtksourceview libmodplug libappindicator-gtk3 kakasi ]
+    ++ (if xineBackend then [ xineLib ] else with gst_all_1;
+    [ gstreamer gst-plugins-base ] ++ optionals withGstPlugins [ gst-plugins-good gst-plugins-ugly gst-plugins-bad ]);
 
-  propagatedBuildInputs = [
-    mutagen pygtk pygobject2 dbus-python gst-python intltool
-  ];
+  propagatedBuildInputs = with python2Packages;
+    [ pygobject3 pycairo mutagen pygtk gst-python feedparser faulthandler futures ]
+      ++ optionals withDbusPython [ dbus-python ]
+      ++ optionals withPyInotify [ pyinotify ]
+      ++ optionals withMusicBrainzNgs [ musicbrainzngs ]
+      ++ optionals stdenv.isDarwin [ pyobjc ]
+      ++ optionals withPahoMqtt [ paho-mqtt ];
 
-  postInstall = stdenv.lib.optionalString withGstPlugins ''
-    # Wrap quodlibet so it finds the GStreamer plug-ins
-    wrapProgram "$out/bin/quodlibet" --prefix \
-      GST_PLUGIN_SYSTEM_PATH ":" "$GST_PLUGIN_SYSTEM_PATH"                                                     \
-  '';
+  makeWrapperArgs = optionals (kakasi != null) [ "--prefix PATH : ${kakasi}/bin" ];
 
   meta = {
     description = "GTK+-based audio player written in Python, using the Mutagen tagging library";
+    license = stdenv.lib.licenses.gpl2;
 
     longDescription = ''
       Quod Libet is a GTK+-based audio player written in Python, using
···
       & internet radio, and all major audio formats.
     '';
 
-    maintainers = [ stdenv.lib.maintainers.coroa ];
+    maintainers = with stdenv.lib.maintainers; [ coroa sauyon ];
     homepage = https://quodlibet.readthedocs.io/en/latest/;
   };
 }

pkgs/applications/audio/quodlibet/quodlibet-package-plugins.patch

···
-diff -Naur quodlibet-2.5.orig/setup.py quodlibet-2.5.new/setup.py
---- quodlibet-2.5.orig/setup.py	2012-12-19 08:47:41.000000000 +0000
-+++ quodlibet-2.5.new/setup.py	2013-04-22 19:27:07.152631051 +0000
-@@ -337,5 +338,14 @@
-                 }
-             }
-         })
-+    else:
-+        from os.path import join
-+
-+        data_files = []
-+        for type in ["playorder", "songsmenu", "editing", "events", "gstreamer"]:
-+            data_files.append((join('quodlibet', 'plugins', type),
-+                               glob.glob(join('..', 'plugins', type, '*.py'))))
-+        setup_kwargs.update({ 'data_files': data_files });
-+
-     setup(**setup_kwargs)
- 

pkgs/applications/editors/typora/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "typora-${version}";
-  version = "0.9.31";
+  version = "0.9.38";
 
   src =
     if stdenv.system == "x86_64-linux" then
       fetchurl {
         url = "https://www.typora.io/linux/typora_${version}_amd64.deb";
-        sha256 = "786b5164d9c63ecc23eb427c5ff393285ce8fd540c5bfdd5c1464655fac87a42";
+        sha256 = "bf6a069c5da4a7dc289bdb3c8d27e7a81daeaee99488d4d3b512c6b673780557";
       }
     else
       fetchurl {
         url = "https://www.typora.io/linux/typora_${version}_i386.deb";
-        sha256 = "a8fe53f8984d9f8c4e06c14affbb616be58a91cd2b475b9681fb18a6e21930d1";
+        sha256 = "edd092e96ebf69503cf6b39b77a61ec5e3185f8a1447da0bed063fa11861c1b9";
       }
     ;
 
···
   installPhase = ''
     mkdir -p $out
     dpkg -x $src $out
-    cp -av $out/usr/* $out
+    mv $out/usr/bin $out
+    mv $out/usr/share $out
     rm $out/bin/typora
+    rmdir $out/usr
 
     # Otherwise it looks "suspicious"
     chmod -R g-w $out
···
   meta = with stdenv.lib; {
     description = "A minimal Markdown reading & writing app";
     homepage = https://typora.io;
-    license = licenses.free;
-    maintainers = with stdenv.lib.maintainers; [ jensbin ];
+    license = licenses.unfree;
+    maintainers = with maintainers; [ jensbin ];
     platforms = [ "x86_64-linux" "i686-linux" ];
   };
 }
-

pkgs/applications/graphics/ImageMagick/7.0.nix

···
     else throw "ImageMagick is not supported on this platform.";
 
   cfg = {
-    version = "7.0.7-8";
-    sha256 = "0h2jbaxrxrmdcr5crf1d93sc60v4zfqrrl3w79md6h11wf57ksbp";
+    version = "7.0.7-9";
+    sha256 = "0p0879chcfrghcamwgxxcmaaj04xv0z91ris7hxi37qdw8c7836w";
     patches = [];
   };
 in

pkgs/applications/graphics/ImageMagick/default.nix

···
     else throw "ImageMagick is not supported on this platform.";
 
   cfg = {
-    version = "6.9.9-20";
-    sha256 = "1pz8clmhnq26vdsp1j21czq3nfbvrmfdz30k7na7w4vh7wqxsrx1";
+    version = "6.9.9-21";
+    sha256 = "0241g3c207rawn61bz8rc5gz55k5mi2b0n3zlwa0jv9xczlkd6a9";
     patches = [];
   }
     # Freeze version on mingw so we don't need to port the patch too often.

pkgs/applications/graphics/krita/default.nix

···
 
 mkDerivation rec {
   name = "krita-${version}";
-  version = "3.2.1";
+  version = "3.3.2";
 
   src = fetchurl {
-    url = "http://download.kde.org/stable/krita/${version}/${name}.tar.gz";
-    sha256 = "0fafy5ggplgq2rz85sqa42vmkzs2r9dq47qfrbnn2n6pfzkcw1pg";
+    url = https://download.kde.org/stable/krita/3.3.2/krita-3.3.2.1.tar.xz;
+    sha256 = "0i3l27cfi1h486m74xf4ynk0pwx32xaqraa91a0g1bpj1jxf2mg5";
   };
 
   nativeBuildInputs = [ cmake extra-cmake-modules ];

pkgs/applications/misc/dump1090/default.nix

···
+{ stdenv, fetchFromGitHub, pkgconfig, libusb, rtl-sdr }:
+
+stdenv.mkDerivation rec {
+  name = "dump1090-${version}";
+  version = "2014-10-31";
+
+  src = fetchFromGitHub {
+    owner = "MalcolmRobb";
+    repo = "dump1090";
+    rev = "bff92c4ad772a0a8d433f788d39dae97e00e4dbe";
+    sha256 = "06aaj9gpz5v4qzvnp8xf18wdfclp0jvn3hflls79ly46gz2dh9hy";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+
+  buildInputs = [ libusb rtl-sdr ];
+
+  makeFlags = [ "PREFIX=$out" ];
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share
+    cp -v dump1090 $out/bin/dump1090
+    cp -vr public_html $out/share/dump1090
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A simple Mode S decoder for RTLSDR devices";
+    homepage = https://github.com/MalcolmRobb/dump1090;
+    license = licenses.bsd3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ earldouglas ];
+  };
+}

pkgs/applications/misc/hello/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchipfs }:
 
 stdenv.mkDerivation rec {
   name = "hello-2.10";
 
-  src = fetchurl {
-    url = "mirror://gnu/hello/${name}.tar.gz";
-    sha256 = "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i";
+  src = fetchipfs {
+    url    = "https://ftp.gnu.org/gnu/hello/hello-2.10.tar.gz";
+    ipfs   = "QmWyj65ak3wd8kG2EvPCXKd6Tij15m4SwJz6g2yG2rQ7w8";
+    sha256 = "1im1gglfm4k10bh4mdaqzmx3lm3kivnsmxrvl6vyvmfqqzljq75l";
   };
 
   doCheck = true;

pkgs/applications/misc/hubstaff/default.nix

···
+{ stdenv, fetchurl, unzip, makeWrapper, libX11, zlib, libSM, libICE, libXext
+, freetype, libXrender, fontconfig, libXft, libXinerama, libnotify, glib
+, gtk3, libappindicator-gtk3, curl }:
+
+let
+
+  version = "1.2.14-36df5e3";
+
+  rpath = stdenv.lib.makeLibraryPath
+    [ libX11 zlib libSM libICE libXext freetype libXrender fontconfig libXft
+      libXinerama stdenv.cc.cc.lib libnotify glib gtk3 libappindicator-gtk3
+      curl ];
+
+in
+
+stdenv.mkDerivation {
+  name = "hubstaff-${version}";
+
+  src = fetchurl {
+    url = "https://hubstaff-production.s3.amazonaws.com/downloads/HubstaffClient/Builds/Release/${version}/Hubstaff-${version}.sh";
+    sha256 = "0yzhxk9zppj94llnf8naa6ca61f7c8jaj6b1m25zffnnz37m1sdb";
+  };
+
+  nativeBuildInputs = [ unzip makeWrapper ];
+
+  unpackCmd = ''
+    # MojoSetups have a ZIP file at the end. ZIP’s magic string is
+    # most often PK\x03\x04. This *should* work for future updates,
+    # but feel free to come up with something more reasonable.
+    dataZipOffset=$(grep --max-count=1 --byte-offset --only-matching --text $'PK\x03\x04' $curSrc | cut -d: -f1)
+    dd bs=$dataZipOffset skip=1 if=$curSrc of=data.zip 2>/dev/null
+    unzip -q data.zip "data/*"
+    rm data.zip
+  '';
+
+  dontBuild = true;
+
+  installPhase = ''
+    # TODO: handle 32-bit arch?
+    rm -r x86
+
+    opt=$out/opt/hubstaff
+    mkdir -p $out/bin $opt
+    cp -r . $opt/
+
+    prog=$opt/x86_64/HubstaffClient.bin.x86_64
+
+    patchelf --set-interpreter $(cat ${stdenv.cc}/nix-support/dynamic-linker) $prog
+    wrapProgram $prog --prefix LD_LIBRARY_PATH : ${rpath}
+
+    ln -s $prog $out/bin/HubstaffClient
+
+    # Why is this needed? SEGV otherwise.
+    ln -s $opt/data/resources $opt/x86_64/resources
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Time tracking software";
+    homepage = https://hubstaff.com/;
+    license = licenses.unfree;
+    platforms = [ "x86_64-linux" ];
+    maintainers = [ maintainers.michalrus ];
+  };
+}

pkgs/applications/misc/masterpdfeditor/default.nix

···
+{ stdenv, fetchurl, glibc, sane-backends, qtbase, qtsvg, libXext, libX11, libXdmcp, libXau, libxcb }:
+  let
+    version = "4.3.61";
+  in
+    stdenv.mkDerivation {
+      name = "masterpdfeditor-${version}";
+      src = fetchurl {
+        url = "http://get.code-industry.net/public/master-pdf-editor-${version}_qt5.amd64.tar.gz";
+        sha256 = "1g6mx8nch6ypf78h6xsb673wim19wn5ni5840armzg0pvi3sfknm";
+      };
+      libPath = stdenv.lib.makeLibraryPath [
+        stdenv.cc.cc
+        glibc
+        sane-backends
+        qtbase
+        qtsvg
+        libXext
+        libX11
+        libXdmcp
+        libXau
+        libxcb
+      ];
+      dontStrip = true;
+      installPhase = ''
+        p=$out/opt/masterpdfeditor
+        mkdir -p $out/bin $p $out/share/applications $out/share/pixmaps
+
+        substituteInPlace masterpdfeditor4.desktop \
+          --replace 'Exec=/opt/master-pdf-editor-4' "Exec=$out/bin" \
+          --replace 'Path=/opt/master-pdf-editor-4' "Path=$out/bin" \
+          --replace 'Icon=/opt/master-pdf-editor-4' "Icon=$out/share/pixmaps"
+        cp -v masterpdfeditor4.png $out/share/pixmaps/
+        cp -v masterpdfeditor4.desktop $out/share/applications
+
+        cp -v masterpdfeditor4 $p/
+        ln -s $p/masterpdfeditor4 $out/bin/masterpdfeditor4
+        cp -v -r stamps templates lang fonts $p
+
+        install -D license.txt $out/share/$name/LICENSE
+
+        patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+                 --set-rpath $libPath \
+                 $p/masterpdfeditor4
+      '';
+      meta = with stdenv.lib; {
+        description = "Master PDF Editor";
+        homepage = "https://code-industry.net/free-pdf-editor/";
+        license = licenses.unfreeRedistributable;
+        platforms = with platforms; [ "x86_64-linux" ];
+        maintainers = with maintainers; [ cmcdragonkai flokli ];
+      };
+    }

pkgs/applications/misc/subsurface/default.nix

···
-{
-  stdenv,
-  cmake, doxygen, pkgconfig, autoreconfHook,
-  curl,
-  fetchgit,
-  grantlee,
-  libgit2,
-  libusb,
-  libssh2,
-  libxml2,
-  libxslt,
-  libzip,
-  qtbase, qtconnectivity, qtquickcontrols, qtscript, qtsvg, qttools, qtwebkit,
-  sqlite
+{ stdenv, fetchurl, fetchFromGitHub, autoreconfHook, cmake, makeWrapper, pkgconfig, qmake
+, curl, grantlee, libgit2, libusb, libssh2, libxml2, libxslt, libzip, zlib
+, qtbase, qtconnectivity, qtlocation, qtsvg, qttools, qtwebkit
 }:
 
 let
-  version = "4.6.0";
+  version = "4.7.2";
 
-  libmarble = stdenv.mkDerivation rec {
-    name = "libmarble-ssrf-${version}";
+  libdc = stdenv.mkDerivation rec {
+    name = "libdivecomputer-ssrf-${version}";
 
-    src = fetchgit {
-      url    = "git://git.subsurface-divelog.org/marble";
-      rev    = "refs/tags/v${version}";
-      sha256 = "1dm2hdk6y36ls7pxbzkqmyc46hdy2cd5f6pkxa6nfrbhvk5f31zd";
+    src = fetchurl {
+      url = "https://subsurface-divelog.org/downloads/libdivecomputer-subsurface-branch-${version}.tgz";
+      sha256 = "04wadhhva1bfnwk0kl359kcv0f83mgym2fzs441spw5llcl7k52r";
     };
 
-    buildInputs = [ qtbase qtquickcontrols qtscript qtwebkit ];
-    nativeBuildInputs = [ doxygen pkgconfig cmake ];
+    nativeBuildInputs = [ autoreconfHook ];
+
+    buildInputs = [ zlib ];
 
     enableParallelBuilding = true;
 
-    cmakeFlags = [
-      "-DQTONLY=TRUE"
-      "-DQT5BUILD=ON"
-      "-DBUILD_MARBLE_TESTS=NO"
-      "-DWITH_DESIGNER_PLUGIN=NO"
-      "-DBUILD_MARBLE_APPS=NO"
-    ];
-
     meta = with stdenv.lib; {
-      description = "Qt library for a slippy map with patches from the Subsurface project";
-      homepage = http://subsurface-divelog.org;
+      homepage = http://www.libdivecomputer.org;
+      description = "A cross-platform and open source library for communication with dive computers from various manufacturers";
+      maintainers = with maintainers; [ mguentner ];
       license = licenses.lgpl21;
-      maintainers = with maintainers; [ mguentner ];
       platforms = platforms.all;
     };
   };
 
-  libdc = stdenv.mkDerivation rec {
-    name = "libdivecomputer-ssrf-${version}";
+  googlemaps = stdenv.mkDerivation rec {
+    name = "googlemaps-${version}";
+
+    version = "2017-09-17";
 
-    src = fetchgit {
-      url    = "git://subsurface-divelog.org/libdc";
-      rev    = "refs/tags/v${version}";
-      sha256 = "0s82c8bvqph9c9chwzd76iwrw968w7lgjm3pj4hmad1jim67bs6n";
+    src = fetchFromGitHub {
+      owner = "vladest";
+      repo = "googlemaps";
+      rev = "1b857c02504dd52b1aa442418b8dcea78ced3f35";
+      sha256 = "14icmc925g4abwwdrldjc387aiyvcp3ia5z7mfh9qa09bv829a84";
     };
 
-    nativeBuildInputs = [ autoreconfHook ];
+    nativeBuildInputs = [ qmake ];
+
+    buildInputs = [ qtbase qtlocation ];
+
+    pluginsSubdir = "lib/qt-${qtbase.qtCompatVersion}/plugins";
+
+    installPhase = ''
+      mkdir $out $(dirname ${pluginsSubdir})
+      mv plugins ${pluginsSubdir}
+      mv lib $out/
+    '';
 
     enableParallelBuilding = true;
 
     meta = with stdenv.lib; {
-      homepage = http://www.libdivecomputer.org;
-      description = "A cross-platform and open source library for communication with dive computers from various manufacturers";
-      maintainers = with maintainers; [ mguentner ];
-      license = licenses.lgpl21;
+      inherit (src.meta) homepage;
+      description = "QtLocation plugin for Google maps tile API";
+      maintainers = with maintainers; [ orivej ];
+      license = licenses.mit;
       platforms = platforms.all;
     };
   };
···
 in stdenv.mkDerivation rec {
   name = "subsurface-${version}";
 
-  src = fetchgit {
-    url    = "git://git.subsurface-divelog.org/subsurface";
-    rev    = "refs/tags/v${version}";
-    sha256 = "1rk5n52p6cnyjrgi7ybhmvh7y31zxrjny0mqpnc1wql69f90h94c";
+  src = fetchurl {
+    url = "https://subsurface-divelog.org/downloads/Subsurface-${version}.tgz";
+    sha256 = "06f215xx1nc2q2qff2ihcl86fkrlnkvacl1swi3fw9iik6nq3bjp";
   };
 
   buildInputs = [
-    libdc libmarble
+    libdc googlemaps
     curl grantlee libgit2 libssh2 libusb libxml2 libxslt libzip
     qtbase qtconnectivity qtsvg qttools qtwebkit
   ];
-  nativeBuildInputs = [ cmake pkgconfig ];
 
-  enableParallelBuilding = false; # subsurfacewebservices.h dependency on ui_webservices.h
+  nativeBuildInputs = [ cmake makeWrapper pkgconfig ];
 
   cmakeFlags = [
-    "-DMARBLE_LIBRARIES=${libmarble}/lib/libssrfmarblewidget.so"
+    "-DLIBDC_FROM_PKGCONFIG=ON"
     "-DNO_PRINTING=OFF"
   ];
 
+  postInstall = ''
+    wrapProgram $out/bin/subsurface \
+      --prefix QT_PLUGIN_PATH : "${googlemaps}/${googlemaps.pluginsSubdir}"
+  '';
+
+  enableParallelBuilding = true;
+
+  passthru = { inherit version libdc googlemaps; };
+
   meta = with stdenv.lib; {
-    description = "Subsurface is an open source divelog program that runs on Windows, Mac and Linux";
+    description = "A divelog program";
     longDescription = ''
       Subsurface can track single- and multi-tank dives using air, Nitrox or TriMix.
       It allows tracking of dive locations including GPS coordinates (which can also

pkgs/applications/networking/browsers/firefox-bin/default.nix

···
 
   inherit (generated) version sources;
 
-  arch = if stdenv.system == "i686-linux"
-    then "linux-i686"
-    else "linux-x86_64";
+  mozillaPlatforms = {
+    "i686-linux" = "linux-i686";
+    "x86_64-linux" = "linux-x86_64";
+  };
+
+  arch = mozillaPlatforms.${stdenv.system};
 
   isPrefixOf = prefix: string:
     builtins.substring 0 (builtins.stringLength prefix) string == prefix;
···
       free = false;
       url = http://www.mozilla.org/en-US/foundation/trademarks/policy/;
     };
-    platforms = platforms.linux;
+    platforms = builtins.attrNames mozillaPlatforms;
     maintainers = with maintainers; [ garbas ];
   };
 }

pkgs/applications/networking/browsers/qutebrowser/default.nix

···
   };
 
 in buildPythonApplication rec {
-  name = "qutebrowser-${version}";
-  version = "1.0.2";
+  name = "qutebrowser-${version}${fix_postfix}";
+  fix_postfix = "-1";
+  version = "1.0.3";
   namePrefix = "";
 
   src = fetchurl {
-    url = "https://github.com/The-Compiler/qutebrowser/releases/download/v${version}/${name}.tar.gz";
-    sha256 = "093nmvl9x3ykrpmvnmx98g9npg4wmq0mmf7qzgbzmg93dnyq2cpk";
+    url = "https://github.com/qutebrowser/qutebrowser/releases/download/v${version}/${name}.tar.gz";
+    sha256 = "04d6hg2yf2wjwn0sd05bpx3zngnb93g7rizbdq17bbpmnwxchzap";
   };
 
   # Needs tox

pkgs/applications/networking/p2p/tixati/default.nix

···
+{ stdenv, fetchurl, glib, zlib, dbus, dbus_glib, gtk2, gdk_pixbuf, cairo, pango }:
+
+stdenv.mkDerivation rec {
+  name = "tixati-${version}";
+  version = "2.55";
+
+  src = fetchurl {
+    url = "https://download2.tixati.com/download/tixati-${version}-1.x86_64.manualinstall.tar.gz";
+    sha256 = "02mha6lfcb0mg0y977bxa6xg8krpbsbzpm4b5xw6y6wign4d8a8w";
+  };
+
+  installPhase = ''
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+             --set-rpath ${stdenv.lib.makeLibraryPath [ glib zlib dbus dbus_glib gtk2 gdk_pixbuf cairo pango ]} \
+             tixati
+    install -D tixati         $out/bin/tixati
+    install -D tixati.desktop $out/share/applications/tixati.desktop
+    install -D tixati.png     $out/share/icons/tixati.png
+  '';
+
+  dontStrip = true;
+
+  meta = with stdenv.lib; {
+    description = "Torrent client";
+    homepage = http://www.tixati.com;
+    license = licenses.unfree;
+    platforms = [ "x86_64-linux" ];
+    maintainers = with maintainers; [ volth ];
+  };
+}

pkgs/applications/office/calligra/2.nix

···
     maintainers = with maintainers; [ phreedom ebzzry ];
     inherit (kdelibs4.meta) platforms;
     license = licenses.gpl2;
+    broken = true;
   };
 }

pkgs/applications/office/fava/default.nix

···
-{ stdenv, pkgs, fetchurl, python3Packages, fetchFromGitHub, fetchzip, python3, beancount }:
-
-python3Packages.buildPythonApplication rec {
-  version = "1.3";
-  name = "fava-${version}";
+{ stdenv, python3, beancount }:
 
-  src = fetchFromGitHub {
-    owner = "beancount";
-    repo = "fava";
-    rev = "v${version}";
-    sha256 = "0g0aj0qcmpny6dipi00nks7h3mf5a4jfd6bxjm1rb5807wswcpg8";
-  };
+let
+  inherit (python3.pkgs) buildPythonApplication fetchPypi;
+in
+buildPythonApplication rec {
+  pname = "fava";
+  version = "1.5";
+  name = "${pname}-${version}";
 
-  assets = fetchzip {
-    url = "https://github.com/beancount/fava/releases/download/v${version}/fava-${version}.tar.gz";
-    sha256 = "0yn2psbn436g1w5ixn94z8ca6dfd54izg98979arn0k7slpiccvz";
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0d3jncidzvfsxjplzg4cmflqr4mxrbrlj5bh6fpxj529pialpkk6";
   };
 
-  checkInputs = with python3Packages; [ pytest ];
-
-  checkPhase = ''
-    # pyexcel is optional
-    # the other 2 tests fail due non-unicode locales
-    PATH=$out/bin:$PATH pytest tests \
-      --ignore tests/test_util_excel.py \
-      --ignore tests/test_cli.py \
-      --ignore tests/test_translations.py \
-  '';
+  doCheck = false;
 
-  postInstall = ''
-    cp -r $assets/fava/static/gen $out/${python3.sitePackages}/fava/static
-  '';
-
-  propagatedBuildInputs = with python3Packages;
+  propagatedBuildInputs = with python3.pkgs;
     [ flask dateutil pygments wheel markdown2 flaskbabel tornado
       click beancount ];
 
   meta = {
-    homepage = https://github.com/aumayr/fava;
+    homepage = https://beancount.github.io/fava;
     description = "Web interface for beancount";
     license = stdenv.lib.licenses.mit;
     maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];

pkgs/applications/science/logic/cvc4/default.nix

···
-{ stdenv, fetchFromGitHub, cln, gmp, swig, pkgconfig, readline, libantlr3c,
-boost, jdk, autoreconfHook, python2, antlr3_4 }:
+{ stdenv, fetchurl, cln, gmp, swig, pkgconfig
+, readline, libantlr3c, boost, jdk, autoreconfHook
+, python2, antlr3_4
+}:
 
 stdenv.mkDerivation rec {
-  name = "cvc4-unstable-${version}";
-  version = "2017-05-18";
+  name = "cvc4-${version}";
+  version = "1.5";
 
-  src = fetchFromGitHub {
-    owner = "CVC4";
-    repo = "CVC4";
-    rev = "d77107cc56b0a089364c3d1512813701c155ea93";
-    sha256 = "085bjrrm33rl5pwqx13af9sgni9cfbg70wag6lm08jj41ws411xs";
+  src = fetchurl {
+    url = "http://cvc4.cs.stanford.edu/downloads/builds/src/cvc4-${version}.tar.gz";
+    sha256 = "0yxxawgc9vd2cz883swjlm76rbdkj48n7a8dfppsami530y2rvhi";
   };
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
···
     "--with-readline"
     "--with-boost=${boost.dev}"
   ];
+
   preConfigure = ''
     patchShebangs ./src/
   '';

pkgs/applications/science/logic/symbiyosys/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "symbiyosys-${version}";
-  version = "2017.10.16";
+  version = "2017.11.05";
 
   src = fetchFromGitHub {
     owner  = "cliffordwolf";
     repo   = "symbiyosys";
-    rev    = "f403b99fae053baab651e3ec8345a68cb3ba6a96";
-    sha256 = "0jzzlybxaqmhrasfjv3q3skshalr7lvv4p142qgdqz1ig36znbi8";
+    rev    = "db9c7e97b8f84ef7e9b18ae630009897c7982a08";
+    sha256 = "0pyznkjm0vjmaf6mpwknmh052qrwy2fzi05h80ysx1bxc51ns0m0";
   };
 
   buildInputs = [ python3 yosys ];

pkgs/applications/science/logic/yices/default.nix

···
 
 stdenv.mkDerivation rec {
   name    = "yices-${version}";
-  version = "2.5.3";
+  version = "2.5.4";
 
   src = fetchurl {
     url = "https://github.com/SRI-CSL/yices2/archive/Yices-${version}.tar.gz";
     name = "${name}-src.tar.gz";
-    sha256 = "0a3zzbvmgyiljzqn6xmc037gismm779p696jywk09j2pqbvp52ac";
+    sha256 = "1k8wmlddi3zv5kgg6xbch3a0s0xqsmsfc7y6z8zrgcyhswl36h7p";
   };
 
-  patchPhase = ''patchShebangs tests/regress/check.sh'';
-
-  configureFlags = [ "--with-static-gmp=${gmp-static.out}/lib/libgmp.a"
-                     "--with-static-gmp-include-dir=${gmp-static.dev}/include"
-                     "--enable-mcsat"
-                   ];
   nativeBuildInputs = [ autoreconfHook ];
-  buildInputs = [ gmp-static gperf libpoly ];
+  buildInputs       = [ gmp-static gperf libpoly ];
+  configureFlags =
+    [ "--with-static-gmp=${gmp-static.out}/lib/libgmp.a"
+      "--with-static-gmp-include-dir=${gmp-static.dev}/include"
+      "--enable-mcsat"
+    ];
 
   enableParallelBuilding = true;
   doCheck = true;
+
+  # Usual shenanigans
+  patchPhase = ''patchShebangs tests/regress/check.sh'';
 
   # Includes a fix for the embedded soname being libyices.so.2.5, but
-  # only installing the libyices.so.2.5.1 file.
+  # only installing the libyices.so.2.5.x file.
   installPhase = ''
       make install LDCONFIG=true
-      (cd $out/lib && ln -s -f libyices.so.2.5.3 libyices.so.2.5)
+      (cd $out/lib && ln -s -f libyices.so.${version} libyices.so.2.5)
   '';
 
   meta = with stdenv.lib; {
     description = "A high-performance theorem prover and SMT solver";
     homepage    = "http://yices.csl.sri.com";
     license     = licenses.gpl3;
-    platforms   = platforms.linux ++ platforms.darwin;
+    platforms   = with platforms; linux ++ darwin;
     maintainers = [ maintainers.thoughtpolice ];
   };
 }

pkgs/applications/science/math/sage/default.nix

···
-{ stdenv, fetchurl, m4, perl, gfortran, texlive, ffmpeg, tk, gnused_422
-, imagemagick, liblapack, python, openssl, libpng 
+# TODO
+# - consider writing a script to convert spkgs to nix packages, similar to vim
+#   or cabal2nix. This would allow a more efficient and "cleaner" build, greater
+#   flexibility and the possibility to select which dependencies to add and which
+#   to remove. It would also allow to use system packages for some dependencies
+#   and recompile others (optimized for the system) without recompiling everything.
+# - add optdeps:
+#   - imagemagick
+#   - texlive full for documentation
+#   - ...
+# - further seperate build outputs. Also maybe run `make doc`.
+#   Configure flags like --bindir and --libdir oculd also be used for that, see
+#   ./configure --help`.
+
+# Other resources:
+# - https://wiki.debian.org/DebianScience/Sage
+# - https://github.com/cschwan/sage-on-gentoo
+# - https://git.archlinux.org/svntogit/community.git/tree/trunk?h=packages/sagemath
+
+{ stdenv
+, fetchurl
+, perl
+, gfortran
+, python
+, autoreconfHook
+, gettext
 , which
+, texlive
+, hevea
 }:
 
 stdenv.mkDerivation rec {
-  name = "sage-6.8";
+  version = "8.0";
+  name = "sage-${version}";
 
   src = fetchurl {
-    url = "http://old.files.sagemath.org/src-old/${name}.tar.gz";
-    sha256 = "102mrzzi215g1xn5zgcv501x9sghwg758jagx2jixvg1rj2jijj9";
+    # Note that the source is *not* fetched from github, since that doesn't
+    # the upstream folder with all the source tarballs of the spkgs.
+    # If those are not present they are fetched at build time, which breaks
+    # when building in a sandbox (and probably only works if you install the
+    # latest sage version).
+    urls = [
+      "http://mirrors.mit.edu/sage/src/sage-${version}.tar.gz"
+      "ftp://ftp.fu-berlin.de/unix/misc/sage/src/sage-${version}.tar.gz"
+      "http://sagemath.polytechnic.edu.na/src/sage-${version}.tar.gz"
+      "ftp://ftp.sun.ac.za/pub/mirrors/www.sagemath.org/src/sage-${version}.tar.gz"
+      "http://sagemath.mirror.ac.za/src/sage-${version}.tar.gz"
+      "http://ftp.leg.uct.ac.za/pub/packages/sage/src/sage-${version}.tar.gz"
+      "http://mirror.ufs.ac.za/sagemath/src/sage-${version}.tar.gz"
+      "http://mirrors-usa.go-parts.com/sage/sagemath/src/sage-${version}.tar.gz"
+      "http://www.cecm.sfu.ca/sage/src/sage-${version}.tar.gz"
+      "http://files.sagemath.org/src/sage-${version}.tar.gz"
+      "http://mirrors.xmission.com/sage/src/sage-${version}.tar.gz"
+      "http://sagemath.c3sl.ufpr.br/src/sage-${version}.tar.gz"
+      "http://linorg.usp.br/sage/src/sage-${version}.tar.gz"
+      "http://mirror.hust.edu.cn/sagemath/src/sage-${version}.tar.gz"
+      "http://ftp.iitm.ac.in/sage/src/sage-${version}.tar.gz"
+      "http://ftp.kaist.ac.kr/sage/src/sage-${version}.tar.gz"
+      "http://ftp.riken.jp/sagemath/src/sage-${version}.tar.gz"
+      "http://mirrors.tuna.tsinghua.edu.cn/sagemath/src/sage-${version}.tar.gz"
+      "http://mirrors.ustc.edu.cn/sagemath/src/sage-${version}.tar.gz"
+      "http://ftp.tsukuba.wide.ad.jp/software/sage/src/sage-${version}.tar.gz"
+      "http://ftp.yz.yamagata-u.ac.jp/pub/math/sage/src/sage-${version}.tar.gz"
+      "http://mirror.yandex.ru/mirrors/sage.math.washington.edu/src/sage-${version}.tar.gz"
+      "http://mirror.aarnet.edu.au/pub/sage/src/sage-${version}.tar.gz"
+      "http://sage.mirror.garr.it/mirrors/sage/src/sage-${version}.tar.gz"
+      "http://www.mirrorservice.org/sites/www.sagemath.org/src/sage-${version}.tar.gz"
+      "http://mirror.switch.ch/mirror/sagemath/src/sage-${version}.tar.gz"
+      "https://mirrors.up.pt/pub/sage/src/sage-${version}.tar.gz"
+      "http://www-ftp.lip6.fr/pub/math/sagemath/src/sage-${version}.tar.gz"
+      "http://ftp.ntua.gr/pub/sagemath/src/sage-${version}.tar.gz"
+    ];
+    sha256 = "1a9rhb8jby6fdqa2s7n2fl9jwqqlsl7qz7dbpbwvg6jwlrvni7fg";
+  };
+
+  postPatch = ''
+    substituteAllInPlace src/bin/sage-env
+  '';
+
+  installPhase = ''
+    # Sage installs during first `make`, `make install` is no-op and just takes time.
+  '';
 
-  };
+  outputs = [ "out" "doc" ];
 
-  buildInputs = [ m4 perl gfortran texlive.combined.scheme-basic ffmpeg gnused_422 tk imagemagick liblapack
-                  python openssl libpng which ];
+  buildInputs = [
+    perl # needed for the build
+    python # needed for the build
+    gfortran # needed to build giac
+    autoreconfHook # needed to configure sage with prefix
+    gettext # needed to build the singular spkg
+    hevea # needed to build the docs of the giac spkg
+    which # needed in configure of mpir
+    # needed to build the docs of the giac spkg
+    (texlive.combine { inherit (texlive)
+      scheme-basic
+      collection-pstricks # needed by giac
+      times # font needed by giac
+      stmaryrd # needed by giac
+      babel-greek # optional for giac, otherwise throws a bunch of latex command not founds
+      ;
+    })
+  ];
 
-  patches = [ ./spkg-singular.patch ./spkg-python.patch ./spkg-git.patch ];
+  patches = [
+    # fix usages of /bin/rm
+    ./spkg-singular.patch
+    # help python find the crypt library
+    ./spkg-python2.patch
+    ./spkg-python3.patch
+    # fix usages of /usr/bin/perl
+    ./spkg-git.patch
+    # fix usages of /bin/cp and add necessary argument to function call
+    ./spkg-giac.patch
+    # environment
+    ./env.patch
+  ];
 
   enableParallelBuilding = true;
 
-  hardeningDisable = [ "format" ];
+  hardeningDisable = [
+    "format" # needed to build palp, for lines like `printf(ctime(&_NFL->TIME))`
+    # TODO could be patched with `sed s|printf(ctime(\(.*\)))|%s... or fixed upstream
+  ];
 
   preConfigure = ''
     export SAGE_NUM_THREADS=$NIX_BUILD_CORES
     export SAGE_ATLAS_ARCH=fast
-    mkdir -p $out/sageHome
-    export HOME=$out/sageHome
-    export CPPFLAGS="-P"
+
+    export HOME=$out/sage-home
+    mkdir -p $out/sage-home
+
+    mkdir -p "$out"
+
+    # we need to keep the source around
+    dir="$PWD"
+    cd ..
+    mv "$dir" "$out/sage-root"
+
+    cd "$out/sage-root" # build in target dir, since `make` is also `make install`
   '';
 
-  preBuild = "patchShebangs build";
+  # for reference: http://doc.sagemath.org/html/en/installation/source.html
+  preBuild = ''
+    # TODO do this conditionally
+    export SAGE_SPKG_INSTALL_DOCS='no'
+    patchShebangs build
+  '';
+
+  postBuild = ''
+    rm -r "$out/sage-root/upstream" # don't keep the sources of all the spkgs
+    rm -r "$out/sage-root/src/build"
+    rm -rf "$out/sage-root/src/.git"
+    rm -r "$out/sage-root/logs"
+    # Fix dependency cycle between out and doc
+    rm -f "$out/sage-root/config.status"
+    rm -f "$out/sage-root/build/make/Makefile-auto"
+    rm -f "$out/sage-home/.sage/gap/libgap-workspace-"*
+  '';
+
+  # TODO there are some doctest failures, which seem harmless.
+  # We should figure out a way to fix the failures or ignore only those tests.
+  doCheck = false;
 
-  installPhase = ''DESTDIR=$out make install'';
+  checkTarget = "ptestalllong"; # all long tests in parallell
+  preCheck = ''
+    export SAGE_TIMEOUT=0 # no timeout
+    export SAGE_TIMEOUT_LONG=0 # no timeout
+  '';
 
   meta = {
     homepage = http://www.sagemath.org;
     description = "A free open source mathematics software system";
+    # taken from the homepage
+    longDescription = ''
+      SageMath is a free open-source mathematics software system licensed under the GPL. It builds on top of many existing open-source packages: NumPy, SciPy, matplotlib, Sympy, Maxima, GAP, FLINT, R and many more. Access their combined power through a common, Python-based language or directly via interfaces or wrappers.
+      Mission: Creating a viable free open source alternative to Magma, Maple, Mathematica and Matlab.
+    '';
     license = stdenv.lib.licenses.gpl2Plus;
-    broken = true;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = with stdenv.lib.maintainers; [ timokau ];
   };
 }

pkgs/applications/science/math/sage/env.patch

···
+diff --git a/src/bin/sage-env b/src/bin/sage-env
+index ead308f861..ed8db9f9b7 100644
+--- a/src/bin/sage-env
++++ b/src/bin/sage-env
+@@ -111,6 +111,8 @@ resolvelinks() {
+ }
+ 
+ 
++SAGE_ROOT="@out@/sage-root"
++
+ # New value for SAGE_ROOT: either SAGE_ROOT (if given)
+ # or a guessed value based on pwd.
+ if [ -n "$SAGE_ROOT" ]; then
+@@ -185,6 +187,8 @@ fi
+ export SAGE_ENV_SOURCED=$SAGE_ENV_VERSION
+ 
+ export SAGE_ROOT="$NEW_SAGE_ROOT"
++export SAGE_LOCAL='@out@/'
++export PYTHONPATH="@out@/lib/python2.7/site-packages:$PYTHONPATH"
+ 
+ 
+ # sage-env must know where the Sage's script files are.

pkgs/applications/science/math/sage/fetch-mirrors.sh

···
+#! /usr/bin/env nix-shell
+#! nix-shell -i bash -p curl go-pup
+
+# Fetches a list of all available source mirrors from the sage homepage.
+# Note that the list is sorted by country, but fetchurl doesn't offer an option
+# to customize mirror preference.
+
+curl -s http://www.sagemath.org/download-source.html \
+    | pup 'table#mirror'  \
+    | pup 'a attr{href}' \
+    | sed -e 's/index\.html/sage-${version}.tar.gz/'

pkgs/applications/science/math/sage/spkg-giac.patch

···
+--- old/build/pkgs/giac/spkg-install	2017-07-21 14:10:00.000000000 -0500
++++ new/build/pkgs/giac/spkg-install	2017-10-15 15:55:55.321237645 -0500
+@@ -4,6 +4,8 @@
+ ## Giac
+ ###########################################
+ 
++find . -type f -exec sed -e 's@/bin/cp@cp@g' -i '{}' ';' && echo "Patching input parser" && find . -iname 'input_parser.cc'
++sed -e 's@yylex (&yylval)@yylex (\&yyval, scanner)@gp' -i 'src/src/input_parser.cc'
+ 
+ if [ "$SAGE_LOCAL" = "" ]; then
+    echo "SAGE_LOCAL undefined ... exiting";

pkgs/applications/science/math/sage/spkg-git.patch

···
---- old/build/pkgs/git/spkg-install	2015-07-26 15:34:43.000000000 +0200
-+++ new/build/pkgs/git/spkg-install	2015-09-17 08:28:03.586657451 +0200
-@@ -45,6 +45,8 @@
-     fi
- done
+diff --git a/build/pkgs/git/spkg-install b/build/pkgs/git/spkg-install
+index 8469cb58c2..d0dc9a1db9 100755
+--- a/build/pkgs/git/spkg-install
++++ b/build/pkgs/git/spkg-install
+@@ -35,6 +35,8 @@ fi
  
-+find . -exec sed -e 's@/usr/bin/perl@perl@g' -i '{}' ';'
+ cd src
+ 
++find . -type f -exec sed -e 's@/usr/bin/perl@perl@g' -i '{}' ';'
 +
  # We don't want to think about Fink or Macports
  export NO_FINK=1

pkgs/applications/science/math/sage/spkg-python.patch

···
---- old/build/pkgs/python2/spkg-install	2015-07-26 15:34:43.000000000 +0200
-+++ new/build/pkgs/python2/spkg-install	2015-09-16 20:48:51.904555797 +0200
-@@ -32,7 +32,7 @@
- done
- 
- # We are setting LDFLAGS so that we pick up Sage's readline
--LDFLAGS="-L$SAGE_LOCAL/lib $LDFLAGS"
-+LDFLAGS="-L$SAGE_LOCAL/lib -lcrypt $LDFLAGS"
- export LDFLAGS
- 
- if [ "$SAGE_DEBUG" = "yes" ]; then

pkgs/applications/science/math/sage/spkg-python2.patch

···
+--- old/build/pkgs/python2/spkg-install	2017-07-21 14:10:00.000000000 -0500
++++ new/build/pkgs/python2/spkg-install	2017-10-15 11:26:54.823134067 -0500
+@@ -22,6 +22,9 @@
+ 
+ cd src
+ 
++LDFLAGS="-lcrypt $LDFLAGS"
++export LDFLAGS
++
+ if [ "$SAGE_DEBUG" = "yes" ]; then
+     echo "Building Python with pydebug"
+     PYTHON_CONFIGURE="$PYTHON_CONFIGURE --with-pydebug"

pkgs/applications/science/math/sage/spkg-python3.patch

···
+--- old/build/pkgs/python3/spkg-install	2017-07-21 14:10:00.000000000 -0500
++++ new/build/pkgs/python3/spkg-install	2017-10-15 13:11:17.769261404 -0500
+@@ -22,6 +22,9 @@
+ 
+ cd src
+ 
++LDFLAGS="-lcrypt $LDFLAGS"		
++export LDFLAGS
++
+ if [ "$SAGE_DEBUG" = "yes" ]; then
+     echo "Building Python with pydebug"
+     PYTHON_CONFIGURE="$PYTHON_CONFIGURE --with-pydebug"

pkgs/applications/science/math/sage/spkg-singular.patch

···
---- old/build/pkgs/singular/spkg-install	2015-07-26 15:34:43.000000000 +0200
-+++ new/build/pkgs/singular/spkg-install	2015-09-15 20:42:51.716505855 +0200
-@@ -115,6 +115,11 @@
-     done
- }
+--- old/build/pkgs/singular/spkg-install	2017-10-15 10:35:41.826540964 -0500
++++ new/build/pkgs/singular/spkg-install	2017-10-15 10:36:40.613743443 -0500
+@@ -4,6 +4,9 @@
+ ## Singular
+ ###########################################
  
-+nix_nuke_bin_rm()
-+{
-+    find . -exec sed -e 's@/bin/rm@rm@g' -i '{}' ';'
-+}
++find . -type f -exec sed -e 's@/bin/rm@rm@g' -i '{}' ';'
++#echo '#!/usr/bin/env bash\nIgnoring missing $1' > src/build-aux/missing
 +
- remove_old_version()
- {
-     rm -f "$SAGE_LOCAL"/bin/Singular*
-@@ -306,11 +311,11 @@
- 
- 
- # Actually run all the functions defined above
--for i in choose_patches apply_patches remove_old_version config \
-+for i in choose_patches apply_patches nix_nuke_bin_rm remove_old_version config \
-   build_singular build_libsingular build_factory build_libfac \
-   create_singular_script install_docs ; do
-     echo "### Singular spkg-install: $i ###"
--    cd "$SRC" && $i
-+    cd "$SRC" && pwd && $i
-     if [ $? -ne 0 ]; then
-         echo >&2 "Error building Singular (error in $i)."
-         exit 1
+ if [ -z "$SAGE_LOCAL" ]; then
+     echo >&2 "Error: SAGE_LOCAL undefined -- exiting..."
+     echo >&2 "Maybe run 'sage -sh'?"

pkgs/applications/video/lightworks/default.nix

···
+{ stdenv, fetchurl, dpkg, makeWrapper, patchelf, buildFHSUserEnv
+, gtk3, gnome3, gdk_pixbuf, cairo, libjpeg_original, glib, gnome2, mesa_glu
+, nvidia_cg_toolkit, zlib, openssl, portaudio
+}:
+let
+  fullPath = stdenv.lib.makeLibraryPath [
+    stdenv.cc.cc
+    gnome3.gtk
+    gdk_pixbuf
+    cairo
+    libjpeg_original
+    glib
+    gnome2.pango
+    mesa_glu
+    nvidia_cg_toolkit
+    zlib
+    openssl
+    portaudio
+  ];
+
+  lightworks = stdenv.mkDerivation rec {
+    version = "14.0.0";
+    name = "lightworks-${version}";
+    
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = "http://downloads.lwks.com/v14/lwks-14.0.0-amd64.deb";
+          sha256 = "66eb9f9678d979db76199f1c99a71df0ddc017bb47dfda976b508849ab305033";
+        }
+      else throw "${name} is not supported on ${stdenv.system}";
+
+    buildInputs = [ dpkg makeWrapper ];
+
+    phases = [ "unpackPhase" "installPhase" ];
+    unpackPhase = "dpkg-deb -x ${src} ./";
+
+    installPhase = ''
+      mkdir -p $out/bin
+      substitute usr/bin/lightworks $out/bin/lightworks \
+        --replace "/usr/lib/lightworks" "$out/lib/lightworks"
+      chmod +x $out/bin/lightworks
+
+      cp -r usr/lib $out
+
+      # /usr/share/fonts is not normally searched
+      # This adds it to lightworks' search path while keeping the default
+      # using the FONTCONFIG_FILE env variable
+      echo "<?xml version='1.0'?>
+      <!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
+      <fontconfig>
+          <dir>/usr/share/fonts/truetype</dir>
+          <include>/etc/fonts/fonts.conf</include>
+      </fontconfig>" > $out/lib/lightworks/fonts.conf
+
+      patchelf \
+        --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+        $out/lib/lightworks/ntcardvt
+
+      wrapProgram $out/lib/lightworks/ntcardvt \
+        --prefix LD_LIBRARY_PATH : ${fullPath}:$out/lib/lightworks \
+        --set FONTCONFIG_FILE $out/lib/lightworks/fonts.conf
+       
+      cp -r usr/share $out/share
+    '';
+
+    dontPatchELF = true;
+
+    meta = {
+      description = "Professional Non-Linear Video Editor";
+      homepage = "https://www.lwks.com/";
+      license = stdenv.lib.licenses.unfree;
+      maintainers = [ stdenv.lib.maintainers.antonxy ];
+      platforms = [ "x86_64-linux" ];
+    };
+  };
+
+# Lightworks expects some files in /usr/share/lightworks
+in buildFHSUserEnv rec {
+  name = "lightworks";
+
+  targetPkgs = pkgs: [
+      lightworks
+  ];
+
+  runScript = "lightworks";
+}

pkgs/applications/video/mkvtoolnix/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mkvtoolnix-${version}";
-  version = "16.0.0";
+  version = "17.0.0";
 
   src = fetchFromGitHub {
     owner = "mbunkus";
     repo = "mkvtoolnix";
     rev = "release-${version}";
-    sha256 = "0zdmjp0f7sh0bkaj0ls4sy4sg9qdq9ycrl18hlkafnj9xnbijgnn";
+    sha256 = "1v74rxf9wm0sn2illy0hp36hpwz7q04y0k32wq6wn7qrnzkzcc88";
   };
 
   nativeBuildInputs = [ pkgconfig autoconf automake gettext drake ruby docbook_xsl libxslt ];

pkgs/build-support/fetchipfs/builder.sh

···
+source $stdenv/setup
+
+# Curl flags to handle redirects, not use EPSV, handle cookies for
+# servers to need them during redirects, and work on SSL without a
+# certificate (this isn't a security problem because we check the
+# cryptographic hash of the output anyway).
+
+set -o noglob
+
+curl="curl            \
+ --location           \
+ --max-redirs 20      \
+ --retry 2            \
+ --disable-epsv       \
+ --cookie-jar cookies \
+ --insecure           \
+ --speed-time 5       \
+ -#                   \
+ --fail               \
+ $curlOpts            \
+ $NIX_CURL_FLAGS"
+
+finish() {
+    runHook postFetch
+    set +o noglob
+    exit 0
+}
+
+ipfs_add() {
+    if curl --retry 0 --head --silent "localhost:5001" > /dev/null; then
+        echo "=IPFS= add $ipfs"
+        tar --owner=root --group=root -cWf "source.tar" $(echo *)
+        res=$(curl -# -F "file=@source.tar" "localhost:5001/api/v0/tar/add" | sed 's/.*"Hash":"\(.*\)".*/\1/')
+        if [ $ipfs != $res ]; then
+            echo "\`ipfs tar add' results in $res when $ipfs is expected"
+            exit 1
+        fi
+        rm "source.tar"
+    fi
+}
+
+echo
+
+mkdir download
+cd download
+
+if curl --retry 0 --head --silent "localhost:5001" > /dev/null; then
+    curlexit=18;
+    echo "=IPFS= get $ipfs"
+    # if we get error code 18, resume partial download
+    while [ $curlexit -eq 18 ]; do
+        # keep this inside an if statement, since on failure it doesn't abort the script
+        if $curl -C - "http://localhost:5001/api/v0/tar/cat?arg=$ipfs" --output "$ipfs.tar"; then
+            unpackFile "$ipfs.tar"
+            rm "$ipfs.tar"
+            set +o noglob
+            mv $(echo *) "$out"
+            finish
+        else
+            curlexit=$?;
+        fi
+    done
+fi
+
+if test -n "$url"; then
+    curlexit=18;
+    echo "Downloading $url"
+    while [ $curlexit -eq 18 ]; do
+        # keep this inside an if statement, since on failure it doesn't abort the script
+        if $curl "$url" -O; then
+            set +o noglob
+            tmpfile=$(echo *)
+            unpackFile $tmpfile
+            rm $tmpfile
+            ipfs_add
+            mv $(echo *) "$out"
+            finish
+        else
+            curlexit=$?;
+        fi
+    done
+fi
+
+echo "error: cannot download $ipfs from ipfs or the given url"
+echo
+set +o noglob
+exit 1

pkgs/build-support/fetchipfs/default.nix

···
+{ stdenv
+, curl
+}:
+
+{ ipfs
+, url            ? ""
+, curlOpts       ? ""
+, outputHash     ? ""
+, outputHashAlgo ? ""
+, md5            ? ""
+, sha1           ? ""
+, sha256         ? ""
+, sha512         ? ""
+, meta           ? {}
+, port           ? "8080"
+, postFetch      ? ""
+}:
+
+assert sha512 != "" -> builtins.compareVersions "1.11" builtins.nixVersion <= 0;
+
+let
+
+  hasHash = (outputHash != "" && outputHashAlgo != "")
+    || md5 != "" || sha1 != "" || sha256 != "" || sha512 != "";
+
+in
+
+if (!hasHash) then throw "Specify sha for fetchipfs fixed-output derivation" else stdenv.mkDerivation {
+  name = ipfs;
+  builder = ./builder.sh;
+  buildInputs = [ curl ];
+
+  # New-style output content requirements.
+  outputHashAlgo = if outputHashAlgo != "" then outputHashAlgo else
+      if sha512 != "" then "sha512" else if sha256 != "" then "sha256" else if sha1 != "" then "sha1" else "md5";
+  outputHash = if outputHash != "" then outputHash else
+      if sha512 != "" then sha512 else if sha256 != "" then sha256 else if sha1 != "" then sha1 else md5;
+
+  outputHashMode = "recursive";
+
+  inherit curlOpts
+          postFetch
+          ipfs
+          url
+          port;
+
+  # Doing the download on a remote machine just duplicates network
+  # traffic, so don't do that.
+  preferLocalBuild = true;
+
+  inherit meta;
+}

pkgs/build-support/kernel/make-initrd.nix

···
 # `contents = {object = ...; symlink = /init;}' is a typical
 # argument.
 
-{ stdenv, perl, cpio, contents, ubootChooser, compressor, prepend
+{ stdenv, perl, cpio, contents, compressor, prepend, ubootTools
 , hostPlatform
 }:
 
-let
-  inputsFun = ubootName : [ perl cpio ]
-    ++ stdenv.lib.optional (ubootName != null) [ (ubootChooser ubootName) ];
-  makeUInitrdFun = ubootName : (ubootName != null);
-in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   name = "initrd";
   builder = ./make-initrd.sh;
-  nativeBuildInputs = inputsFun hostPlatform.platform.uboot;
+
+  makeUInitrd = hostPlatform.platform.kernelTarget == "uImage";
 
-  makeUInitrd = makeUInitrdFun hostPlatform.platform.uboot;
+  nativeBuildInputs = [ perl cpio ]
+    ++ stdenv.lib.optional makeUInitrd ubootTools;
 
   # !!! should use XML.
   objects = map (x: x.object) contents;

pkgs/data/misc/hackage/default.nix

···
   src-spec ?
     { owner = "commercialhaskell";
       repo = "all-cabal-hashes";
-      rev = "901c2522e6797270f5ded4495b1a529e6c16ef45";
-      sha256 = "05jmwsgrk77nz9vvgfbpsps0l320qgjpkr2c9zhkn9sc3d275lfb";
+      rev = "5e87c40f2cd96bd5dd953758e82f302107c7895e";
+      sha256 = "12rw5fld64s0a2zjsdijfs0dv6vc6z7gcf24h4m2dmymzms4namg";
     }
 , lib
 }:

pkgs/desktops/gnome-3/apps/glade/default.nix

···
-{ stdenv, intltool, fetchurl, python
+{ stdenv, intltool, fetchurl, python, autoreconfHook
 , pkgconfig, gtk3, glib
 , makeWrapper, itstool, libxml2, docbook_xsl
 , gnome3, librsvg, gdk_pixbuf, libxslt }:
···
 
   propagatedUserEnvPkgs = [ gnome3.gnome_themes_standard ];
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ gtk3 glib intltool itstool libxml2 python
-                  gnome3.gsettings_desktop_schemas makeWrapper docbook_xsl
-                  gdk_pixbuf gnome3.defaultIconTheme librsvg libxslt ];
+  nativeBuildInputs = [
+    pkgconfig intltool itstool makeWrapper docbook_xsl libxslt
+    # reconfiguration
+    autoreconfHook gnome3.gnome_common gnome3.yelp_tools
+  ];
+  buildInputs = [ gtk3 glib libxml2 python
+                  gnome3.gsettings_desktop_schemas
+                  gdk_pixbuf gnome3.defaultIconTheme librsvg ];
 
   enableParallelBuilding = true;
+
+  patches = [
+    # https://bugzilla.gnome.org/show_bug.cgi?id=782161
+    (fetchurl {
+      url = https://bugzilla.gnome.org/attachment.cgi?id=351054;
+      sha256 = "093wjjj40027pkqqnm14jb2dp2i2m8p1bayqx1lw18pq66c8fahn";
+    })
+  ];
 
   preFixup = ''
     wrapProgram "$out/bin/glade" \

pkgs/desktops/gnome-3/apps/nautilus-sendto/default.nix

···
-{ stdenv, fetchurl, glib, pkgconfig, gnome3, intltool
-, gobjectIntrospection, makeWrapper }:
+{ stdenv, fetchurl, meson, ninja, glib, pkgconfig, gnome3, appstream-glib, gettext }:
 
 stdenv.mkDerivation rec {
   name = "nautilus-sendto-${version}";
 
-  version = "3.8.1";
+  version = "3.8.6";
 
   src = fetchurl {
     url = "mirror://gnome/sources/nautilus-sendto/3.8/${name}.tar.xz";
-    sha256 = "03fa46bff271acdbdedab6243b2a84e5ed3daa19c81b69d087b3e852c8fe5dab";
+    sha256 = "164d7c6e8bae29c4579bcc67a7bf50d783662b1545b62f3008e7ea3c0410e04d";
   };
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ glib gobjectIntrospection intltool makeWrapper ];
+  nativeBuildInputs = [ meson ninja pkgconfig appstream-glib gettext ];
+  buildInputs = [ glib ];
 
   meta = with stdenv.lib; {
     description = "Integrates Evolution and Pidgin into the Nautilus file manager";

pkgs/desktops/gnome-3/core/dconf/default.nix

···
-{ stdenv, fetchurl, vala_0_32, libxslt, pkgconfig, glib, dbus_glib, gnome3
+{ stdenv, fetchurl, vala, libxslt, pkgconfig, glib, dbus_glib, gnome3
 , libxml2, intltool, docbook_xsl_ns, docbook_xsl, makeWrapper }:
 
 let
···
 
   outputs = [ "out" "lib" "dev" ];
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ vala_0_32 libxslt glib dbus_glib gnome3.gtk libxml2
-                  intltool docbook_xsl docbook_xsl_ns makeWrapper ];
+  nativeBuildInputs = [ vala pkgconfig intltool libxslt libxml2 docbook_xsl docbook_xsl_ns makeWrapper ];
+  buildInputs = [ glib dbus_glib ];
 
   postConfigure = stdenv.lib.optionalString stdenv.isDarwin ''
     substituteInPlace client/Makefile \

pkgs/desktops/gnome-3/core/folks/default.nix

···
   majorVersion = "0.11";
 in
 stdenv.mkDerivation rec {
-  name = "folks-${majorVersion}.3";
+  name = "folks-${majorVersion}.4";
 
   src = fetchurl {
     url = "mirror://gnome/sources/folks/${majorVersion}/${name}.tar.xz";
-    sha256 = "2a2828a7c87fd39e5786f8f2cf0ebe47576a74974f1355c478a6dc747d7bcb64";
+    sha256 = "16hqh2gxlbx0b0hgq216hndr1m72vj54jvryzii9zqkk0g9kxc57";
   };
 
   propagatedBuildInputs = [ glib gnome3.libgee sqlite ];

pkgs/desktops/gnome-3/core/grilo-plugins/default.nix

···
 
 stdenv.mkDerivation rec {
   major = "0.3";
-  minor = "3";
+  minor = "5";
   name = "grilo-plugins-${major}.${minor}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/grilo-plugins/${major}/${name}.tar.xz";
-    sha256 = "fe66e887847fef9c361bcb7226047c43b2bc22b172aaf22afd5534947cc85b9c";
+    sha256 = "1yv8a0mfd5qmdbdrnd0is5c51s1mvibhw61na99iagnbirxq4xr9";
   };
 
   installFlags = [ "GRL_PLUGINS_DIR=$(out)/lib/grilo-${major}" ];

pkgs/desktops/gnome-3/core/grilo/default.nix

···
 
 stdenv.mkDerivation rec {
   major = "0.3"; # if you change this, also change ./setup-hook.sh
-  minor = "3";
+  minor = "4";
   name = "grilo-${major}.${minor}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/grilo/${major}/${name}.tar.xz";
-    sha256 = "1qx072m0gl6m3d5g5cbbf13p4h217icmlxjnrn829x5xqwi451sw";
+    sha256 = "0vh67gja6yn7czh77ssmx6ncp99fl2926pbi2hplqms27c2n8sbw";
   };
 
   setupHook = ./setup-hook.sh;

pkgs/desktops/gnome-3/core/libgdata/default.nix

···
   majorVersion = "0.17";
 in
 stdenv.mkDerivation rec {
-  name = "libgdata-${majorVersion}.6";
+  name = "libgdata-${majorVersion}.9";
 
   src = fetchurl {
     url = "mirror://gnome/sources/libgdata/${majorVersion}/${name}.tar.xz";
-    sha256 = "8b6a3ff1db23bd9e5ebbcc958b29b769a898f892eed4798222d562ba69df30b0";
+    sha256 = "0fj54yqxdapdppisqm1xcyrpgcichdmipq0a0spzz6009ikzgi45";
   };
 
   NIX_CFLAGS_COMPILE = "-I${gnome3.libsoup.dev}/include/libsoup-gnome-2.4/ -I${gnome3.gcr}/include/gcr-3 -I${gnome3.gcr}/include/gck-1";

pkgs/desktops/gnome-3/core/libgxps/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, cairo, libarchive, freetype, libjpeg, libtiff
-, openssl, bzip2, acl, attr, libxml2
+{ stdenv, fetchurl, meson, ninja, pkgconfig, glib, gobjectIntrospection, cairo
+, libarchive, freetype, libjpeg, libtiff
 }:
 
 stdenv.mkDerivation rec {
-  name = "libgxps-0.2.2";
+  name = "libgxps-0.3.0";
 
   src = fetchurl {
-    url = "http://ftp.acc.umu.se/pub/GNOME/core/3.10/3.10.2/sources/${name}.tar.xz";
-    sha256 = "1gi0b0x0354jyqc48vspk2hg2q1403cf2p9ibj847nzhkdrh9l9r";
+    url = "mirror://gnome/sources/libgxps/0.3/${name}.tar.xz";
+    sha256 = "412b1343bd31fee41f7204c47514d34c563ae34dafa4cc710897366bd6cd0fae";
   };
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ glib cairo freetype libjpeg libtiff acl openssl bzip2 attr libxml2 ];
+  nativeBuildInputs = [ meson ninja pkgconfig gobjectIntrospection ];
+  buildInputs = [ glib cairo freetype libjpeg libtiff ];
   propagatedBuildInputs = [ libarchive ];
 
-  configureFlags = "--without-liblcms2";
+  mesonFlags = [
+    "-Denable-test=false"
+    "-Dwith-liblcms2=false"
+  ];
 
   meta = with stdenv.lib; {
     platforms = platforms.linux;

pkgs/desktops/gnome-3/core/libpeas/src.nix

···
 # Autogenerated by maintainers/scripts/gnome.sh update
 
 fetchurl: rec {
-  major = "1.18";
+  major = "1.22";
   minor = "0";
   version = "${major}.${minor}";
   name = "libpeas-${version}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/libpeas/${major}/${name}.tar.xz";
-    sha256 = "09jy2rwwgp0xx7cnypxl56m7zzxnj3j4v58xqjxjasf3chn88jdz";
+    sha256 = "0qm908kisyjzjxvygdl18hjqxvvgkq9w0phs2g55pck277sw0bsv";
   };
 }

pkgs/desktops/gnome-3/core/libzapojit/default.nix

···
   buildInputs = [ glib intltool json_glib rest libsoup gtk gnome_online_accounts ];
 
   meta = with stdenv.lib; {
+    description = "GObject wrapper for the SkyDrive and Hotmail REST APIs";
     platforms = platforms.linux;
   };
 }

pkgs/desktops/gnome-3/core/mutter/default.nix

···
-{ fetchurl, stdenv, pkgconfig, gnome3, intltool, gobjectIntrospection, upower, cairo
+{ fetchurl, fetchpatch, stdenv, pkgconfig, gnome3, intltool, gobjectIntrospection, upower, cairo
 , pango, cogl, clutter, libstartup_notification, libcanberra_gtk2, zenity, libcanberra_gtk3
 , libtool, makeWrapper, xkeyboard_config, libxkbfile, libxkbcommon, libXtst, libudev, libinput
-, libgudev, xwayland }:
+, libgudev, libwacom, xwayland, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   inherit (import ./src.nix fetchurl) name src;
···
   # fatal error: gio/gunixfdlist.h: No such file or directory
   NIX_CFLAGS_COMPILE = "-I${gnome3.glib.dev}/include/gio-unix-2.0 -Wno-error=format -Wno-error=sign-compare";
 
-  configureFlags = "--with-x --disable-static --enable-shape --enable-sm --enable-startup-notification --enable-xsync --enable-verbose-mode --with-libcanberra --with-xwayland-path=${xwayland}/bin/Xwayland";
+  configureFlags = [
+    "--with-x"
+    "--disable-static"
+    "--enable-shape"
+    "--enable-sm"
+    "--enable-startup-notification"
+    "--enable-xsync"
+    "--enable-verbose-mode"
+    "--with-libcanberra"
+    "--with-xwayland-path=${xwayland}/bin/Xwayland"
+  ];
 
   propagatedBuildInputs = [
     # required for pkgconfig to detect mutter-clutter
     libXtst
   ];
 
+  nativeBuildInputs = [ autoreconfHook pkgconfig intltool libtool makeWrapper ];
+
   buildInputs = with gnome3;
-    [ pkgconfig intltool glib gobjectIntrospection gtk gsettings_desktop_schemas upower
+    [ glib gobjectIntrospection gtk gsettings_desktop_schemas upower
       gnome_desktop cairo pango cogl clutter zenity libstartup_notification libcanberra_gtk2
-      gnome3.geocode_glib libudev libinput libgudev
-      libcanberra_gtk3 zenity libtool makeWrapper xkeyboard_config libxkbfile
+      gnome3.geocode_glib libudev libinput libgudev libwacom
+      libcanberra_gtk3 zenity xkeyboard_config libxkbfile
       libxkbcommon ];
 
+  patches = [
+    # https://bugzilla.gnome.org/show_bug.cgi?id=760670
+    (fetchpatch {
+      name = "libgudev-232.patch";
+      url = https://bugzilla.gnome.org/attachment.cgi?id=358904;
+      sha256 = "0chvd7g9f2zp3a0gdhvinsfvp2h10rwb6a8ja386vsrl93ac8pix";
+    })
+  ];
+
   preFixup = ''
     wrapProgram "$out/bin/mutter" \
       --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
   '';
-
-  patches = [
-    ./x86.patch # ./math.patch
-  ];
 
   enableParallelBuilding = true;
 

pkgs/desktops/gnome-3/core/mutter/math.patch

···
---- mutter-3.18.0/src/backends/meta-cursor-renderer.c.orig	2015-09-23 13:54:31.297523343 +0200
-+++ mutter-3.18.0/src/backends/meta-cursor-renderer.c	2015-09-23 13:54:43.728271766 +0200
-@@ -31,6 +31,7 @@
- 
- #include <cogl/cogl.h>
- #include <clutter/clutter.h>
-+#include <math.h>
- 
- #include "meta-stage.h"
- 

pkgs/desktops/gnome-3/core/mutter/x86.patch

···
---- a/src/core/window.c	2015-05-26 10:52:41.382834963 +0200
-+++ b/src/core/window.c	2015-05-26 10:53:03.039948034 +0200
-@@ -3499,7 +3499,7 @@
- 
- static MetaMonitorInfo *
- find_monitor_by_winsys_id (MetaWindow *window,
--                           guint       winsys_id)
-+                           gint       winsys_id)
- {
-   int i;
- 
-@@ -3618,7 +3618,7 @@
-    */
- 
-   gboolean did_placement;
--  guint old_output_winsys_id;
-+  gint old_output_winsys_id;
-   MetaRectangle unconstrained_rect;
-   MetaRectangle constrained_rect;
-   MetaMoveResizeResultFlags result = 0;

pkgs/desktops/gnome-3/core/totem-pl-parser/default.nix

···
 { stdenv, fetchurl, pkgconfig, file, intltool, gmime, libxml2, libsoup, gnome3 }:
 
 stdenv.mkDerivation rec {
-  name = "totem-pl-parser-3.10.2";
+  inherit (import ./src.nix fetchurl) name src;
 
-  src = fetchurl {
-    url = "mirror://gnome/sources/totem-pl-parser/3.10/${name}.tar.xz";
-    sha256 = "38be09bddc46ddecd2b5ed7c82144ef52aafe879a5ec3d8b192b4b64ba995469";
-  };
-
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ file intltool gmime libxml2 libsoup ];
+  nativeBuildInputs = [ pkgconfig file intltool ];
+  buildInputs = [ gmime libxml2 libsoup ];
 
   meta = with stdenv.lib; {
     homepage = https://wiki.gnome.org/Apps/Videos;

pkgs/desktops/gnome-3/core/totem-pl-parser/src.nix

···
+# Autogenerated by maintainers/scripts/gnome.sh update
+
+fetchurl: {
+  name = "totem-pl-parser-3.10.2";
+
+  src = fetchurl {
+    url = mirror://gnome/sources/totem-pl-parser/3.10/totem-pl-parser-3.10.2.tar.xz;
+    sha256 = "38be09bddc46ddecd2b5ed7c82144ef52aafe879a5ec3d8b192b4b64ba995469";
+  };
+}

pkgs/desktops/gnome-3/core/vte/src.nix

···
 # Autogenerated by maintainers/scripts/gnome.sh update
 
 fetchurl: {
-  name = "vte-0.48.3";
+  name = "vte-0.50.1";
 
   src = fetchurl {
-    url = mirror://gnome/sources/vte/0.48/vte-0.48.3.tar.xz;
-    sha256 = "a3a9fb182740b392a45cd3f46fa61a985f68bb6b1817b52daec22034c46158c3";
+    url = mirror://gnome/sources/vte/0.50/vte-0.50.1.tar.xz;
+    sha256 = "cf1708e3e573160e1db107014b3ef70888fefe6b668373fed70e8d1cac45a8c2";
   };
 }

pkgs/development/compilers/arachne-pnr/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "arachne-pnr-${version}";
-  version = "2017.06.29";
+  version = "2017.11.05";
 
   src = fetchFromGitHub {
-    owner = "cseed";
-    repo = "arachne-pnr";
-    rev = "7e135edb31feacde85ec5b7e5c03fc9157080977";
-    sha256 = "1wszcx6hgw4q4r778zswrlwdwvwxq834bkajck8w9yfqwxs9lmq8";
+    owner  = "cseed";
+    repo   = "arachne-pnr";
+    rev    = "1e81432830c75c505c76e419619f605a6c4c7583";
+    sha256 = "0lzblmi1klbsmd32h8nh027npm1z1a199lng13lcrqwr17lhb7my";
   };
 
   enableParallelBuilding = true;

pkgs/development/compilers/factor-lang/default.nix

···
 { stdenv, fetchurl, fetchFromGitHub, glib, glibc, git,
   rlwrap, curl, pkgconfig, perl, makeWrapper, tzdata, ncurses,
   libX11, pango, cairo, gtk2, gdk_pixbuf, gtkglext,
-  mesa, libXmu, libXt, libICE, libSM }:
+  mesa_glu, libXmu, libXt, libICE, libSM }:
 
 stdenv.mkDerivation rec {
   name = "factor-lang-${version}";
···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ git rlwrap curl perl makeWrapper
     libX11 pango cairo gtk2 gdk_pixbuf gtkglext
-    mesa libXmu libXt libICE libSM ];
+    mesa_glu libXmu libXt libICE libSM ];
 
   buildPhase = ''
     make $(bash ./build-support/factor.sh make-target) GIT_LABEL=heads/master-${rev}
···
     # to be a generic solution here.
     find $(echo ${stdenv.lib.makeLibraryPath [
         glib libX11 pango cairo gtk2 gdk_pixbuf gtkglext
-        mesa libXmu libXt libICE libSM ]} | sed -e 's#:# #g') -name \*.so.\* > $TMPDIR/so.lst
+        mesa_glu libXmu libXt libICE libSM ]} | sed -e 's#:# #g') -name \*.so.\* > $TMPDIR/so.lst
 
     (echo $(cat $TMPDIR/so.lst | wc -l) "libs found in cache \`/etc/ld.so.cache'";
     for l in $(<$TMPDIR/so.lst);
···
     wrapProgram $out/bin/factor --prefix LD_LIBRARY_PATH : \
       "${stdenv.lib.makeLibraryPath [ glib
         libX11 pango cairo gtk2 gdk_pixbuf gtkglext
-        mesa libXmu libXt libICE libSM ]}"
+        mesa_glu libXmu libXt libICE libSM ]}"
 
     sed -ie 's#/bin/.factor-wrapped#/lib/factor/factor#g' $out/bin/factor
     mv $out/bin/.factor-wrapped $out/lib/factor/factor

pkgs/development/compilers/ghc/8.2.2.nix

···
+{ stdenv, lib, fetchurl, bootPkgs, perl, ncurses, libiconv, binutils, coreutils
+, autoconf, automake, happy, alex, python3, sphinx, hscolour
+, buildPlatform, targetPlatform , selfPkgs, cross ? null
+
+  # If enabled GHC will be build with the GPL-free but slower integer-simple
+  # library instead of the faster but GPLed integer-gmp library.
+, enableIntegerSimple ? false, gmp
+}:
+
+let
+  inherit (bootPkgs) ghc;
+  version = "8.2.1.20171030";
+
+  commonBuildInputs = [ alex autoconf automake ghc happy hscolour perl python3 sphinx ];
+  commonPreConfigure =  ''
+    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
+  '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''
+    export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/ghc-${version}"
+  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+    export NIX_LDFLAGS+=" -no_dtrace_dof"
+  '' + stdenv.lib.optionalString enableIntegerSimple ''
+    echo "INTEGER_LIBRARY=integer-simple" > mk/build.mk
+  '';
+in stdenv.mkDerivation (rec {
+  inherit version;
+  name = "ghc-${version}";
+
+  src = fetchurl {
+    url = "https://downloads.haskell.org/~ghc/8.2.2-rc2/${name}-src.tar.xz";
+    sha256 = "0m2lx13yscgxmb18nrzhgg5h4kwzcnxdw7rjcqwx4dcwl1k0a724";
+  };
+
+  postPatch = "patchShebangs .";
+
+  patches = [ ./ghc-gold-linker.patch ];
+
+  preConfigure = commonPreConfigure;
+
+  buildInputs = commonBuildInputs;
+
+  enableParallelBuilding = true;
+
+  configureFlags = [
+    "CC=${stdenv.cc}/bin/cc"
+    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
+    "--datadir=$doc/share/doc/ghc"
+  ] ++ stdenv.lib.optional (! enableIntegerSimple) [
+    "--with-gmp-includes=${gmp.dev}/include" "--with-gmp-libraries=${gmp.out}/lib"
+  ] ++ stdenv.lib.optional stdenv.isDarwin [
+    "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"
+  ];
+
+  # required, because otherwise all symbols from HSffi.o are stripped, and
+  # that in turn causes GHCi to abort
+  stripDebugFlags = [ "-S" ] ++ stdenv.lib.optional (!stdenv.isDarwin) "--keep-file-symbols";
+
+  checkTarget = "test";
+
+  postInstall = ''
+    paxmark m $out/lib/${name}/bin/{ghc,haddock}
+
+    # Install the bash completion file.
+    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/ghc
+
+    # Patch scripts to include "readelf" and "cat" in $PATH.
+    for i in "$out/bin/"*; do
+      test ! -h $i || continue
+      egrep --quiet '^#!' <(head -n 1 $i) || continue
+      sed -i -e '2i export PATH="$PATH:${stdenv.lib.makeBinPath [ binutils coreutils ]}"' $i
+    done
+  '';
+
+  outputs = [ "out" "doc" ];
+
+  passthru = {
+    inherit bootPkgs;
+  } // stdenv.lib.optionalAttrs (targetPlatform != buildPlatform) {
+    crossCompiler = selfPkgs.ghc.override {
+      cross = targetPlatform;
+      bootPkgs = selfPkgs;
+    };
+  };
+
+  meta = {
+    homepage = http://haskell.org/ghc;
+    description = "The Glasgow Haskell Compiler";
+    maintainers = with stdenv.lib.maintainers; [ marcweber andres peti ];
+    inherit (ghc.meta) license platforms;
+  };
+
+} // stdenv.lib.optionalAttrs (cross != null) {
+  name = "${cross.config}-ghc-${version}";
+
+  preConfigure = commonPreConfigure + ''
+    sed 's|#BuildFlavour  = quick-cross|BuildFlavour  = perf-cross|' mk/build.mk.sample > mk/build.mk
+  '';
+
+  configureFlags = [
+    "CC=${stdenv.ccCross}/bin/${cross.config}-cc"
+    "LD=${stdenv.binutils}/bin/${cross.config}-ld"
+    "AR=${stdenv.binutils}/bin/${cross.config}-ar"
+    "NM=${stdenv.binutils}/bin/${cross.config}-nm"
+    "RANLIB=${stdenv.binutils}/bin/${cross.config}-ranlib"
+    "--target=${cross.config}"
+    "--enable-bootstrap-with-devel-snapshot"
+  ] ++
+    # fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
+    lib.optional (cross.config or null == "aarch64-apple-darwin14") "--disable-large-address-space";
+
+  buildInputs = commonBuildInputs ++ [ stdenv.ccCross stdenv.binutils ];
+
+  dontSetConfigureCross = true;
+
+  passthru = {
+    inherit bootPkgs cross;
+    cc = "${stdenv.ccCross}/bin/${cross.config}-cc";
+    ld = "${stdenv.binutils}/bin/${cross.config}-ld";
+  };
+})

pkgs/development/compilers/orc/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "orc-0.4.26";
+  name = "orc-0.4.27";
 
   src = fetchurl {
-    url = "http://gstreamer.freedesktop.org/src/orc/${name}.tar.xz";
-    sha256 = "0jd69ynvr3k70mlxxgbsk047l1rd63m1wkj3qdcq7644xy0gllkx";
+    url = "https://gstreamer.freedesktop.org/src/orc/${name}.tar.xz";
+    sha256 = "14vbwdydwarcvswzf744jdjb3ibhv6k4j6hzdacfan41zic3xrai";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/sbcl/1.2.0.nix

···
-{ stdenv, fetchurl, sbclBootstrap, clisp}:
-
-stdenv.mkDerivation rec {
-  name    = "sbcl-${version}";
-  version = "1.2.0";
-
-  src = fetchurl {
-    url    = "mirror://sourceforge/project/sbcl/sbcl/${version}/${name}-source.tar.bz2";
-    sha256 = "13k20sys1v4lvgis8cnbczww6zs93rw176vz07g4jx06418k53x2";
-  };
-
-  buildInputs = [ ]
-    ++ (stdenv.lib.optional stdenv.isDarwin sbclBootstrap)
-    ++ (stdenv.lib.optional stdenv.isLinux clisp)
-    ;
-
-  patchPhase = ''
-    echo '"${version}.nixos"' > version.lisp-expr
-    echo "
-    (lambda (features)
-      (flet ((enable (x)
-               (pushnew x features))
-             (disable (x)
-               (setf features (remove x features))))
-        (enable :sb-thread))) " > customize-target-features.lisp
-
-    pwd
-
-    # SBCL checks whether files are up-to-date in many places..
-    # Unfortunately, same timestamp is not good enough
-    sed -e 's@> x y@>= x y@' -i contrib/sb-aclrepl/repl.lisp
-    sed -e '/(date)/i((= date 2208988801) 2208988800)' -i contrib/asdf/asdf.lisp
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date input/a)'
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date output/i(or (and (= 2208988801 (file-write-date output)) (= 2208988801 (file-write-date input)))'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-fasl/a)'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-source/i(or (and (= 2208988801 (file-write-date defaulted-source-truename)) (= 2208988801 (file-write-date defaulted-fasl-truename)))'
-
-    # Fix the tests
-    sed -e '/deftest pwent/inil' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest grent/inil' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest .*ent.non-existing/,+5d' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest \(pw\|gr\)ent/,+3d' -i contrib/sb-posix/posix-tests.lisp
-
-    sed -e '5,$d' -i contrib/sb-bsd-sockets/tests.lisp
-    sed -e '5,$d' -i contrib/sb-simple-streams/*test*.lisp
-
-    # Use whatever `cc` the stdenv provides
-    substituteInPlace src/runtime/Config.x86-64-darwin --replace gcc cc
-
-    substituteInPlace src/runtime/Config.x86-64-darwin \
-      --replace mmacosx-version-min=10.4 mmacosx-version-min=10.5
-  '';
-
-  preBuild = ''
-    export INSTALL_ROOT=$out
-    mkdir -p test-home
-    export HOME=$PWD/test-home
-  '';
-
-  buildPhase = if stdenv.isLinux
-    then ''
-      sh make.sh clisp --prefix=$out
-    ''
-    else ''
-      sh make.sh --prefix=$out --xc-host='${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit'
-    '';
-
-  installPhase = ''
-    INSTALL_ROOT=$out sh install.sh
-  '';
-
-  meta = {
-    description = "Lisp compiler";
-    homepage = http://www.sbcl.org;
-    license = stdenv.lib.licenses.bsd3;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.all;
-    inherit version;
-  };
-}

pkgs/development/compilers/sbcl/1.3.12.nix

···
-{ stdenv, fetchurl, writeText, sbclBootstrap
-, sbclBootstrapHost ? "${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit"
-, threadSupport ? (stdenv.isi686 || stdenv.isx86_64)
-  # Meant for sbcl used for creating binaries portable to non-NixOS via save-lisp-and-die.
-  # Note that the created binaries still need `patchelf --set-interpreter ...`
-  # to get rid of ${glibc} dependency.
-, purgeNixReferences ? false
-}:
-
-stdenv.mkDerivation rec {
-  name    = "sbcl-${version}";
-  version = "1.3.12";
-
-  src = fetchurl {
-    url    = "mirror://sourceforge/project/sbcl/sbcl/${version}/${name}-source.tar.bz2";
-    sha256 = "1hjr2xqazy4j0m58y4na6fz8ii3xflqairxy7vpd7ajbs00yqfc0";
-  };
-
-  patchPhase = ''
-    echo '"${version}.nixos"' > version.lisp-expr
-    echo "
-    (lambda (features)
-      (flet ((enable (x)
-               (pushnew x features))
-             (disable (x)
-               (setf features (remove x features))))
-    ''
-    + (if threadSupport then "(enable :sb-thread)" else "(disable :sb-thread)")
-    + stdenv.lib.optionalString stdenv.isArm "(enable :arm)"
-    + ''
-      )) " > customize-target-features.lisp
-
-    pwd
-
-    # SBCL checks whether files are up-to-date in many places..
-    # Unfortunately, same timestamp is not good enough
-    sed -e 's@> x y@>= x y@' -i contrib/sb-aclrepl/repl.lisp
-    sed -e '/(date)/i((= date 2208988801) 2208988800)' -i contrib/asdf/asdf.lisp
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date input/a)'
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date output/i(or (and (= 2208988801 (file-write-date output)) (= 2208988801 (file-write-date input)))'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-fasl/a)'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-source/i(or (and (= 2208988801 (file-write-date defaulted-source-truename)) (= 2208988801 (file-write-date defaulted-fasl-truename)))'
-
-    # Fix the tests
-    sed -e '/deftest pwent/inil' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest grent/inil' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest .*ent.non-existing/,+5d' -i contrib/sb-posix/posix-tests.lisp
-    sed -e '/deftest \(pw\|gr\)ent/,+3d' -i contrib/sb-posix/posix-tests.lisp
-
-    sed -e '5,$d' -i contrib/sb-bsd-sockets/tests.lisp
-    sed -e '5,$d' -i contrib/sb-simple-streams/*test*.lisp
-
-    # Use whatever `cc` the stdenv provides
-    substituteInPlace src/runtime/Config.x86-64-darwin --replace gcc cc
-
-    substituteInPlace src/runtime/Config.x86-64-darwin \
-      --replace mmacosx-version-min=10.4 mmacosx-version-min=10.5
-  ''
-  + (if purgeNixReferences
-    then
-      # This is the default location to look for the core; by default in $out/lib/sbcl
-      ''
-        sed 's@^\(#define SBCL_HOME\) .*$@\1 "/no-such-path"@' \
-          -i src/runtime/runtime.c
-      ''
-    else
-      # Fix software version retrieval
-      ''
-        sed -e "s@/bin/uname@$(command -v uname)@g" -i src/code/*-os.lisp
-      ''
-    );
-
-
-  preBuild = ''
-    export INSTALL_ROOT=$out
-    mkdir -p test-home
-    export HOME=$PWD/test-home
-  '';
-
-  buildPhase = ''
-    sh make.sh --prefix=$out --xc-host="${sbclBootstrapHost}"
-  '';
-
-  installPhase = ''
-    INSTALL_ROOT=$out sh install.sh
-  '';
-
-  # Specifying $SBCL_HOME is only truly needed with `purgeNixReferences = true`.
-  setupHook = writeText "setupHook.sh" ''
-    envHooks+=(_setSbclHome)
-    _setSbclHome() {
-      export SBCL_HOME='@out@/lib/sbcl/'
-    }
-  '';
-
-  meta = sbclBootstrap.meta // {
-    inherit version;
-    updateWalker = true;
-  };
-}

pkgs/development/compilers/sbcl/default.nix

···
-{ stdenv, fetchurl, writeText, sbclBootstrap
+{ stdenv, fetchurl, fetchgit, writeText, sbclBootstrap
 , sbclBootstrapHost ? "${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit"
 , threadSupport ? (stdenv.isi686 || stdenv.isx86_64 || "aarch64-linux" == stdenv.system)
   # Meant for sbcl used for creating binaries portable to non-NixOS via save-lisp-and-die.
···
 
 stdenv.mkDerivation rec {
   name    = "sbcl-${version}";
-  version = "1.4.0";
+  version = "1.4.1.0.20171104";
 
-  src = fetchurl {
-    url    = "mirror://sourceforge/project/sbcl/sbcl/${version}/${name}-source.tar.bz2";
-    sha256 = "0s87ax5hg9hz6b8kc9yrjckgz56s9iv96l2dcq216cbqkykrrm88";
+  #src = fetchurl {
+  #  url    = "mirror://sourceforge/project/sbcl/sbcl/${version}/${name}-source.tar.bz2";
+  #  sha256 = "1qdaf847g5p2zgq00ax5hdy4r82bl3ss382psd0kkca1h83cdiz8";
+  #};
+  src = fetchgit {
+    url    = "https://git.code.sf.net/p/sbcl/sbcl";
+    sha256 = "1fq34h8h8pax5q17w84kwv5amiaag3ikkq3cdmb31r64736mxi6r";
+    rev    = "11aa57d23bc464d6a6867a80e946907404ceadd1";
   };
 
   patchPhase = ''
···
     # SBCL checks whether files are up-to-date in many places..
     # Unfortunately, same timestamp is not good enough
     sed -e 's@> x y@>= x y@' -i contrib/sb-aclrepl/repl.lisp
-    sed -e '/(date)/i((= date 2208988801) 2208988800)' -i contrib/asdf/asdf.lisp
+    #sed -e '/(date)/i((= date 2208988801) 2208988800)' -i contrib/asdf/asdf.lisp
     sed -i src/cold/slam.lisp -e \
       '/file-write-date input/a)'
     sed -i src/cold/slam.lisp -e \

pkgs/development/compilers/yosys/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "yosys-${version}";
-  version = "2017.10.16";
+  version = "2017.11.05";
 
   srcs = [
     (fetchFromGitHub {
       owner = "cliffordwolf";
       repo = "yosys";
-      rev = "716dbc92745aa8b41d85a60d50263433d5a79393";
-      sha256 = "0va77my4iddsw6psgjfhfgs0z0z1hpj0l8ipchcl8crpxipxcr77";
+      rev = "4f31cb6daddedcee467d85797d81b79360ce1826";
+      sha256 = "1a5n0g5kpjsy8f99f64w81gkrr450wvffp407r1pddl8pmb0c3r7";
       name = "yosys";
     })
     (fetchFromBitbucket {
       owner = "alanmi";
       repo = "abc";
-      rev = "6283c5d99b06";
-      sha256 = "1mv8r1la4d4r9bk32sl4nq3flyxi8jf2ccaak64j5rz9hirrlpla";
+      rev = "f6838749f234";
+      sha256 = "0n7ywvih958h1c4n7a398a9w3qikhkv885fx5j3y2a0xwqc86m4y";
       name = "yosys-abc";
     })
   ];

pkgs/development/coq-modules/bignums/default.nix

···
+{ stdenv, fetchFromGitHub, coq }:
+
+let rev_and_sha = {
+  "8.6" = {
+    rev = "v8.6.0";
+    sha256 = "0553pcsy21cyhmns6k9qggzb67az8kl31d0lwlnz08bsqswigzrj";
+  };
+  "8.7" = {
+    rev = "V8.7.0";
+    sha256 = "11c4sdmpd3l6jjl4v6k213z9fhrmmm1xnly3zmzam1wrrdif4ghl";
+  };
+};
+in
+
+if ! (rev_and_sha ? "${coq.coq-version}") then
+  throw "bignums is not available for Coq ${coq.coq-version}"
+else with rev_and_sha."${coq.coq-version}";
+
+stdenv.mkDerivation rec {
+
+  name = "coq${coq.coq-version}-bignums";
+
+  src = fetchFromGitHub {
+    owner = "coq";
+    repo = "bignums";
+    inherit rev sha256;
+  };
+
+  buildInputs = [ coq.ocaml coq.camlp5 coq.findlib coq ];
+
+  installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
+
+  meta = with stdenv.lib; {
+    license = licenses.lgpl2;
+    platforms = coq.meta.platforms;
+  };
+
+}

pkgs/development/coq-modules/math-classes/default.nix

···
-{ stdenv, fetchurl, coq }:
+{ stdenv, fetchFromGitHub, coq, coqPackages }:
+
+if ! stdenv.lib.versionAtLeast coq.coq-version "8.6" then
+  throw "Math-Classes requires Coq 8.6 or later."
+else
+
+stdenv.mkDerivation rec {
 
-stdenv.mkDerivation {
-  name = "coq${coq.coq-version}-math-classes-1.0.6";
+  name = "coq${coq.coq-version}-math-classes-${version}";
+  version = "1.0.7";
 
-  src = fetchurl {
-    url = https://github.com/math-classes/math-classes/archive/1.0.6.tar.gz;
-    sha256 = "071hgjk4bz2ybci7dp2mw7xqmxmm2zph7kj28xcdg28iy796lf02";
+  src = fetchFromGitHub {
+    owner = "math-classes";
+    repo = "math-classes";
+    rev = version;
+    sha256 = "0wgnczacvkb2pc3vjbni9bwjijfyd5jcdnyyjg8185hkf9zzabgi";
   };
 
-  # src = fetchFromGitHub {
-  #   owner  = "math-classes";
-  #   repo   = "math-classes";
-  #   rev    = "1d426a08c2fbfd68bd1b3622fe8f31dd03712e6c";
-  #   sha256 = "3kjc2wzb6n9hcqb2ijx2pckn8jk5g09crrb87yb4s9m0mrw79smr";
-  # };
-
-  buildInputs = [ coq ];
+  buildInputs = [ coq coqPackages.bignums ];
   enableParallelBuilding = true;
   installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
 

pkgs/development/go-modules/generic/default.nix

···
-{ go, govers, parallel, lib, fetchgit, fetchhg, fetchbzr, rsync, removeReferencesTo }:
+{ go, govers, parallel, lib, fetchgit, fetchhg, fetchbzr, rsync
+, removeReferencesTo, fetchFromGitHub }:
 
 { name, buildInputs ? [], nativeBuildInputs ? [], passthru ? {}, preFixup ? ""
 
···
       else if goDep.fetch.type == "bzr" then
         fetchbzr {
           inherit (goDep.fetch) url rev sha256;
+        }
+      else if goDep.fetch.type == "FromGitHub" then
+        fetchFromGitHub {
+          inherit (goDep.fetch) owner repo rev sha256;
         }
       else abort "Unrecognized package fetch type: ${goDep.fetch.type}";
     };

pkgs/development/haskell-modules/hackage-packages.nix

···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "HUnit-approx_1_1_1_1" = callPackage
+    ({ mkDerivation, base, call-stack, HUnit }:
+     mkDerivation {
+       pname = "HUnit-approx";
+       version = "1.1.1.1";
+       sha256 = "1brblqpz002jzql9wgzxk5zlfglmkv91s8gcfd6992xv539jfhsa";
+       libraryHaskellDepends = [ base call-stack HUnit ];
+       testHaskellDepends = [ base call-stack HUnit ];
+       homepage = "https://github.com/goldfirere/HUnit-approx";
+       description = "Approximate equality for floating point numbers with HUnit";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "HXMPP" = callPackage
     ({ mkDerivation, base, base64-string, binary, bytestring
      , crypto-api, enumerator, HLogger, network, pureMD5, random
···
        homepage = "https://github.com/mrkkrp/JuicyPixels-extra";
        description = "Efficiently scale, crop, flip images with JuicyPixels";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "JuicyPixels-extra_0_2_2" = callPackage
+    ({ mkDerivation, base, criterion, hspec, JuicyPixels }:
+     mkDerivation {
+       pname = "JuicyPixels-extra";
+       version = "0.2.2";
+       sha256 = "1f0ysxwd73s04mrqzqj9rfp6dd5441ckc96x2a4zkc1hixgkfzld";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base JuicyPixels ];
+       testHaskellDepends = [ base hspec JuicyPixels ];
+       benchmarkHaskellDepends = [ base criterion JuicyPixels ];
+       homepage = "https://github.com/mrkkrp/JuicyPixels-extra";
+       description = "Efficiently scale, crop, flip images with JuicyPixels";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "JuicyPixels-repa" = callPackage
···
      }:
      mkDerivation {
        pname = "STLinkUSB";
-       version = "0.1.0";
-       sha256 = "17rqwr9f0g9p4i7qw4gih1g7wj2y7d7bdma55warp82v0v996ypr";
+       version = "0.1.1";
+       sha256 = "1b0cxrjbldsdh948fa3d5qr0lmjl2g5qkh7ii4smkmsakzk9jx0s";
        libraryHaskellDepends = [
          base binary bytestring transformers usb vector
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "STM32-Zombie" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, STLinkUSB
+     , STM32F103xx-SVD, transformers
+     }:
+     mkDerivation {
+       pname = "STM32-Zombie";
+       version = "0.2.0";
+       sha256 = "10vknxgihz3cgyzi1rmyh30zqyg0q7ll653ljndjj8lh3hnghajx";
+       libraryHaskellDepends = [
+         base binary bytestring containers STLinkUSB STM32F103xx-SVD
+         transformers
+       ];
+       description = "control a STM32F103 microcontroller";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "STM32F103xx-SVD" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "STM32F103xx-SVD";
+       version = "0.1";
+       sha256 = "0m6vvj4mfmmn1r21aglwdb6801bwr0ks60vbwz7y1cb97vsdad9v";
+       libraryHaskellDepends = [ base ];
+       description = "Definition for Peripherals,Registers and Fields from STM32F103xx.svd";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "STMonadTrans" = callPackage
     ({ mkDerivation, array, base, Cabal, mtl }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "SVD2HS" = callPackage
+    ({ mkDerivation, base, containers, pretty, text, xml-conduit
+     , xml-lens
+     }:
+     mkDerivation {
+       pname = "SVD2HS";
+       version = "0.1";
+       sha256 = "16crp18wyp7gb99x0vmjcqdwvsvns2kppaic3aspnidlc14hwg35";
+       libraryHaskellDepends = [
+         base containers pretty text xml-conduit xml-lens
+       ];
+       description = "translate a SVD of a Microcontroller to Haskell tables";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "SVG2Q" = callPackage
     ({ mkDerivation, base, haskell98, language-c, pretty, svgutils, syb
      , xml
···
      }:
      mkDerivation {
        pname = "TeX-my-math";
-       version = "0.201.1.0";
-       sha256 = "13rf0q74kk8lmgwfxicgf2d83b1jnvyq623pykm5z4g3cnap4nn4";
+       version = "0.201.1.1";
+       sha256 = "064ram3i1a59ypd8i3wnp7x9vbkc8zawby52676y4pfkqvddnhnm";
        libraryHaskellDepends = [
          base decimal-literals dumb-cas hashable haskell-src-meta HaTeX
          template-haskell text unordered-containers vector-space void
···
      }:
      mkDerivation {
        pname = "aivika";
-       version = "5.3.1";
-       sha256 = "1qgccxz77fa3j6vakg14z81wqw3259zrgg3xvfmrizshxnp1vh54";
+       version = "5.4";
+       sha256 = "1ymzhbmff1wnpksnad0dc47xa0iha5pf6w3ng6gykni2wx8smsgv";
        libraryHaskellDepends = [
          array base binary containers deepseq mtl mwc-random random vector
        ];
···
      }:
      mkDerivation {
        pname = "aivika-lattice";
-       version = "0.4";
-       sha256 = "0fczcyg9bmijjwzh4x2kgs5q0x5swz17b51cv298ka4cmbqbhmgv";
+       version = "0.5";
+       sha256 = "05s7mv2k8211qmrqh8m1xfzpnm7g6x0b9asqlizgqrxq0n5vdyhj";
        libraryHaskellDepends = [
          aivika aivika-transformers array base containers mtl mwc-random
          random
···
      }:
      mkDerivation {
        pname = "aivika-transformers";
-       version = "5.3";
-       sha256 = "08c8hkc1sbq08dsj25sb6ik9nq0insv0k8j42klbpgzmmc4pjvxd";
+       version = "5.4";
+       sha256 = "0if4i3jsc0bf8l0grdrijyzs5h5c85nq328gkwpmzpmawzssbqr5";
        libraryHaskellDepends = [
          aivika array base containers mtl mwc-random random vector
        ];
···
          text xmlgen
        ];
        description = "utility library for Alfred version 2";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "alg" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "alg";
+       version = "0.2.0.0";
+       sha256 = "1lh5pz3zmzyq9dkgzabgi8xhlssxccxw24ng97lynmsvc7jjras8";
+       libraryHaskellDepends = [ base ];
+       description = "Algebraic structures";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
 
   "apiary-http-client" = callPackage
     ({ mkDerivation, apiary, base, bytestring, bytestring-builder
-     , http-client, http-types, text, transformers, types-compat, wai
+     , http-client, http-types, text, transformers, wai
      }:
      mkDerivation {
        pname = "apiary-http-client";
-       version = "0.1.3.0";
-       sha256 = "1p1scvv9m93g11xy7fix10nyw1ps4261v9h98k77z2hmhcvwnrpd";
+       version = "0.1.4.0";
+       sha256 = "0y5sl8xy2ginmb97495xb3dzzczjvrznfrdklvrbsrll9a4b5iia";
        libraryHaskellDepends = [
          apiary base bytestring bytestring-builder http-client http-types
-         text transformers types-compat wai
+         text transformers wai
        ];
        homepage = "https://github.com/winterland1989/apiary-http-client";
        description = "A http client for Apiary";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "boop" = callPackage
+    ({ mkDerivation, base, mtl, text }:
+     mkDerivation {
+       pname = "boop";
+       version = "0.1.0.0";
+       sha256 = "1gn4b8y6dlhhf1vi92km32lyryl25xvbc8akbq1xxgn16iq49y8c";
+       libraryHaskellDepends = [ base mtl text ];
+       testHaskellDepends = [ base ];
+       homepage = "https://github.com/tdammers/boop";
+       description = "OOP primitives for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "bootstrap-types" = callPackage
     ({ mkDerivation, base, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "buffer";
-       version = "0.5.0.1";
-       sha256 = "09dwscqkdppmiprz8k0rfxkwf7qd8b6md8iviqmxw3wamm9qx7dl";
+       version = "0.5.3";
+       sha256 = "0bf9y6rb3q26rk6qd7a2mjlb1gd1gp2k080ywhp5g48l474h6p26";
        libraryHaskellDepends = [ base base-prelude bug bytestring ];
        testHaskellDepends = [
          bug quickcheck-instances rerebase tasty tasty-hunit
···
        homepage = "https://github.com/phadej/cabal-doctest";
        description = "A Setup.hs helper for doctests running";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "cabal-doctest_1_0_3" = callPackage
+    ({ mkDerivation, base, Cabal, directory, filepath }:
+     mkDerivation {
+       pname = "cabal-doctest";
+       version = "1.0.3";
+       sha256 = "1qyqxmw5z1418jda3q5j04pknqirfrfrqigibbxi4n31ajwlfisc";
+       libraryHaskellDepends = [ base Cabal directory filepath ];
+       homepage = "https://github.com/phadej/cabal-doctest";
+       description = "A Setup.hs helper for doctests running";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "cabal-file-th" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "checkers_0_4_9" = callPackage
+  "checkers_0_4_9_5" = callPackage
     ({ mkDerivation, array, base, QuickCheck, random, semigroupoids }:
      mkDerivation {
        pname = "checkers";
-       version = "0.4.9";
-       sha256 = "1vpyyhvq1xkq8pxz2xpmw14yldn8ks95zaijpqxdzsmq4v3sy83a";
+       version = "0.4.9.5";
+       sha256 = "1xaffx0vmq4swciyq3qzjfklfj19nnhd5yama9di5sas4f8v517i";
        libraryHaskellDepends = [
          array base QuickCheck random semigroupoids
        ];
+       homepage = "https://github.com/conal/checkers";
        description = "Check properties on standard classes and data structures";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "checkmate";
-       version = "0.3.0";
-       sha256 = "0yqinjpc65flh50kb2jax10lrmcbp8lcy36ivrya180wdfvlcm0n";
+       version = "0.3.2";
+       sha256 = "1s79cpi5hzfb59705i6gdvicczvddsbikcwwqx22v3yfyakbbxww";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        homepage = "https://github.com/spoqa/checkmate#readme";
        description = "Generate checklists relevant to a given patch";
-       license = stdenv.lib.licenses.gpl3;
+       license = stdenv.lib.licenses.agpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "columbia";
-       version = "0.1.1";
-       sha256 = "10yd0rp9zzdsx2hcb7gn0yxz8b9zj0pfy4g8d09qgs3c8lg8fdan";
+       version = "0.1.2";
+       sha256 = "1mayj9bzjrf37chd37mnwr6xbc126n4cbsdjzb2fy87q3vy4g7bh";
        libraryHaskellDepends = [
          array base bytestring containers contravariant data-endian
          directory filelock invariant mmap mmorph monad-loops mtl parallel
···
   "conduit-algorithms" = callPackage
     ({ mkDerivation, async, base, bytestring, bzlib-conduit, conduit
      , conduit-combinators, conduit-extra, containers, deepseq
-     , directory, filepath, HUnit, mtl, resourcet, stm, stm-chans
-     , stm-conduit, test-framework, test-framework-hunit
-     , test-framework-th, transformers, unix
+     , directory, HUnit, mtl, resourcet, stm, stm-conduit
+     , test-framework, test-framework-hunit, test-framework-th
+     , transformers
      }:
      mkDerivation {
        pname = "conduit-algorithms";
-       version = "0.0.6.0";
-       sha256 = "0b3wpmx35bl85mzy9v0hiz48flzv2vjdimkgdv58si24l3drg6g6";
+       version = "0.0.6.1";
+       sha256 = "0zs7klxlkirch0j7gasxqalfw9nc4pfslgrg93jwn5vhpxdxhgwk";
        libraryHaskellDepends = [
          async base bytestring bzlib-conduit conduit conduit-combinators
-         conduit-extra containers deepseq directory filepath mtl resourcet
-         stm stm-chans stm-conduit transformers unix
+         conduit-extra containers deepseq mtl resourcet stm stm-conduit
+         transformers
        ];
        testHaskellDepends = [
          async base bytestring bzlib-conduit conduit conduit-combinators
-         conduit-extra containers deepseq directory filepath HUnit mtl
-         resourcet stm stm-chans stm-conduit test-framework
-         test-framework-hunit test-framework-th transformers unix
+         conduit-extra containers deepseq directory HUnit mtl resourcet stm
+         stm-conduit test-framework test-framework-hunit test-framework-th
+         transformers
        ];
        description = "Conduit-based algorithms";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "conduit-resumablesink" = callPackage
-    ({ mkDerivation, base, bytestring, conduit, hspec, transformers
-     , void
+    ({ mkDerivation, base, bytestring, conduit, hspec, resourcet
+     , transformers, void
      }:
      mkDerivation {
        pname = "conduit-resumablesink";
-       version = "0.1.1";
-       sha256 = "1bqdpnhqjh4dhvppsa8nlgja0jpdw48kxywz2999sp5hi53qxdfg";
+       version = "0.2";
+       sha256 = "0pk4qvsxmmvrx9kfypbsjiq6kgcma73w97873rk3nrc9vdcm888v";
        libraryHaskellDepends = [ base conduit void ];
        testHaskellDepends = [
-         base bytestring conduit hspec transformers void
+         base bytestring conduit hspec resourcet transformers void
        ];
        homepage = "http://github.com/A1kmm/conduit-resumablesink";
        description = "Allows conduit to resume sinks to feed multiple sources into it";
···
 
   "conduit-throttle" = callPackage
     ({ mkDerivation, async, base, conduit, conduit-combinators
-     , conduit-extra, HUnit, resourcet, stm, stm-chans, stm-conduit
-     , test-framework, test-framework-hunit, throttle-io-stream
-     , unliftio, unliftio-core
+     , conduit-extra, HUnit, monad-control, resourcet, stm, stm-chans
+     , stm-conduit, test-framework, test-framework-hunit
+     , throttle-io-stream, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "conduit-throttle";
-       version = "0.2.0.1";
-       sha256 = "0402bnj5z4m2lqgagbw8rc7c8vmm3sldp1vcrywd5zvcp5031xsa";
+       version = "0.3.0.0";
+       sha256 = "1kwrryplhck8q6hn6lx6j741d9hllzf84ykmqwiq0h34fjdd0a4r";
        libraryHaskellDepends = [
-         async base conduit conduit-combinators conduit-extra resourcet stm
-         stm-chans throttle-io-stream unliftio unliftio-core
+         async base conduit conduit-combinators conduit-extra monad-control
+         resourcet stm stm-chans throttle-io-stream unliftio unliftio-core
        ];
        testHaskellDepends = [
          async base conduit conduit-combinators conduit-extra HUnit
-         resourcet stm stm-chans stm-conduit test-framework
+         monad-control resourcet stm stm-chans stm-conduit test-framework
          test-framework-hunit throttle-io-stream unliftio unliftio-core
        ];
        homepage = "https://github.com/mtesseract/conduit-throttle#readme";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "content-store" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cond, conduit
+     , conduit-combinators, conduit-extra, cryptonite, directory
+     , filepath, hspec, htoml, memory, monad-control, mtl, resourcet
+     , temporary, text, transformers, transformers-base, unix
+     }:
+     mkDerivation {
+       pname = "content-store";
+       version = "0.1.0";
+       sha256 = "1qimbnqfvnl7zhcpklnzp2n7s7swq5knif6li29fyvfb6ls1471c";
+       libraryHaskellDepends = [
+         aeson base bytestring cond conduit conduit-combinators
+         conduit-extra cryptonite directory filepath htoml memory
+         monad-control mtl resourcet temporary text transformers
+         transformers-base unix
+       ];
+       testHaskellDepends = [ base bytestring hspec memory ];
+       homepage = "https://github.com/weldr/content-store";
+       description = "Store and retrieve data from an on-disk store";
+       license = "LGPL";
+     }) {};
+
   "context-free-grammar" = callPackage
     ({ mkDerivation, array, base, containers, control-monad-omega
      , dlist, HUnit, mtl, pretty, QuickCheck, quickcheck-properties
···
        hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
      }) {};
 
-  "dejafu_0_9_0_1" = callPackage
+  "dejafu_0_9_0_2" = callPackage
     ({ mkDerivation, base, concurrency, containers, deepseq, exceptions
      , leancheck, random, ref-fd, transformers, transformers-base
      }:
      mkDerivation {
        pname = "dejafu";
-       version = "0.9.0.1";
-       sha256 = "18i21basz8d50axa1ccgz9djghd95iazv4k7x499fff1nak39147";
+       version = "0.9.0.2";
+       sha256 = "1mxg88jlr6qga82s37xs9mwq2y26vgfkd9dg9j9mxwdzw39581gr";
        libraryHaskellDepends = [
          base concurrency containers deepseq exceptions leancheck random
          ref-fd transformers transformers-base
···
      }) {};
 
   "dhall" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, bytestring, case-insensitive
-     , charset, containers, contravariant, exceptions, http-client
-     , http-client-tls, lens, optparse-generic, parsers, prettyprinter
-     , system-fileio, system-filepath, tasty, tasty-hunit, text
-     , text-format, transformers, trifecta, unordered-containers, vector
+    ({ mkDerivation, ansi-wl-pprint, base, base16-bytestring
+     , bytestring, case-insensitive, charset, containers, contravariant
+     , cryptohash, exceptions, http-client, http-client-tls, lens
+     , optparse-generic, parsers, prettyprinter, system-fileio
+     , system-filepath, tasty, tasty-hunit, text, text-format
+     , transformers, trifecta, unordered-containers, vector
      }:
      mkDerivation {
        pname = "dhall";
-       version = "1.7.0";
-       sha256 = "1177px9xlvby3wbhwgrvx23wxgmcqhl3qllbry6k42rbgf7rw900";
+       version = "1.8.0";
+       sha256 = "0bfnylfjqp8065i2akz5b8p55c45396hi8h6lx0jkl1i597567c4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-wl-pprint base bytestring case-insensitive charset containers
-         contravariant exceptions http-client http-client-tls lens parsers
-         prettyprinter system-fileio system-filepath text text-format
-         transformers trifecta unordered-containers vector
+         ansi-wl-pprint base base16-bytestring bytestring case-insensitive
+         charset containers contravariant cryptohash exceptions http-client
+         http-client-tls lens parsers prettyprinter system-fileio
+         system-filepath text text-format transformers trifecta
+         unordered-containers vector
        ];
        executableHaskellDepends = [
          base optparse-generic prettyprinter system-filepath text trifecta
···
      }:
      mkDerivation {
        pname = "dhall-bash";
-       version = "1.0.5";
-       sha256 = "1cicl18sz969ws64jybxsibcbk1686mfia9avw8asy1fmr2w6ryv";
+       version = "1.0.6";
+       sha256 = "1wjwjpprvd90dpmxij5zj1gr5x41bvzmr4qwyfhxd2am6bzg5n5d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dhall-json";
-       version = "1.0.7";
-       sha256 = "1wgzj9gfvxs2yvh0hnncfck2qbf4fhqpnibl6n10d0hllmvdbq1b";
+       version = "1.0.8";
+       sha256 = "0icwbsx7a6m62klyghllvwj474f2kxghh40d7f5v01l135qrg8a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "dhall-nix" = callPackage
     ({ mkDerivation, base, containers, data-fix, dhall, hnix
-     , neat-interpolation, optparse-generic, text, trifecta, vector
+     , neat-interpolation, optparse-generic, text, text-format, trifecta
+     , vector
      }:
      mkDerivation {
        pname = "dhall-nix";
-       version = "1.0.8";
-       sha256 = "1z6jgcfk1zi0alhpp6ycskb6yd40j2l7bl9bxfkb79443383r2mm";
+       version = "1.0.9";
+       sha256 = "06njwk2mmn8virrzd7q1bw91rwagcczkjn21kjhbajn6gzl77dry";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers data-fix dhall hnix neat-interpolation text vector
+         base containers data-fix dhall hnix neat-interpolation text
+         text-format vector
        ];
        executableHaskellDepends = [
          base dhall hnix optparse-generic text trifecta
···
     ({ mkDerivation, base, dhall, optparse-generic, text }:
      mkDerivation {
        pname = "dhall-text";
-       version = "1.0.3";
-       sha256 = "1kic5mwndqmxqrg9f2a7panawns5j43pik42hl2dds5fvj3cmvr9";
+       version = "1.0.4";
+       sha256 = "1ba2sljiq016jhgx7ifh5vjrwxd1czv2gm56h2pig3p0x45ds2wm";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base dhall optparse-generic text ];
···
     ({ mkDerivation, base, Cabal, ghc-prim, QuickCheck }:
      mkDerivation {
        pname = "dimensions";
-       version = "0.3.1.0";
-       sha256 = "1img3byk6jyfjqn1diss2067k88ii6hg5g92yaghkizh1d2vmyi0";
+       version = "0.3.2.0";
+       sha256 = "1ps9yy363xfpvq6dl5mjp02h0cj1vdib2vggvsykvgqwwrnra83p";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base Cabal QuickCheck ];
        homepage = "https://github.com/achirkin/easytensor#readme";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "disjoint-containers" = callPackage
+    ({ mkDerivation, base, containers, doctest, QuickCheck
+     , transformers
+     }:
+     mkDerivation {
+       pname = "disjoint-containers";
+       version = "0.2.1";
+       sha256 = "1082mx4af7h70hvnj0fxgimhnqbgn3ywkh53lm1hyhcfalnmyrs7";
+       libraryHaskellDepends = [ base containers transformers ];
+       testHaskellDepends = [ base containers doctest QuickCheck ];
+       homepage = "https://github.com/andrewthad/disjoint-containers#readme";
+       description = "Disjoint containers";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "disjoint-set" = callPackage
     ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck
      , transformers
···
      }:
      mkDerivation {
        pname = "dumb-cas";
-       version = "0.1.1.0";
-       sha256 = "1crzw0axgamjhxrm2ggdqw45jw80avp227bwc1v0c7lmb4cmkr3p";
+       version = "0.1.1.1";
+       sha256 = "0pimlspgrfv04hwz91krbcq0g01fhrp9vgi2sj1kc7wz9hcd1pva";
        libraryHaskellDepends = [
          base containers decimal-literals hashable template-haskell
          unordered-containers
···
     ({ mkDerivation, base, transformers, transformers-base }:
      mkDerivation {
        pname = "dunai";
-       version = "0.2.0.0";
-       sha256 = "1h6rw4h300hbmv05immhzxzf5yb9kc5zsykifdysi40l4fbx7rkc";
+       version = "0.3.0.0";
+       sha256 = "0ncznc3khbanqsq4ab0n246sx30slq13awclafln5bjxvi1cx3yl";
        libraryHaskellDepends = [ base transformers transformers-base ];
+       homepage = "https://github.com/ivanperez-keera/dunai";
        description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "dynamic-plot";
-       version = "0.2.2.0";
-       sha256 = "1w4w58x75x04i4mgfwb2znprrbf8vbml691niymlx1vlzlcsf13z";
+       version = "0.3.0.0";
+       sha256 = "0a674aqs9jnkga3a9sp24qyr3fssbizh4p1zwfvzwafnjrbmrc5c";
        libraryHaskellDepends = [
          base colour colour-space constrained-categories containers
          data-default deepseq diagrams-cairo diagrams-core diagrams-gtk
···
      }:
      mkDerivation {
        pname = "easytensor";
-       version = "0.3.1.0";
-       sha256 = "07shnpbnh3qq28yhcrhwhhb8m8b9x5ad36cj5f5hxqghfhih7k6b";
+       version = "0.4.0.0";
+       sha256 = "13wgg67gjg07r1n91kqikbhz8nnzfbgmi0v8a1596a6z7al4kvpr";
        libraryHaskellDepends = [ base dimensions ghc-prim ];
        testHaskellDepends = [ base Cabal dimensions QuickCheck ];
        benchmarkHaskellDepends = [ base dimensions time ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "elm-websocket" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, concurrent-extra
+     , containers, directory, formatting, hspec, http-types, lens, mtl
+     , network, scotty, stm, text, time, wai, wai-middleware-static
+     , wai-websockets, warp, websockets, wl-pprint-text
+     }:
+     mkDerivation {
+       pname = "elm-websocket";
+       version = "1.0";
+       sha256 = "10v97m93dl34apvv3jn26jfcb7f206q3bqvwqk220j83s8kas07a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring concurrent-extra containers directory
+         formatting lens mtl stm text time wai wai-websockets websockets
+         wl-pprint-text
+       ];
+       executableHaskellDepends = [
+         aeson base concurrent-extra http-types scotty text wai
+         wai-middleware-static warp
+       ];
+       testHaskellDepends = [
+         aeson base concurrent-extra hspec http-types mtl network text wai
+         warp websockets
+       ];
+       homepage = "http://github.com/rhyskeepence/elm-websocket";
+       description = "Generate ELM code from a Wai websocket application";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "elm-yesod" = callPackage
     ({ mkDerivation, base, blaze-markup, Elm, shakespeare-js, text
      , yesod-core
···
      }:
      mkDerivation {
        pname = "emailparse";
-       version = "0.2.0.6";
-       sha256 = "0n02h7d3n4xaivwpqiki2p0qca44y1md5zxp77l74ld7lf7y7rm9";
+       version = "0.2.0.8";
+       sha256 = "1x6hzmmsmdyqbcsx3sfgzi59y21ps7knz5hdinsyg1s30i22zgkz";
        libraryHaskellDepends = [
          attoparsec base bytestring either either-unwrap mime MissingH
          strptime text text-icu time word8
···
        pname = "fixed-vector-binary";
        version = "0.6.0.0";
        sha256 = "1yjyw9wc92laiwd9w8ng3456azicvf9a9wqk2v6liiksj3flw7hy";
+       revision = "1";
+       editedCabalFile = "04xrlp3r2798jpjw9v0zfjda79j19xz81szwp8jp5g71r5y16pvj";
        libraryHaskellDepends = [ base binary fixed-vector ];
        testHaskellDepends = [
          base binary fixed-vector tasty tasty-quickcheck
···
        pname = "fixed-vector-cereal";
        version = "0.6.0.0";
        sha256 = "1kf3d0pfaif5fish1vc5z7d5ym23bwl80l8bg4bgpdw75cg2dnn6";
+       revision = "1";
+       editedCabalFile = "1xhryv8d2znbfi99grg8dsn2lpya0wd8ff4pv6piyb01c13fl3xh";
        libraryHaskellDepends = [ base cereal fixed-vector ];
        testHaskellDepends = [
          base cereal fixed-vector tasty tasty-quickcheck
···
        pname = "fixed-vector-hetero";
        version = "0.3.1.2";
        sha256 = "0l8vphi8ijyzyk372r9i7imq8r6ki1w774gid69c8d2a2b63gvdd";
+       revision = "1";
+       editedCabalFile = "05scgl0r3g9nnb0pfg39cinylm11wdyqr8f51k69wj5y79fzf5yz";
        libraryHaskellDepends = [
          base deepseq fixed-vector ghc-prim primitive transformers
        ];
···
      }:
      mkDerivation {
        pname = "fluid-idl";
-       version = "0.0.1";
-       sha256 = "1mqswhsvyycxa7c7c92jag6rsp0dbkdm8bwjv6pcr92w293ycrv2";
+       version = "0.0.2";
+       sha256 = "1qcsdnjwz0gcn8z6ss27f3a687fi47cmm95a9rfag42gvvlwyr9z";
        libraryHaskellDepends = [
          aeson base bytestring containers errors exceptions lifted-async
          monad-control monad-logger mtl random safe-exceptions scientific
···
      }:
      mkDerivation {
        pname = "gelatin";
-       version = "0.1.0.0";
-       sha256 = "08y9wsym19rgwr6k44n8pxffwi1fna3nmg4bq5cc7in5zj1ihfbv";
+       version = "0.1.0.1";
+       sha256 = "151sf11a9sfwi6wg26l7lyphklv3lgy51djfqx3qszykhzccgv7b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "geoip2";
-       version = "0.3.0.0";
-       sha256 = "1yazd4wgf4ivk2x3apymddcww24z7a4b0jxzph7l8273wd8dy8zg";
+       version = "0.3.1.0";
+       sha256 = "1w9iqfkyi0ij33kng4adczi6m8chyhsadc2af5ryp8xzl7w64l8m";
        libraryHaskellDepends = [
          base bytestring cereal containers iproute mmap reinterpret-cast
          text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "ginger_0_7_2_0" = callPackage
+  "ginger_0_7_3_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring
      , data-default, filepath, http-types, mtl, parsec, safe, scientific
      , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers
···
      }:
      mkDerivation {
        pname = "ginger";
-       version = "0.7.2.0";
-       sha256 = "1xgczxqqd4ml8ifcyr45nrgbqn5a40nrbkvzbn4r4djpivnsrk0k";
+       version = "0.7.3.0";
+       sha256 = "1c4k0ixpkdb711arxcn028z27y78ssr6j5n7dfs9cajf93x727gs";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "haskanoid";
-       version = "0.1.5.2";
-       sha256 = "1hw4ylwwsmp59ifw8s4w1394gv7p2xc6nvqajfmil0p8r8s6r1pf";
+       version = "0.1.5.4";
+       sha256 = "01cwjvs1sj66w9siqfq3vzrw5607bh2pxr6zzx64jhqhcr3yv73d";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "hasql_1" = callPackage
+  "hasql_1_1" = callPackage
     ({ mkDerivation, attoparsec, base, base-prelude, bug, bytestring
      , bytestring-strict-builder, contravariant, contravariant-extras
      , criterion, data-default-class, dlist, either, hashable
···
      }:
      mkDerivation {
        pname = "hasql";
-       version = "1";
-       sha256 = "0zhk9vwlmjc1cwbqx1l9nns155a5f2zbb8k1240wqcylignfqi2b";
+       version = "1.1";
+       sha256 = "1c2gfdgxki17ng6b5qr3pvmra7v7x3hf9vh75hq4n6jr8rp03iki";
        libraryHaskellDepends = [
          attoparsec base base-prelude bytestring bytestring-strict-builder
          contravariant contravariant-extras data-default-class dlist either
···
      }:
      mkDerivation {
        pname = "hasql-cursor-query";
-       version = "0.4.3.1";
-       sha256 = "0m9lr2n5ac0n9gslj2v24jmm68b1aq29zb9ca5wszfs16x6v92ci";
+       version = "0.4.4";
+       sha256 = "0xbnhgix1g4sf2cpimz77ljiwm79l4lnx1ys7q31rak1fyw7fgs0";
        libraryHaskellDepends = [
          base base-prelude bytestring contravariant foldl hasql
          hasql-cursor-transaction hasql-transaction profunctors
···
      }:
      mkDerivation {
        pname = "hasql-cursor-transaction";
-       version = "0.6.2.1";
-       sha256 = "113fkkkdh2ar431b9l3jbqabymmas2r0fwc7icfys3ayh8r50fg7";
+       version = "0.6.3";
+       sha256 = "12vzkay4r0pzz41p4n60zd077yigr3373i5nr8cpf8z39msj8vaj";
        libraryHaskellDepends = [
          base base-prelude bytestring bytestring-tree-builder contravariant
          contravariant-extras hasql hasql-transaction transformers
···
      }:
      mkDerivation {
        pname = "hasql-optparse-applicative";
-       version = "0.2.3";
-       sha256 = "0ph2dzfl12bcdcd4xqw5kg1sdyd36ajz3n3ha27rnvv0l8slld6i";
+       version = "0.2.4";
+       sha256 = "0gdbwhzcfjriq2yah5kfn9r1anc77f1iyay86zsdgq4z8qi6asvr";
        libraryHaskellDepends = [
          base-prelude hasql hasql-pool optparse-applicative
        ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "hasql-pool_0_4_3" = callPackage
+    ({ mkDerivation, base-prelude, hasql, resource-pool, time }:
+     mkDerivation {
+       pname = "hasql-pool";
+       version = "0.4.3";
+       sha256 = "08fzh0y1cxaslp8ia26p9jhs3dckjfdvmiqw1lasdabb7ij82i0j";
+       libraryHaskellDepends = [ base-prelude hasql resource-pool time ];
+       homepage = "https://github.com/nikita-volkov/hasql-pool";
+       description = "A pool of connections for Hasql";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hasql-postgres" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
      , criterion-plus, deepseq, directory, doctest, either, filepath
···
        homepage = "https://github.com/nikita-volkov/hasql-transaction";
        description = "A composable abstraction over the retryable transactions for Hasql";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "hasql-transaction_0_5_2" = callPackage
+    ({ mkDerivation, async, base, base-prelude, bytestring
+     , bytestring-tree-builder, contravariant, contravariant-extras
+     , hasql, mtl, rebase, transformers
+     }:
+     mkDerivation {
+       pname = "hasql-transaction";
+       version = "0.5.2";
+       sha256 = "0w4y65vqgc4pk66xpip9jzzbas6cpnss4gx1w91rg7j48491cmym";
+       libraryHaskellDepends = [
+         base base-prelude bytestring bytestring-tree-builder contravariant
+         contravariant-extras hasql mtl transformers
+       ];
+       testHaskellDepends = [ async hasql rebase ];
+       homepage = "https://github.com/nikita-volkov/hasql-transaction";
+       description = "A composable abstraction over the retryable transactions for Hasql";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hastache" = callPackage
···
      }:
      mkDerivation {
        pname = "hat";
-       version = "2.9.0.0";
-       sha256 = "05sbgq1mliahdn4qj7flgw7klrm67r2mz7gxs03i6lx6mi3phm9f";
-       revision = "1";
-       editedCabalFile = "1wspd2shxpp3x4p4ghgf82vqchlkxk6qhvsgn07ypzm2kfz3a9dh";
+       version = "2.9.4";
+       sha256 = "13ldpj92qzp243zwnx0q044isdq2nmbh93wardqzr37jybs7m4xs";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "hjsonschema_1_7_0" = callPackage
+  "hjsonschema_1_7_1" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, containers
      , directory, file-embed, filepath, hashable, hjsonpointer, hspec
      , http-client, http-types, pcre-heavy, profunctors, protolude
···
      }:
      mkDerivation {
        pname = "hjsonschema";
-       version = "1.7.0";
-       sha256 = "01k29v8xqw3d8vy3qdf6ppgjmly7ppbg19yjrsiv10szishwigg2";
+       version = "1.7.1";
+       sha256 = "0x9w33scdnbfdmadxpx2c4fgkmpvny9ipsl2y7fq56zr6fa0ybfz";
        libraryHaskellDepends = [
          aeson base bytestring containers file-embed filepath hashable
          hjsonpointer http-client http-types pcre-heavy profunctors
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hlint_2_0_10" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
+     , containers, cpphs, data-default, directory, extra, filepath
+     , haskell-src-exts, haskell-src-exts-util, hscolour, process
+     , refact, text, transformers, uniplate, unordered-containers
+     , vector, yaml
+     }:
+     mkDerivation {
+       pname = "hlint";
+       version = "2.0.10";
+       sha256 = "1kmjgdj652lx269sppa35wga8a2376nzjd548nnc6h52kdpgix30";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers cpphs
+         data-default directory extra filepath haskell-src-exts
+         haskell-src-exts-util hscolour process refact text transformers
+         uniplate unordered-containers vector yaml
+       ];
+       executableHaskellDepends = [ base ];
+       homepage = "https://github.com/ndmitchell/hlint#readme";
+       description = "Source code suggestions";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hlogger" = callPackage
     ({ mkDerivation, base, old-locale, time }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hoauth2_1_4_0" = callPackage
+  "hoauth2_1_5_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , http-conduit, http-types, microlens, text, unordered-containers
      , uri-bytestring, uri-bytestring-aeson, wai, warp
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "1.4.0";
-       sha256 = "0wksa14mj7pyd6mjv81m1djqs8s79sri8a1by14l626pgai7p3h0";
+       version = "1.5.0";
+       sha256 = "0dfrqdjrvc94f94xl8vqggdvzbkiwj3xfkmwilkskvnfg1s1hg8q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hopenpgp-tools";
        version = "0.19.5";
        sha256 = "1yb6slxphz7lghclv1cjs2kwig1ll1dxzcaf4js26nanq280lqz0";
-       revision = "1";
-       editedCabalFile = "0lid8ck44b5ybb8wq81bh8wianr4r4rigqzq49cfr1g4kxmhqcq8";
+       revision = "2";
+       editedCabalFile = "1w9ban4w6zm7cknfnlzhgx649xg2j0vsrhqdlnd5g8qzcbbhh0si";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "hsass";
        version = "0.4.2";
        sha256 = "0hv2falrm3dcmdx08mpk2z8yxfr1hahgrd3ff9yvw6xjcjzab5yh";
+       libraryHaskellDepends = [
+         base bytestring data-default-class filepath hlibsass monad-loops
+         transformers
+       ];
+       testHaskellDepends = [
+         base bytestring data-default-class hspec hspec-discover temporary
+       ];
+       homepage = "https://github.com/jakubfijalkowski/hsass";
+       description = "Integrating Sass into Haskell applications";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "hsass_0_5_0" = callPackage
+    ({ mkDerivation, base, bytestring, data-default-class, filepath
+     , hlibsass, hspec, hspec-discover, monad-loops, temporary
+     , transformers
+     }:
+     mkDerivation {
+       pname = "hsass";
+       version = "0.5.0";
+       sha256 = "07jhny061fnxqiijr2rqac85qzlxz24w8dms5pn844as8nkwdi4d";
        libraryHaskellDepends = [
          base bytestring data-default-class filepath hlibsass monad-loops
          transformers
···
      }:
      mkDerivation {
        pname = "hw-kafka-client";
-       version = "2.0.4";
-       sha256 = "0mqrxczjr822hccmrdsmy98mw10jdmiiq94vdibkqrh618hs4fd5";
+       version = "2.1.0";
+       sha256 = "1kl9pkcpsciwxya92kr75nd0n2xb4qrhs5fs75ifkgzicjipxd5v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hwsl2";
-       version = "0.4.0.0";
-       sha256 = "0f081h2w2his8fgis6prj6z5bywh4csjqgwn5mc4wdy5s1zi6010";
+       version = "0.4.0.1";
+       sha256 = "07kg0m75fi9m236lnisrjdyx7y53hl6pm4v5l9cxvghfankfbgk0";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring quickcheck-properties tasty tasty-quickcheck
···
        pname = "idris";
        version = "1.0";
        sha256 = "1srbz0cyvd0k1yqgbrwnfj94yg5y3z533q1kzac96z1h7v454s5h";
-       configureFlags = [ "-fcurses" "-fffi" "-fgmp" ];
+       configureFlags = [ "-fcurses" "-f-execonly" "-fffi" "-fgmp" ];
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "idris";
        version = "1.1.1";
        sha256 = "0rq43i3mf7b4yiwzrzzpyh3ldka3j514ms9cf31vsfpy0jn3bvkp";
-       configureFlags = [ "-fcurses" "-fffi" "-fgmp" ];
+       configureFlags = [ "-fcurses" "-fexeconly" "-fffi" "-fgmp" ];
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        homepage = "https://github.com/blamario/incremental-parser";
        description = "Generic parser library capable of providing partial results from partial input";
        license = "GPL";
+     }) {};
+
+  "incremental-parser_0_2_5_2" = callPackage
+    ({ mkDerivation, base, bytestring, checkers, criterion, deepseq
+     , monoid-subclasses, QuickCheck, tasty, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "incremental-parser";
+       version = "0.2.5.2";
+       sha256 = "0qlawnlghp8cz96sc6kjzhp0dlinmnyh38gjcp6i1wfn2qy8qy7d";
+       libraryHaskellDepends = [ base monoid-subclasses ];
+       testHaskellDepends = [
+         base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq monoid-subclasses text
+       ];
+       homepage = "https://github.com/blamario/incremental-parser";
+       description = "Generic parser library capable of providing partial results from partial input";
+       license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "incremental-sat-solver" = callPackage
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "lackey_0_4_5" = callPackage
+    ({ mkDerivation, base, servant, servant-foreign, tasty, tasty-hspec
+     , text
+     }:
+     mkDerivation {
+       pname = "lackey";
+       version = "0.4.5";
+       sha256 = "0xczvbfvgcifb6mzyicihgz6vcn7bx2d3w9r8ih9mdclbfhc32l6";
+       libraryHaskellDepends = [ base servant servant-foreign text ];
+       testHaskellDepends = [ base servant tasty tasty-hspec text ];
+       homepage = "https://github.com/tfausak/lackey#readme";
+       description = "Generate Ruby clients from Servant APIs";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "lagrangian" = callPackage
     ({ mkDerivation, ad, base, hmatrix, HUnit, nonlinear-optimization
      , test-framework, test-framework-hunit, test-framework-quickcheck2
···
      }:
      mkDerivation {
        version = "0.0.1.20091117";
-       version = "0.0.1.20091117";
-       version = "0.0.1.20091117";
+       version = "0.16.3.0";
+       sha256 = "0cjg4r6yjwfzr2xn90gvrw2x93mlpz6z2i1i4djbnilknl9s53vp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        version = "0.0.1.20091117";
      mkDerivation {
        version = "0.0.1.20091117";
-       version = "0.1.2.1";
-       version = "0.0.1.20091117";
+       version = "0.1.2.2";
+       sha256 = "1hzvw76fgaf5d5l1dca9662c0pplgv0h53dwfr42cwg0hxj6c876";
        version = "0.0.1.20091117";
        version = "0.0.1.20091117";
        license = "unknown";
···
      }:
      mkDerivation {
        version = "0.0.1.20091117";
-       version = "0.1";
-       version = "0.0.1.20091117";
+       version = "0.1.0.1";
+       sha256 = "1j11cg76w9kyc1nn395qhzj9cp64ff0jq8y0h5x9lcn2r18zihhi";
        libraryHaskellDepends = [
        version = "0.0.1.20091117";
        ];
···
      }:
      mkDerivation {
        pname = "ltk";
-       version = "0.16.1.0";
-       sha256 = "00vxsp5w38wv12wl09z6wa72kpczd6k5g9m02clshaq3ai6cyg1a";
+       version = "0.0.1.20091117";
+       sha256 = "1x8abgss6j46wp0cz7vfr704j38f00pcgkhyxn8ismqf3k7sdzxc";
        libraryHaskellDepends = [
          base base-compat Cabal containers filepath ghc gi-cairo gi-gdk
          gi-glib gi-gobject gi-gtk gi-gtk-hs haskell-gi-base
···
      , containers, criterion, directory, file-embed, hspec
      , hspec-megaparsec, http-client, http-client-tls, megaparsec
      , MonadRandom, mtl, optparse-applicative, process, random-shuffle
-     , recursion-schemes, tar, template-haskell, text, th-lift-instances
-     , titlecase, zip-archive, zlib
+     , recursion-schemes, recursion-schemes-ext, tar, template-haskell
+     , text, th-lift-instances, titlecase, zip-archive, zlib
      }:
      mkDerivation {
        pname = "madlang";
-       version = "3.1.1.13";
-       sha256 = "0qmgd368brmmibqlimv254i20ayxw96ipnwcfid4q3pdml9javn4";
+       version = "3.1.1.18";
+       sha256 = "00np5hkbab7hi46056hp6maa7fc63vbx227pj0y3d5q502hgf3jj";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory process ];
        libraryHaskellDepends = [
          ansi-wl-pprint base composition-prelude containers directory
          file-embed http-client http-client-tls megaparsec MonadRandom mtl
-         optparse-applicative random-shuffle recursion-schemes tar
-         template-haskell text th-lift-instances titlecase zip-archive zlib
+         optparse-applicative random-shuffle recursion-schemes
+         recursion-schemes-ext tar template-haskell text th-lift-instances
+         titlecase zip-archive zlib
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec hspec-megaparsec text ];
···
        homepage = "https://github.com/myfreeweb/magicbane";
        description = "A web framework that integrates Servant, ClassyPrelude, EKG, fast-logger, wai-cli…";
        license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
+  "magicbane_0_1_2" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, classy-prelude
+     , conduit, conduit-combinators, data-default, data-has, either
+     , ekg-core, ekg-wai, envy, errors, fast-logger, http-api-data
+     , http-client, http-client-tls, http-conduit, http-date
+     , http-link-header, http-media, http-types, lifted-async
+     , mime-types, monad-control, monad-logger, monad-metrics, mtl
+     , network, network-uri, raw-strings-qq, refined, servant
+     , servant-server, split, string-conversions, text, transformers
+     , unordered-containers, wai, wai-cli, wai-middleware-metrics
+     }:
+     mkDerivation {
+       pname = "magicbane";
+       version = "0.1.2";
+       sha256 = "19k31vy2ldf9a3jvmlys16n6w31a8h7b1iyp6m35f4n16ndjvwa1";
+       libraryHaskellDepends = [
+         aeson aeson-qq attoparsec base classy-prelude conduit
+         conduit-combinators data-default data-has either ekg-core ekg-wai
+         envy errors fast-logger http-api-data http-client http-client-tls
+         http-conduit http-date http-link-header http-media http-types
+         lifted-async mime-types monad-control monad-logger monad-metrics
+         mtl network network-uri raw-strings-qq refined servant
+         servant-server split string-conversions text transformers
+         unordered-containers wai wai-cli wai-middleware-metrics
+       ];
+       homepage = "https://github.com/myfreeweb/magicbane#readme";
+       description = "A web framework that integrates Servant, ClassyPrelude, EKG, fast-logger, wai-cli…";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "magico" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "model_0_4_1" = callPackage
+    ({ mkDerivation, base, containers, convertible, deepseq, doctest
+     , filemanip, ghc-prim, pretty, tasty, tasty-hunit, tasty-quickcheck
+     , transformers
+     }:
+     mkDerivation {
+       pname = "model";
+       version = "0.4.1";
+       sha256 = "115apma3mbvpskd5kbgccs4g4d1n9g5lj62bd9appd0d0i8rskf8";
+       libraryHaskellDepends = [
+         base containers convertible deepseq pretty transformers
+       ];
+       testHaskellDepends = [
+         base containers doctest filemanip ghc-prim pretty tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       homepage = "http://github.com/tittoassini/model";
+       description = "Derive a model of a data type using Generics";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "modelicaparser" = callPackage
     ({ mkDerivation, ansi-terminal, base, containers, filepath, parsec
      , QuickCheck
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "mono-traversable_1_0_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion, foldl
+     , hashable, hspec, HUnit, mwc-random, QuickCheck, semigroups, split
+     , text, transformers, unordered-containers, vector
+     , vector-algorithms
+     }:
+     mkDerivation {
+       pname = "mono-traversable";
+       version = "1.0.4.0";
+       sha256 = "0qwmzjf25gradzajr4f9zw3a48m4hw26qvqnb134daqkyxpkzf13";
+       libraryHaskellDepends = [
+         base bytestring containers hashable split text transformers
+         unordered-containers vector vector-algorithms
+       ];
+       testHaskellDepends = [
+         base bytestring containers foldl hspec HUnit QuickCheck semigroups
+         text transformers unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [ base criterion mwc-random vector ];
+       homepage = "https://github.com/snoyberg/mono-traversable";
+       description = "Type classes for mapping, folding, and traversing monomorphic containers";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mono-traversable-instances" = callPackage
     ({ mkDerivation, base, comonad, containers, dlist, dlist-instances
      , mono-traversable, semigroupoids, semigroups, transformers
···
        benchmarkHaskellDepends = [ base criterion system-filepath text ];
        description = "A bare-bones calculus of constructions";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "morte_1_6_11" = callPackage
+    ({ mkDerivation, alex, array, base, binary, code-page, containers
+     , criterion, deepseq, Earley, http-client, http-client-tls
+     , microlens, microlens-mtl, mtl, optparse-applicative, pipes
+     , QuickCheck, system-fileio, system-filepath, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-format, transformers
+     }:
+     mkDerivation {
+       pname = "morte";
+       version = "1.6.11";
+       sha256 = "10zwdf82hxjgxh7zs7wlnvyzjpaqalwj7rlg454jjlml59ifzvmw";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array base binary containers deepseq Earley http-client
+         http-client-tls microlens microlens-mtl pipes system-fileio
+         system-filepath text text-format transformers
+       ];
+       libraryToolDepends = [ alex ];
+       executableHaskellDepends = [
+         base code-page optparse-applicative text text-format
+       ];
+       testHaskellDepends = [
+         base mtl QuickCheck system-filepath tasty tasty-hunit
+         tasty-quickcheck text transformers
+       ];
+       benchmarkHaskellDepends = [ base criterion system-filepath text ];
+       description = "A bare-bones calculus of constructions";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "mosaico-lib" = callPackage
···
        pname = "natural-transformation";
        version = "0.4";
        sha256 = "1by8xwjc23l6pa9l4iv7zp82dykpll3vc3hgxk0pgva724n8xhma";
-       revision = "1";
-       editedCabalFile = "1scwm1gs07znkj4ahfyxpwrksj4rdl1pa81xflcqhkqfgcndvgl3";
+       revision = "2";
+       editedCabalFile = "1j90pd1zznr18966axskad5w0kx4dvqg62r65rmw1ihqwxm1ndix";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base containers quickcheck-instances tasty tasty-quickcheck
···
        homepage = "https://github.com/WraithM/opaleye-trans";
        description = "A monad transformer for Opaleye";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "opaleye-trans_0_3_7" = callPackage
+    ({ mkDerivation, base, mtl, opaleye, postgresql-simple
+     , product-profunctors, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "opaleye-trans";
+       version = "0.3.7";
+       sha256 = "17yfa0kgd3v8dlz77nlgplyi23f622f46z9q2xyswnrrf5w2c4z0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base mtl opaleye postgresql-simple product-profunctors transformers
+         transformers-base
+       ];
+       executableHaskellDepends = [
+         base opaleye postgresql-simple product-profunctors
+       ];
+       homepage = "https://github.com/WraithM/opaleye-trans";
+       description = "A monad transformer for Opaleye";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "open-browser" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "optparse-simple_0_0_4" = callPackage
+    ({ mkDerivation, base, bytestring, directory, either, gitrev
+     , optparse-applicative, template-haskell, transformers
+     }:
+     mkDerivation {
+       pname = "optparse-simple";
+       version = "0.0.4";
+       sha256 = "1md24dlz6949rqv6y2x9d5r07lrqw42c21kdy09nk5y8r3mq43x0";
+       libraryHaskellDepends = [
+         base either gitrev optparse-applicative template-haskell
+         transformers
+       ];
+       testHaskellDepends = [ base bytestring directory ];
+       description = "Simple interface to optparse-applicative";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "optparse-text" = callPackage
     ({ mkDerivation, base, hspec, optparse-applicative, text }:
      mkDerivation {
···
      }) {};
 
   "orgstat" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, colour
+    ({ mkDerivation, aeson, attoparsec, base, boxes, bytestring, colour
      , containers, data-default, diagrams-lib, diagrams-svg, directory
      , exceptions, filepath, formatting, hashable, hspec, HUnit, lens
      , linear, log-warper, mtl, optparse-simple, orgmode-parse
···
      }:
      mkDerivation {
        pname = "orgstat";
-       version = "0.1.1";
-       sha256 = "0241f7d996akmqi1id6dqwki5yql7mgw331msxvza616s3gcyd36";
+       version = "0.1.2";
+       sha256 = "11q8n9sy841klms368bs0wl14wg0q5dq5gfcipzm25pw6jswfgyy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson attoparsec base bytestring colour containers data-default
-         diagrams-lib diagrams-svg directory exceptions filepath formatting
-         hashable lens linear log-warper mtl optparse-simple orgmode-parse
-         text time turtle universum yaml
+         aeson attoparsec base boxes bytestring colour containers
+         data-default diagrams-lib diagrams-svg directory exceptions
+         filepath formatting hashable lens linear log-warper mtl
+         optparse-simple orgmode-parse text time turtle universum yaml
        ];
        executableHaskellDepends = [
          base bytestring directory exceptions filepath formatting log-warper
···
        maintainers = with stdenv.lib.maintainers; [ peti ];
      }) {};
 
-  "pandoc_2_0_0_1" = callPackage
+  "pandoc_2_0_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
      , binary, blaze-html, blaze-markup, bytestring, Cabal
      , case-insensitive, cmark-gfm, containers, criterion, data-default
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "2.0.0.1";
-       sha256 = "1wq21vsg9afv8lxk6rmmmb57437q7gv1qs4ymbzd1mvxkvzx0hwh";
+       version = "2.0.1";
+       sha256 = "00c7iv2s70dijyd651sflncmba9dfbflrrzii1hn0m5als75jgmb";
        configureFlags = [ "-fhttps" "-f-trypandoc" ];
        isLibrary = true;
        isExecutable = true;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "pandoc-citeproc_0_11_1_2" = callPackage
+  "pandoc-citeproc_0_11_1_3" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , Cabal, containers, data-default, directory, filepath, hs-bibutils
      , mtl, old-locale, pandoc, pandoc-types, parsec, process, rfc5051
···
      }:
      mkDerivation {
        pname = "pandoc-citeproc";
-       version = "0.11.1.2";
-       sha256 = "0lv1j035f5c0dd0n772ivav6kwzfxvnk6zcxmmhmkc3s9r9716sd";
+       version = "0.11.1.3";
+       sha256 = "00c9r8v7rc8ff8gw41470c3marhp0vqrdywmj91565k4ri7wfnwp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "pandoc-include-code";
-       version = "1.1.0.0";
-       sha256 = "1ygdmnmr4lw7f83xhqaa7m074ii6wbrsx148i9qx3inz5z2rm9b5";
+       version = "1.1.1.0";
+       sha256 = "016c6xf9avh4ydhd0vb5l044d4zlxgrpvp40v15889plrkbvxnbb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "pandoc-stylefrommeta" = callPackage
-    ({ mkDerivation, base, containers, HaTeX, MissingH, pandoc
-     , pandoc-types
+    ({ mkDerivation, base, bytestring, containers, MissingH, pandoc
+     , pandoc-types, text
      }:
      mkDerivation {
        pname = "pandoc-stylefrommeta";
-       version = "0.1.1.0";
-       sha256 = "0blgccnzyignq14y94cnascjxlk6088wwpxifwm45rnn0hs786vf";
+       version = "0.2.0.2";
+       sha256 = "12yvbh8cx5r6llx0gnz70n1b3zwm3zc8bdciq3cxyfivci5iks2r";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base containers HaTeX MissingH pandoc pandoc-types
+         base bytestring containers MissingH pandoc pandoc-types text
        ];
        homepage = "http://github.com/lyokha/styleFromMeta";
        description = "Pandoc filter to customize links, images and paragraphs";
···
     ({ mkDerivation, base, data-diverse, hspec, transformers }:
      mkDerivation {
        pname = "parameterized";
-       version = "0.2.0.0";
-       sha256 = "0z40b6cja2c4y177w6iwg8dijlpk5zwrf5yfwppc5y6n57g260z7";
+       version = "0.3.0.0";
+       sha256 = "148i3s6j38qvncbkk2hz86lbzprr5h7l7gpjqf0zb0ay0i9idczs";
        libraryHaskellDepends = [ base data-diverse transformers ];
        testHaskellDepends = [ base data-diverse hspec transformers ];
        homepage = "https://github.com/louispan/parameterized#readme";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "postgresql-typed_0_5_2" = callPackage
+    ({ mkDerivation, aeson, array, attoparsec, base, binary, bytestring
+     , containers, convertible, cryptonite, haskell-src-meta, HDBC
+     , HUnit, memory, network, old-locale, postgresql-binary, QuickCheck
+     , scientific, template-haskell, text, time, utf8-string, uuid
+     }:
+     mkDerivation {
+       pname = "postgresql-typed";
+       version = "0.5.2";
+       sha256 = "0ws9xmh199jsvdmxjxkhm59j05ljfsrf16xchkbxqd8p1pg8786c";
+       libraryHaskellDepends = [
+         aeson array attoparsec base binary bytestring containers cryptonite
+         haskell-src-meta HDBC memory network old-locale postgresql-binary
+         scientific template-haskell text time utf8-string uuid
+       ];
+       testHaskellDepends = [
+         base bytestring containers convertible HDBC HUnit network
+         QuickCheck time
+       ];
+       homepage = "https://github.com/dylex/postgresql-typed";
+       description = "PostgreSQL interface with compile-time SQL type checking, optional HDBC backend";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "postgresql-typed-lifted" = callPackage
     ({ mkDerivation, base, base-unicode-symbols, bytestring, exceptions
      , lens, monad-control, postgresql-typed, transformers-base
···
      }:
      mkDerivation {
        pname = "preamble";
-       version = "0.0.49";
-       sha256 = "1xk8l4lbicl1k6xr14x80dlc5g55dj59xgzgx01b61d0k595mmj1";
+       version = "0.0.50";
+       sha256 = "09gsl99ikglf1cyzmy53xcn2lb549z6gi5930ldz03nd50lg0fdg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ptr";
-       version = "0.15.3";
-       sha256 = "1h66bk595nv0jmcxdzfzvpr7ymfm6hl3n4bnglwlwkp2y1ymm3i3";
+       version = "0.15.4";
+       sha256 = "0hmj6411wqsa9wgh2i3aksbkx07yaz88lp9h6lj9r8qfyv9yls5l";
        libraryHaskellDepends = [
          base base-prelude bug bytestring contravariant mtl profunctors
          semigroups text transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "ratel_0_3_7" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, filepath, http-client, http-client-tls, http-types
+     , tasty, tasty-hspec, text, uuid
+     }:
+     mkDerivation {
+       pname = "ratel";
+       version = "0.3.7";
+       sha256 = "0jwmlnxnaaldi1gr988gdy82y3ylvmi9ylnrsas8rg6pwyj76v9c";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-client-tls http-types text uuid
+       ];
+       testHaskellDepends = [ base filepath tasty tasty-hspec ];
+       homepage = "https://github.com/tfausak/ratel#readme";
+       description = "Notify Honeybadger about exceptions";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ratel-wai" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , http-client, ratel, wai
···
      }:
      mkDerivation {
        pname = "reactive-midyim";
-       version = "0.4";
-       sha256 = "0aq3iaq3l4wcdixa09q9na2n4l92nkzikjbma3mxl4d6gklhcvhy";
+       version = "0.4.0.1";
+       sha256 = "1ck2f8nhlhcw9vyh42svp94xrnd4jcvic2kzxikw50vjcd4w6rrf";
        libraryHaskellDepends = [
          base containers data-accessor data-accessor-transformers event-list
          midi non-negative random reactive-banana-bunch transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "rest-snap_0_3_0_0" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, case-insensitive
+     , rest-core, safe, snap-core, unordered-containers, uri-encode
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "rest-snap";
+       version = "0.3.0.0";
+       sha256 = "1s38xrmg90y80rxmz1kf5wfxq7dgf63xysicg0jfawwl3sy88iff";
+       libraryHaskellDepends = [
+         base base-compat bytestring case-insensitive rest-core safe
+         snap-core unordered-containers uri-encode utf8-string
+       ];
+       description = "Rest driver for Snap";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "rest-stringmap" = callPackage
     ({ mkDerivation, aeson, base, containers, hashable, hxt
      , json-schema, tostring, unordered-containers
···
      }:
      mkDerivation {
        pname = "sbv";
-       version = "7.3";
-       sha256 = "01vcil4zij8ap1bnkmmi8439mmnsbw3qc1gw994wdnar082wzh66";
+       version = "7.4";
+       sha256 = "0yylg2zdrcqzckhmlz9d5chac1jawbnrdp7fn49ia1nsl0i3jggc";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array async base containers crackNum data-binary-ieee754 deepseq
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "schematic_0_4_0_0" = callPackage
+  "schematic_0_4_2_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hjsonschema
      , hspec, hspec-core, hspec-discover, hspec-smallcheck, HUnit, lens
      , mtl, profunctors, regex-tdfa, regex-tdfa-text, scientific
···
      }:
      mkDerivation {
        pname = "schematic";
-       version = "0.4.0.0";
-       sha256 = "1n0i7irbf4flnhybhvl5kqkcyz673nyv7bl8z14yxi152a7kjkqi";
+       version = "0.4.2.0";
+       sha256 = "0k63pnv8mip8kn623s5n7w24bd4spjmi1a9h280nf7wd1q8z72n4";
        libraryHaskellDepends = [
          aeson base bytestring containers hjsonschema mtl profunctors
          regex-tdfa regex-tdfa-text scientific singletons smallcheck tagged
···
        pname = "scientific";
        version = "0.3.5.2";
        sha256 = "0msnjz7ml0zycw9bssslxbg0nigziw7vs5km4q3vjbs8jpzpkr2w";
+       revision = "1";
+       editedCabalFile = "1gnz52yrd9bnq4qvd4v9kd00clx0sfbh64phafdq5g2hbk9yrg0v";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq hashable integer-gmp
          integer-logarithms primitive text
···
        pname = "servant";
        version = "0.11";
        sha256 = "00vbhijdxb00n8ha068zdwvqlfqv1iradkkdchzzvnhg2jpzgcy5";
-       revision = "1";
-       editedCabalFile = "1az9id2dl7psc8lknf7y9cvzkivcjzw7g27yyp40flb6bfvmaqp3";
+       revision = "2";
+       editedCabalFile = "1b5zxz1cqf0n2y1jfvb1rsza95hdyhn9fc6fl73bxr5m9apv511z";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson attoparsec base base-compat bytestring case-insensitive
···
      }:
      mkDerivation {
        pname = "shakers";
-       version = "0.0.33";
-       sha256 = "1wn0bk867nbzcg6c6a8q5sa4ma60r3zc46ykpdla34k61nq5g3qy";
+       version = "0.0.35";
+       sha256 = "14hkdkhpg5gs1mhd96ldy7xb35rqrr0cqnnaw3hmv2cyk6np7fnz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bytestring, hsI2C, time, transformers }:
      mkDerivation {
        pname = "si-clock";
-       version = "0.1.3";
-       sha256 = "0s2d1liaknk5qhh41pi3508m3dz9k0ljl5fc2v1vs6ckv4sd9fjr";
+       version = "0.1.3.1";
+       sha256 = "15fk63nynpk5wz9ikij18g5vnrslsrv97fn649dkssmsdwifjfj5";
        libraryHaskellDepends = [
          base bytestring hsI2C time transformers
        ];
···
     ({ mkDerivation, base, singletons }:
      mkDerivation {
        pname = "singleton-nats";
-       version = "0.4.0.2";
-       sha256 = "1nrjdy7rkjla2cgyb2j50p7qi30divl6aa75m3yvf2whb38wgisw";
+       version = "0.4.0.3";
+       sha256 = "150pfyfgyvksx600c9c7pyw154dvjgfiykas3wxfzkm3l9mhg32v";
        libraryHaskellDepends = [ base singletons ];
        homepage = "https://github.com/AndrasKovacs/singleton-nats";
        description = "Unary natural numbers relying on the singletons infrastructure";
···
      }:
      mkDerivation {
        pname = "sitepipe";
-       version = "0.1.1";
-       sha256 = "1kymvi3pf67chjsvqxv29i4fbac2yyrjx5llc2r7qjfw3hblf5sj";
+       version = "0.2.0.0";
+       sha256 = "15cynic59qkfgb8d3ca6hr3dag0cs48af266xaiblpvim39rk1fb";
        libraryHaskellDepends = [
          aeson base bytestring containers directory exceptions filepath Glob
          lens lens-aeson megaparsec MissingH mtl mustache
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "skylighting_0_4_2" = callPackage
+  "skylighting_0_4_3_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
      , blaze-html, bytestring, case-insensitive, containers, criterion
      , Diff, directory, filepath, HUnit, hxt, mtl, pretty-show, random
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.4.2";
-       sha256 = "0szhhmjz14wq1ica3gl6nj5fh85fwh55xyywlq8q3dq8isl1hcz3";
+       version = "0.4.3.1";
+       sha256 = "087f41qx28609i9ryc5njvjyyw1n3ypym63vmw2q4bhlr5lxkf30";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, cmdargs, containers, leancheck }:
      mkDerivation {
        pname = "speculate";
-       version = "0.2.9";
-       sha256 = "0xk8i5hskr59vrf8vkvwsvp4n048fd66k959q7nl0i5z3k0lx2m2";
+       version = "0.2.10";
+       sha256 = "1c2fpswmlrza9al6i94rjnd1k14g5f48g4zrqgyxrgl4sqkhbbs9";
        libraryHaskellDepends = [ base cmdargs containers leancheck ];
        testHaskellDepends = [ base leancheck ];
        benchmarkHaskellDepends = [ base leancheck ];
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_10_0" = callPackage
+  "stratosphere_0_11_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hashable
      , hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.10.0";
-       sha256 = "195rr247bzrnnvjv7i13z88xbpajxk34n94ywqvfyf3457466iqh";
+       version = "0.11.0";
+       sha256 = "1l9wyyw8zvmb7z0qvs5qk0mxbjnlm1405sxiz7wzff6ibxvk9kn5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, process, regex, regex-with-pcre }:
      mkDerivation {
        pname = "system-info";
-       version = "0.1.0.8";
-       sha256 = "0pv4f5yrzybm2r1zi02ranq1ag1akkpzzc8w3qjpwliv2ahy4516";
+       version = "0.1.0.9";
+       sha256 = "0f27y3bdqlyvbxdchsn7mz2rhsvk4bxqy0xldy6l30vsv2q9gdx4";
        libraryHaskellDepends = [ base process regex regex-with-pcre ];
        testHaskellDepends = [ base ];
        homepage = "https://github.com/ChaosGroup/system-info";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "tasty_0_12" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, clock, containers
+     , deepseq, mtl, optparse-applicative, regex-tdfa, stm, tagged
+     , unbounded-delays, unix
+     }:
+     mkDerivation {
+       pname = "tasty";
+       version = "0.12";
+       sha256 = "0840ziawhj0lrzn927nx9lww6wxc5krvf0c3xygl577vvxh4adg1";
+       libraryHaskellDepends = [
+         ansi-terminal async base clock containers deepseq mtl
+         optparse-applicative regex-tdfa stm tagged unbounded-delays unix
+       ];
+       homepage = "https://github.com/feuerbach/tasty";
+       description = "Modern and extensible testing framework";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tasty-ant-xml" = callPackage
     ({ mkDerivation, base, containers, directory, filepath
      , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
···
        hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
      }) {};
 
-  "tasty-dejafu_0_7_0_2" = callPackage
+  "tasty-dejafu_0_7_0_3" = callPackage
     ({ mkDerivation, base, dejafu, random, tagged, tasty }:
      mkDerivation {
        pname = "tasty-dejafu";
-       version = "0.7.0.2";
-       sha256 = "1yj4sdprlz79sk14q5b8089sw1bn0z4nqpbdb2sr90smlxa57zpa";
+       version = "0.7.0.3";
+       sha256 = "0xvqlw5w5rwz1xxi277r9w7iad7prds5i1rrmy8wz3x3vh9kbnmm";
        libraryHaskellDepends = [ base dejafu random tagged tasty ];
        homepage = "https://github.com/barrucadu/dejafu";
        description = "Deja Fu support for the Tasty test framework";
···
        pname = "tasty-hspec";
        version = "1.1.3.2";
        sha256 = "0n4pn89jz9i8d7mxsdp6ynwkg5gjyaipdy261parx64m3nxi4vcv";
+       revision = "1";
+       editedCabalFile = "05fl6jirj479lax2wqg6h5m82mkc475lhas7wmpx91kv1kfklx54";
        libraryHaskellDepends = [
          base hspec hspec-core QuickCheck random tagged tasty
          tasty-quickcheck tasty-smallcheck
···
        pname = "tasty-stats";
        version = "0.2.0.3";
        sha256 = "1jyywffrs270rvf8k9zc82b7fqqv6x1czk6qlbi6sq9z1wgs5w1b";
+       revision = "1";
+       editedCabalFile = "1kvvz549gs7vm9w6gypr8pa1klsab335rzmdq7v638rvijgqfbn8";
        libraryHaskellDepends = [
          base containers directory process stm tagged tasty time
        ];
···
        testHaskellDepends = [ base tasty-hunit ];
        homepage = "http://github.com/bennofs/tasty-th";
        description = "Automatic tasty test case discovery using TH";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "tasty-travis" = callPackage
+    ({ mkDerivation, base, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "tasty-travis";
+       version = "0.1.2";
+       sha256 = "0ypk596sjlh6s2gyy1bgx414jhhfhaaqqqdl9647mjsd49a83g2s";
+       libraryHaskellDepends = [ base tasty ];
+       testHaskellDepends = [ base tasty tasty-hunit ];
+       homepage = "https://github.com/merijn/tasty-travis";
+       description = "Fancy Travis CI output for tasty tests";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "texbuilder";
-       version = "0.1.1.1";
-       sha256 = "14fg4hxyfvv54n85495dbk6avccms92kw5jzgycylnk8aiw2nxa4";
+       version = "0.1.1.2";
+       sha256 = "069y2d2k87sfx4mkmd8219iiyh9s6x79kigxbdi9swfa4k9xa1gm";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = "GPL";
      }) {};
 
+  "texmath_0_10" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, network-uri, pandoc-types, parsec, process, split, syb
+     , temporary, text, utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.10";
+       sha256 = "0i9haxii7kklz6qrfidb54iv5cl73p201zy24mwkf4bf56lff1pa";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec syb xml
+       ];
+       executableHaskellDepends = [ network-uri ];
+       testHaskellDepends = [
+         base bytestring directory filepath process split temporary text
+         utf8-string xml
+       ];
+       homepage = "http://github.com/jgm/texmath";
+       description = "Conversion between formats used to represent mathematics";
+       license = "GPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, temporary, test-framework
···
 
   "thread-hierarchy" = callPackage
     ({ mkDerivation, base, containers, hspec, lifted-base
-     , monad-control, transformers-base
+     , monad-control, stm, transformers-base
      }:
      mkDerivation {
        pname = "thread-hierarchy";
-       version = "0.1.0.3";
-       sha256 = "1j5caivjcvrmfqgl13lhlx9dq81kka64w96ykb0bfb089kwi0j9f";
+       version = "0.2.0.0";
+       sha256 = "1y11q5ijb9hqvxgcf5jig6d24895nrrg06ig8sy7fk1s32rr0bqm";
        libraryHaskellDepends = [
-         base containers lifted-base monad-control transformers-base
+         base containers lifted-base monad-control stm transformers-base
        ];
-       testHaskellDepends = [ base containers hspec ];
+       testHaskellDepends = [ base containers hspec stm ];
        homepage = "https://github.com/nshimaza/thread-hierarchy#readme";
        description = "Simple Haskel thread management in hierarchical manner";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "units-parser_0_1_1" = callPackage
+    ({ mkDerivation, base, containers, mtl, multimap, parsec, syb
+     , tasty, tasty-hunit, template-haskell
+     }:
+     mkDerivation {
+       pname = "units-parser";
+       version = "0.1.1";
+       sha256 = "0d39r1vcwqs61529gjz3329a41fp4pwx0x4j4kw4xl2lza3wr164";
+       libraryHaskellDepends = [ base containers mtl multimap parsec ];
+       testHaskellDepends = [
+         base containers mtl multimap parsec syb tasty tasty-hunit
+         template-haskell
+       ];
+       description = "A parser for units of measure";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "unittyped" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "universum";
-       version = "0.7.1";
-       sha256 = "1q7q1ynfm4m1zz2inyvvj7868p3yxjl7w512j5xiz4mzx3llb292";
+       version = "0.7.1.1";
+       sha256 = "08q3ldx0saahlxh2zkwmsq71lkwrvfrs19nzbgwwdvd31y4r0iq6";
        libraryHaskellDepends = [
          base bytestring containers deepseq exceptions ghc-prim hashable
          microlens microlens-mtl mtl safe safe-exceptions stm text
···
      }:
      mkDerivation {
        pname = "wolf";
-       version = "0.3.29";
-       sha256 = "147s2xg9y77gw81gnqgijnfzfx728ddv018n7zs2sl231asjqy3i";
+       version = "0.3.31";
+       sha256 = "1f5b4j788yr2m7f9if2fj41j236h5zjszzldcna0v6f93za7kzy2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) libyaml;};
 
+  "yaml_0_8_24" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
+     , bytestring, conduit, containers, directory, filepath, hspec
+     , HUnit, libyaml, mockery, resourcet, scientific, semigroups
+     , template-haskell, temporary, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "yaml";
+       version = "0.8.24";
+       sha256 = "08cawq5q2bm23fi48m56x1h6qdf52wn9i9y770v6q2810wj2f7n1";
+       configureFlags = [ "-fsystem-libyaml" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit containers directory
+         filepath resourcet scientific semigroups template-haskell text
+         transformers unordered-containers vector
+       ];
+       libraryPkgconfigDepends = [ libyaml ];
+       executableHaskellDepends = [ aeson base bytestring ];
+       testHaskellDepends = [
+         aeson aeson-qq base base-compat bytestring conduit directory hspec
+         HUnit mockery resourcet temporary text transformers
+         unordered-containers vector
+       ];
+       homepage = "http://github.com/snoyberg/yaml/";
+       description = "Support for parsing and rendering YAML documents";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) libyaml;};
+
   "yaml-combinators" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, generics-sop
      , scientific, tasty, tasty-hunit, text, transformers
···
      }:
      mkDerivation {
        pname = "yi";
-       version = "0.15.0";
-       sha256 = "1mkdpc4fg7qx8mslcmjwnws24hr5p7289v026qf0m6ivc4dkbkbi";
+       version = "0.17.1";
+       sha256 = "18937w0w1hk7ngyrl1p5gy4djgz8py9kcsndas82w82wwh36jnqg";
        configureFlags = [ "-fpango" "-fvty" ];
        isLibrary = false;
        isExecutable = true;
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-core_0_17_0" = callPackage
+  "yi-core_0_17_1" = callPackage
     ({ mkDerivation, array, attoparsec, base, binary, bytestring
      , containers, criterion, data-default, deepseq, directory, dlist
-     , dynamic-state, filepath, hashable, ListLike, microlens-platform
-     , mtl, old-locale, oo-prototypes, parsec, pointedlist, process
-     , process-extras, quickcheck-text, split, tasty, tasty-hunit
-     , tasty-quickcheck, text, time, transformers-base, unix
-     , unix-compat, unordered-containers, xdg-basedir, yi-language
-     , yi-rope
+     , dynamic-state, exceptions, filepath, hashable, ListLike
+     , microlens-platform, mtl, old-locale, oo-prototypes, parsec
+     , pointedlist, process, process-extras, quickcheck-text, split
+     , tasty, tasty-hunit, tasty-quickcheck, text, time
+     , transformers-base, unix, unix-compat, unordered-containers
+     , xdg-basedir, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-core";
-       version = "0.17.0";
-       sha256 = "018fcmviyy0xrzrvmcrdl4r4mk69ig7jgck5zgq58y0h7m4wxkmg";
+       version = "0.17.1";
+       sha256 = "1qv86znr7kjwnxv771xx1j7z63fqbnfasn2ndkbj5ldk3m5bil0p";
        libraryHaskellDepends = [
          array attoparsec base binary bytestring containers data-default
-         directory dlist dynamic-state filepath hashable ListLike
+         directory dlist dynamic-state exceptions filepath hashable ListLike
          microlens-platform mtl old-locale oo-prototypes parsec pointedlist
          process process-extras split text time transformers-base unix
          unix-compat unordered-containers xdg-basedir yi-language yi-rope
···
      }:
      mkDerivation {
        pname = "yi-dynamic-configuration";
-       version = "0.17.0";
-       sha256 = "1slf3qrq61b171sg6izw212qajvmjwv786gndhql8r9kyi7na9ys";
+       version = "0.17.1";
+       sha256 = "1cnafzrgi7js9zayq223752v7jvl9rp526s7bd1nwwyjwl59y0h8";
        libraryHaskellDepends = [
          base data-default dyre microlens-platform mtl text
          transformers-base yi-core yi-rope
···
      }:
      mkDerivation {
        pname = "yi-frontend-pango";
-       version = "0.17.0";
-       sha256 = "141kp6f6f0xrql8jmghqj1h5vrbim28z7p1a9psa40xry1hhlhr7";
+       version = "0.17.1";
+       sha256 = "0jh9bmxhjr1wpilmghanihq6iwn4xn34ihqlfc2c080wm5s8kw4w";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers filepath glib gtk microlens-platform mtl
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-frontend-vty_0_17_0" = callPackage
+  "yi-frontend-vty_0_17_1" = callPackage
     ({ mkDerivation, base, containers, data-default, dlist
      , microlens-platform, pointedlist, stm, text, vty, yi-core
      , yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-frontend-vty";
-       version = "0.17.0";
-       sha256 = "12yl4d3dkjkbz8n184lcs8z08mj8yc1ybaj52z7j58nialvq4ibh";
+       version = "0.17.1";
+       sha256 = "0i00m3z7zj6xqgh78wfrw2zqwcffsb31i2549m0b5g9qsicfp9h6";
        libraryHaskellDepends = [
          base containers data-default dlist microlens-platform pointedlist
          stm text vty yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-fuzzy-open_0_17_0" = callPackage
+  "yi-fuzzy-open_0_17_1" = callPackage
     ({ mkDerivation, base, binary, containers, data-default, directory
      , filepath, mtl, pointedlist, text, transformers-base, vector
      , yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-fuzzy-open";
-       version = "0.17.0";
-       sha256 = "1447w8gqwjnala08sysvy1bxhdna1hydh0bnjx2awz7hns5040ap";
+       version = "0.17.1";
+       sha256 = "1wd1w1d67hkp5rk3130cnmffgh40qb1vp9pnz6f36n0c8b2jqvjh";
        libraryHaskellDepends = [
          base binary containers data-default directory filepath mtl
          pointedlist text transformers-base vector yi-core yi-language
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-ireader_0_17_0" = callPackage
+  "yi-ireader_0_17_1" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-default
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-ireader";
-       version = "0.17.0";
-       sha256 = "0cwfjajs25lbxhzn8zbpjavy1yjym3k4iliqal9iq3i51k9inacc";
+       version = "0.17.1";
+       sha256 = "12babkhlqr7w3mb7z8w8ccwrvmkz8583yi0p9s50rqkn778cij7y";
        libraryHaskellDepends = [
          base binary bytestring containers data-default microlens-platform
          text yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-cua_0_17_0" = callPackage
+  "yi-keymap-cua_0_17_1" = callPackage
     ({ mkDerivation, base, microlens-platform, text, yi-core
      , yi-keymap-emacs, yi-rope
      }:
      mkDerivation {
        pname = "yi-keymap-cua";
-       version = "0.17.0";
-       sha256 = "0v7gcd5arq33r2cf55ig307cfvapz3r1h9cz3ssvkw0fjzr1p1a3";
+       version = "0.17.1";
+       sha256 = "053w4b1p482wma64888vb3ikh7x0f58bl43vy7xs1lazlz22iwaj";
        libraryHaskellDepends = [
          base microlens-platform text yi-core yi-keymap-emacs yi-rope
        ];
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-emacs_0_17_0" = callPackage
+  "yi-keymap-emacs_0_17_1" = callPackage
     ({ mkDerivation, base, containers, filepath, Hclip
      , microlens-platform, mtl, oo-prototypes, text, transformers-base
      , yi-core, yi-language, yi-misc-modes, yi-rope
      }:
      mkDerivation {
        pname = "yi-keymap-emacs";
-       version = "0.17.0";
-       sha256 = "1d90884kjpq13d7nrxjla9kx6gr09xh8lwzbpnf69jg6iiavjlfg";
+       version = "0.17.1";
+       sha256 = "1jx7vhp7v098p3rrs21b43fwcbra6fmg4clamgqbbvbqgiy4bsrw";
        libraryHaskellDepends = [
          base containers filepath Hclip microlens-platform mtl oo-prototypes
          text transformers-base yi-core yi-language yi-misc-modes yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-keymap-vim_0_16_0" = callPackage
+  "yi-keymap-vim_0_17_1" = callPackage
     ({ mkDerivation, attoparsec, base, binary, containers, data-default
      , directory, filepath, Hclip, microlens-platform, mtl
      , oo-prototypes, pointedlist, QuickCheck, safe, tasty, tasty-hunit
···
      }:
      mkDerivation {
        pname = "yi-keymap-vim";
-       version = "0.16.0";
-       sha256 = "1fvl4frjikkdp561zai6z35r8r7f4fq2izlcxl1k1rvsvxz3cbi2";
-       enableSeparateDataOutput = true;
+       version = "0.17.1";
+       sha256 = "1zvd0y6ak56cqxa60x4kgil2lp5lbidnkmp6kh7dq3i71n0nv48w";
        libraryHaskellDepends = [
          attoparsec base binary containers data-default directory filepath
          Hclip microlens-platform mtl oo-prototypes pointedlist safe text
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-language_0_17_0" = callPackage
+  "yi-language_0_17_1" = callPackage
     ({ mkDerivation, alex, array, base, binary, containers
      , data-default, hashable, microlens-platform, oo-prototypes
      , pointedlist, regex-base, regex-tdfa, tasty, tasty-hspec
···
      }:
      mkDerivation {
        pname = "yi-language";
-       version = "0.17.0";
-       sha256 = "046aavm0pf5s8bx6z0v8fvbizzr3s9s8kq79sj3gvis26im9kzpy";
+       version = "0.17.1";
+       sha256 = "17mnjfhxr6vhpfx7l4zg606f2vffjr39ga4j5qmnp7cf4y5n5vja";
        libraryHaskellDepends = [
          array base binary containers data-default hashable
          microlens-platform oo-prototypes pointedlist regex-base regex-tdfa
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-misc-modes_0_17_0" = callPackage
+  "yi-misc-modes_0_17_1" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, filepath
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-misc-modes";
-       version = "0.17.0";
-       sha256 = "0ki6dc1frzhgn7dfbsrpbf75a5i32iz9a8cvy1c33xmdh9s8k4fw";
+       version = "0.17.1";
+       sha256 = "0yyv8p65vhpcjj97pzax0b8bbqhh3lzy3by4rzf0f11p862wzag0";
        libraryHaskellDepends = [
          array base binary data-default filepath microlens-platform text
          yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-mode-haskell_0_17_0" = callPackage
+  "yi-mode-haskell_0_17_1" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, filepath
      , microlens-platform, text, yi-core, yi-language, yi-rope
      }:
      mkDerivation {
        pname = "yi-mode-haskell";
-       version = "0.17.0";
-       sha256 = "17cfbww6lpg29dz51pbzlsx95azhxlgv0lqcpxpxk82w9s4c2dji";
+       version = "0.17.1";
+       sha256 = "1fl9kmv264c0cmpn6c77ylyngyjh9ilcvpcrsn7j75g2xacgdpyx";
        libraryHaskellDepends = [
          array base binary data-default filepath microlens-platform text
          yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-mode-javascript_0_17_0" = callPackage
+  "yi-mode-javascript_0_17_1" = callPackage
     ({ mkDerivation, alex, array, base, binary, data-default, dlist
      , filepath, microlens-platform, mtl, text, yi-core, yi-language
      , yi-rope
      }:
      mkDerivation {
        pname = "yi-mode-javascript";
-       version = "0.17.0";
-       sha256 = "040mc9mfm46alfl21p6p4a8n9p8hr12ywn6sfgq32zrhpa1zn9yb";
+       version = "0.17.1";
+       sha256 = "073yywxsf3j4vcc9rg0hw7jm6gmwvc7krvm0g9q9pv2y49n5aj14";
        libraryHaskellDepends = [
          array base binary data-default dlist filepath microlens-platform
          mtl text yi-core yi-language yi-rope
···
        license = stdenv.lib.licenses.gpl2;
      }) {};
 
-  "yi-snippet_0_17_0" = callPackage
+  "yi-snippet_0_17_1" = callPackage
     ({ mkDerivation, base, binary, containers, data-default, free
      , microlens-platform, mtl, tasty-hunit, tasty-th, text, vector
      , yi-core, yi-rope
      }:
      mkDerivation {
        pname = "yi-snippet";
-       version = "0.17.0";
-       sha256 = "10680a4zc5r9mnvhajgfrvzxpf8naclx4sygvbi69c5aann4q4a1";
+       version = "0.17.1";
+       sha256 = "1prczicjzmqnpkq6sda878f056g4ld1g6wmfpqzly2qa5rs4zg6b";
        libraryHaskellDepends = [
          base binary containers data-default free microlens-platform mtl
          text vector yi-core yi-rope

pkgs/development/interpreters/acl2/default.nix

···
-{ stdenv, fetchurl, sbcl }:
+{ stdenv, fetchFromGitHub,
+  # perl, which, nettools,
+  sbcl }:
 
-stdenv.mkDerivation rec {
+let hashes = {
+  "7.4" = "04jb789nks9llwysxz1zw9pq1dh0j39b5fcmivcc4bq9v9cga2l1";
+};
+in stdenv.mkDerivation rec {
   name = "acl2-${version}";
-  version = "v6-5";
+  version = "7.4";
 
-  src = fetchurl {
-    url = "http://www.cs.utexas.edu/users/moore/acl2/${version}/distrib/acl2.tar.gz";
-    sha256 = "19kfclgpdyms016s06pjf3icj3mx9jlcj8vfgpbx2ac4ls0ir36g";
-    name = "acl2-${version}.tar.gz";
+  src = fetchFromGitHub {
+    owner = "acl2-devel";
+    repo = "acl2-devel";
+    rev = "${version}";
+    sha256 = hashes."${version}";
   };
 
-  buildInputs = [ sbcl ];
+  buildInputs = [ sbcl
+    # which perl nettools
+  ];
+
+  enableParallelBuilding = true;
 
   phases = "unpackPhase installPhase";
 
···
 
   installPhase = ''
     mkdir -p $out/share/${installSuffix}
+    mkdir -p $out/bin
     cp -R . $out/share/${installSuffix}
     cd $out/share/${installSuffix}
-    make 'LISP=${sbcl}/bin/sbcl --dynamic-space-size 2000'
-    make 'LISP=${sbcl}/bin/sbcl --dynamic-space-size 2000' regression
-    make LISP=${sbcl}/bin/sbcl TAGS
-    mkdir -p $out/bin
+
+    # make ACL2 image
+    make LISP=${sbcl}/bin/sbcl
+
+    # The community books don't build properly under Nix yet.
+    rm -rf books
+    #make ACL2=$out/share/saved_acl2 USE_QUICKLISP=1 regression-everything
+
     cp saved_acl2 $out/bin/acl2
   '';
 
   meta = {
     description = "An interpreter and a prover for a Lisp dialect";
-    maintainers = with stdenv.lib.maintainers; [ raskin ];
+    longDescription = ''
+      ACL2 is a logic and programming language in which you can model
+      computer systems, together with a tool to help you prove
+      properties of those models. "ACL2" denotes "A Computational
+      Logic for Applicative Common Lisp".
+
+      ACL2 is part of the Boyer-Moore family of provers, for which its
+      authors have received the 2005 ACM Software System Award.
+
+      NOTE: In nixpkgs, the community books that usually ship with
+      ACL2 have been removed because it is not currently possible to
+      build them with Nix.
+    '';
+    homepage = http://www.cs.utexas.edu/users/moore/acl2/;
+    downloadPage = https://github.com/acl2-devel/acl2-devel/releases;
+    # There are a bunch of licenses in the community books, but since
+    # they currently get deleted during the build, we don't mention
+    # their licenses here.  ACL2 proper is released under a BSD
+    # 3-clause license.
+    #license = with stdenv.lib.licenses;
+    #[ free bsd3 mit gpl2 llgpl21 cc0 publicDomain ];
+    license = stdenv.lib.licenses.bsd3;
+    maintainers = with stdenv.lib.maintainers; [ kini raskin ];
     platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/development/interpreters/elixir/1.5.nix

···
 { mkDerivation }:
 
 mkDerivation rec {
-  version = "1.5.1";
-  sha256 = "0q0zr3v9cyb7p9aab8v038hnjm84nf9b60kikffp6w9rfqqqf767";
+  version = "1.5.2";
+  sha256 = "0ng7z2gz1c8lkn07fric18b3awcw886s9xb864kmnn2iah5gc65j";
   minimumOTPVersion = "18";
 }

pkgs/development/interpreters/spidermonkey/52.nix

···
+{ stdenv, fetchurl, autoconf213, pkgconfig, perl, python2, zip, which, readline, icu, zlib, nspr }:
+
+stdenv.mkDerivation rec {
+  version = "52.2.1gnome1";
+  name = "spidermonkey-${version}";
+
+  # the release notes point to some guys home directory, see
+  # https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/38
+  # probably it would be more ideal to pull a particular tag/revision
+  # from the mercurial repo
+  src = fetchurl {
+    url = "mirror://gnome/teams/releng/tarballs-needing-help/mozjs/mozjs-${version}.tar.gz";
+    sha256 = "1bxhz724s1ch1c0kdlzlg9ylhg1mk8kbhdgfkax53fyvn51pjs9i";
+  };
+
+  buildInputs = [ readline icu zlib nspr ];
+  nativeBuildInputs = [ autoconf213 pkgconfig perl which python2 zip ];
+
+  postUnpack = "sourceRoot=\${sourceRoot}/js/src";
+
+  preConfigure = ''
+    export CXXFLAGS="-fpermissive"
+    export LIBXUL_DIST=$out
+    export PYTHON="${python2.interpreter}"
+  '';
+
+  configureFlags = [
+    "--enable-threadsafe"
+    "--with-system-nspr"
+    "--with-system-zlib"
+    "--with-system-icu"
+    "--with-intl-api"
+    "--enable-readline"
+
+    # enabling these because they're wanted by 0ad. They may or may
+    # not be good defaults for other uses.
+    "--enable-gcgenerational"
+    "--enable-shared-js"
+  ];
+
+  # This addresses some build system bug. It's quite likely to be safe
+  # to re-enable parallel builds if the source revision changes.
+  enableParallelBuilding = true;
+
+  postFixup = ''
+    # The headers are symlinks to a directory that doesn't get put
+    # into $out, so they end up broken. Fix that by just resolving the
+    # symlinks.
+    for i in $(find $out -type l); do
+      cp --remove-destination "$(readlink "$i")" "$i";
+    done
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Mozilla's JavaScript engine written in C/C++";
+    homepage = https://developer.mozilla.org/en/SpiderMonkey;
+    # TODO: MPL/GPL/LGPL tri-license.
+
+    maintainers = [ maintainers.abbradar ];
+    platforms = platforms.linux;
+  };
+}

pkgs/development/libraries/appstream-glib/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, gettext, gtk3, intltool, glib
-, gtk_doc, autoconf, automake, libtool, libarchive
-, gobjectIntrospection, sqlite, libsoup, gcab, attr, acl, docbook_xsl
-, libuuid, json_glib, autoconf-archive, meson, gperf, ninja, gdk_pixbuf
+{ stdenv, fetchFromGitHub, pkgconfig, gettext, gtk3, glib
+, gtk_doc, libarchive, gobjectIntrospection
+, sqlite, libsoup, gcab, attr, acl, docbook_xsl
+, libuuid, json_glib, meson, gperf, ninja
 }:
-let rpath = stdenv.lib.makeLibraryPath
-      [ libuuid.out
-        glib
-        libsoup
-        gdk_pixbuf
-        libarchive.lib
-        gcab
-      ];
-in stdenv.mkDerivation rec {
+stdenv.mkDerivation rec {
   name = "appstream-glib-0.7.2";
 
   src = fetchFromGitHub {
···
                   libarchive gobjectIntrospection gperf ];
   propagatedBuildInputs = [ gtk3 ];
   mesonFlags = [ "-Denable-rpm=false" "-Denable-stemmer=false" "-Denable-dep11=false" ];
-
-  postFixup = ''
-    for elf in "$out"/bin/* "$out"/lib/*.so; do
-      patchelf --set-rpath '${rpath}':"$out/lib" "$elf"
-    done
-  '';
 
   meta = with stdenv.lib; {
     description = "Objects and helper methods to read and write AppStream metadata";

pkgs/development/libraries/boehm-gc/default.nix

···
     [ "--enable-cplusplus" ]
     ++ lib.optional enableLargeConfig "--enable-large-config";
 
-  doCheck = true;
+  doCheck = stdenv.buildPlatform == stdenv.hostPlatform;
 
   # Don't run the native `strip' when cross-compiling.
   dontStrip = hostPlatform != buildPlatform;

pkgs/development/libraries/clutter-gtk/default.nix

···
 
 stdenv.mkDerivation rec {
   major = "1.8";
-  minor = "2";
+  minor = "4";
   name = "clutter-gtk-${major}.${minor}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/clutter-gtk/${major}/${name}.tar.xz";
-    sha256 = "da27d486325490ad3f65d2abf9413aeb8b4a8f7b559e4b2f73567a5344a26b94";
+    sha256 = "01ibniy4ich0fgpam53q252idm7f4fn5xg5qvizcfww90gn9652j";
   };
 
   propagatedBuildInputs = [ clutter gtk3 ];

pkgs/development/libraries/expat/default.nix

···
 
   outputMan = "dev"; # tiny page for a dev tool
 
-  doCheck = true;
+  doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
 
   preCheck = ''
     patchShebangs ./run.sh

pkgs/development/libraries/freetds/default.nix

···
-{ stdenv, fetchurl
+{ stdenv, fetchurl, autoreconfHook, pkgconfig
+, openssl
 , odbcSupport ? false, unixODBC ? null }:
 
 assert odbcSupport -> unixODBC != null;
 
 stdenv.mkDerivation rec {
-  name = "freetds-0.91";
+  name = "freetds-${version}";
+  version = "1.00.70";
 
   src = fetchurl {
-    url = "http://mirrors.ibiblio.org/freetds/stable/${name}.tar.gz";
-    sha256 = "0r946axzxs0czsmr7283w7vmk5jx3jnxxc32d2ncxsrsh2yli0ba";
+    url    = "http://www.freetds.org/files/stable/${name}.tar.bz2";
+    sha256 = "1ydh0c89nb6wh6wakbkqad7mdwpymygvgbcrk8c2mp7abgv1jqzp";
   };
 
-  hardeningDisable = [ "format" ];
+  configureFlags = [
+    "--with-tdsver=7.3"
+  ];
 
-  buildInputs = stdenv.lib.optional odbcSupport [ unixODBC ];
+  buildInputs = [
+    openssl
+  ] ++ stdenv.lib.optional odbcSupport unixODBC;
 
-  configureFlags = stdenv.lib.optionalString odbcSupport "--with-odbc=${unixODBC}";
+  nativeBuildInputs = [ autoreconfHook pkgconfig ];
 
-  doDist = true;
+  enableParallelBuilding = true;
 
-  distPhase = ''
-    touch $out/include/tds.h
-    touch $out/lib/libtds.a
-  '';
-
-  meta = {
-    description =
-      "Libraries to natively talk to Microsoft SQL Server and Sybase databases";
-    homepage = http://www.freetds.org;
-    license = "lgpl";
-    platforms = stdenv.lib.platforms.all;
+  meta = with stdenv.lib; {
+    description = "Libraries to natively talk to Microsoft SQL Server and Sybase databases";
+    homepage    = http://www.freetds.org;
+    license     = licenses.lgpl2;
+    maintainers = with maintainers; [ peterhoeg ];
+    platforms   = platforms.all;
   };
 }

pkgs/development/libraries/gdbm/default.nix

···
     sha256 = "0lx201q20dvc70f8a3c9s7s18z15inlxvbffph97ngvrgnyjq9cx";
   };
 
-  doCheck = true;
+  doCheck = stdenv.buildPlatform == stdenv.hostPlatform;
 
   # Linking static stubs on cygwin requires correct ordering.
   # Consider upstreaming this.

pkgs/development/libraries/glib-networking/default.nix

···
 , gsettings_desktop_schemas }:
 
 let
-  ver_maj = "2.50";
+  ver_maj = "2.54";
   ver_min = "0";
 in
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://gnome/sources/glib-networking/${ver_maj}/${name}.tar.xz";
-    sha256 = "3f1a442f3c2a734946983532ce59ed49120319fdb10c938447c373d5e5286bee";
+    sha256 = "5961b3779080b72314b373ff5d4790eb7e41b75ca91816ad7a81ef32922f7096";
   };
 
   outputs = [ "out" "dev" ]; # to deal with propagatedBuildInputs

pkgs/development/libraries/glibmm/default.nix

···
 { stdenv, fetchurl, pkgconfig, gnum4, glib, libsigcxx }:
 
 let
-  ver_maj = "2.50";
-  ver_min = "0";
+  ver_maj = "2.54";
+  ver_min = "1";
 in
 stdenv.mkDerivation rec {
   name = "glibmm-${ver_maj}.${ver_min}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/glibmm/${ver_maj}/${name}.tar.xz";
-    sha256 = "df726e3c6ef42b7621474b03b644a2e40ec4eef94a1c5a932c1e740a78f95e94";
+    sha256 = "0jkapw18icz59cmlmsl00nwwz0wh291kb4hc9z9hxmq45drqrhkw";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gnutls/generic.nix

···
 let
   # XXX: Gnulib's `test-select' fails on FreeBSD:
   # http://hydra.nixos.org/build/2962084/nixlog/1/raw .
-  doCheck = !stdenv.isFreeBSD && !stdenv.isDarwin && lib.versionAtLeast version "3.4";
+  doCheck = !stdenv.isFreeBSD && !stdenv.isDarwin && lib.versionAtLeast version "3.4"
+      && stdenv.buildPlatform == stdenv.hostPlatform;
 in
 stdenv.mkDerivation {
   name = "gnutls-${version}";

pkgs/development/libraries/gobject-introspection/default.nix

···
 # In that case its about 6MB which could be separated
 
 let
-  ver_maj = "1.52";
+  ver_maj = "1.54";
   ver_min = "1";
 in
 with stdenv.lib;
···
 
   src = fetchurl {
     url = "mirror://gnome/sources/gobject-introspection/${ver_maj}/${name}.tar.xz";
-    sha256 = "1x5gkyrglv3dn9b4fsgw6asqgjw1wj7qc37g9pyac6pyaa6w7l1f";
+    sha256 = "0zl7pfkzkm07733391b4f3cwjbnvb1nwvpmajf5bajh6bxgfv3dq";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/bad/default.nix

···
   inherit (stdenv.lib) optional optionalString;
 in
 stdenv.mkDerivation rec {
-  name = "gst-plugins-bad-1.10.4";
+  name = "gst-plugins-bad-1.12.2";
 
   meta = with stdenv.lib; {
     description = "Gstreamer Bad Plugins";
-    homepage    = "http://gstreamer.freedesktop.org";
+    homepage    = "https://gstreamer.freedesktop.org";
     longDescription = ''
       a set of plug-ins that aren't up to par compared to the
       rest.  They might be close to being good quality, but they're missing
···
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-plugins-bad/${name}.tar.xz";
-    sha256 = "0rk9rlzf2b0hjw5hwbadz53yh4ls7vm3w3cshsa3n8isdd8axp93";
+    sha256 = "0dwyq03g2m0p16dwx8q5qvjn5x9ia72h21sf87mp97gmwkfpwb4w";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/base/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gst-plugins-base-1.10.4";
+  name = "gst-plugins-base-1.12.2";
 
   meta = {
     description = "Base plugins and helper libraries";
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
     license = stdenv.lib.licenses.lgpl2Plus;
     platforms = stdenv.lib.platforms.unix;
   };
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-plugins-base/${name}.tar.xz";
-    sha256 = "1dsyjf6rncsbg4rfj40cvf1wwpjj9h3j3c7bh4zp7jylnfv4blpn";
+    sha256 = "0x86a7aph0y6gyq178plvwvbbyhkfb3hf0gadx9sk5z1mzixqrsh";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/core/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gstreamer-1.10.4";
+  name = "gstreamer-1.12.2";
 
   meta = {
     description = "Open source multimedia framework";
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
     license = stdenv.lib.licenses.lgpl2Plus;
     platforms = stdenv.lib.platforms.unix;
     maintainers = [ stdenv.lib.maintainers.ttuegel ];
···
 
   src = fetchurl {
     url = "${meta.homepage}/src/gstreamer/${name}.tar.xz";
-    sha256 = "062jidnw17hkpva6ddygp80gyasyigfkpm1y7w56rk56a2pzbhjh";
+    sha256 = "1fllz7n58lavyy4nh64xc7izd4ffhl12a2ff0yg4z67al8wkzplz";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/ges/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gstreamer-editing-services-1.10.4";
+  name = "gstreamer-editing-services-1.12.2";
 
   meta = with stdenv.lib; {
     description = "Library for creation of audio/video non-linear editors";
-    homepage    = "http://gstreamer.freedesktop.org";
+    homepage    = "https://gstreamer.freedesktop.org";
     license     = licenses.lgpl2Plus;
     platforms   = platforms.unix;
   };
 
   src = fetchurl {
     url = "${meta.homepage}/src/gstreamer-editing-services/${name}.tar.xz";
-    sha256 = "0i11b1rwkjsy9gxrf9vk9lgg8qm60ggfi5lp0ncyh4lxvh16vbgj";
+    sha256 = "0bi0f487949k9xnl1r6ngysgaibmmswwgdqcrchg0dixnnbm9isr";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/gnonlin/default.nix

···
 
   meta = with stdenv.lib; {
     description = "Gstreamer Non-Linear Multimedia Editing Plugins";
-    homepage    = "http://gstreamer.freedesktop.org";
+    homepage    = "https://gstreamer.freedesktop.org";
     longDescription = ''
       Gnonlin is a library built on top of GStreamer which provides 
       support for writing non-linear audio and video editing

pkgs/development/libraries/gstreamer/good/default.nix

···
   inherit (stdenv.lib) optionals optionalString;
 in
 stdenv.mkDerivation rec {
-  name = "gst-plugins-good-1.10.4";
+  name = "gst-plugins-good-1.12.2";
 
   meta = with stdenv.lib; {
     description = "Gstreamer Good Plugins";
-    homepage    = "http://gstreamer.freedesktop.org";
+    homepage    = "https://gstreamer.freedesktop.org";
     longDescription = ''
       a set of plug-ins that we consider to have good quality code,
       correct functionality, our preferred license (LGPL for the plug-in
···
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-plugins-good/${name}.tar.xz";
-    sha256 = "0zjdwxn83sp9wjp9rxjbyk8kf284g9av7l2v6rjldi586hacd1la";
+    sha256 = "15pfw54fsh9s9xwrnbap4z4njwgqdfvq52k562d2hc5b11rfx4am";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/gstreamermm/default.nix

···
     sha256 = "0i4sk6ns4dyi4szk45bkm4kvl57l52lgm15p2wg2rhx2gr2w3qry";
   };
 
+  patches = [
+    (fetchurl {
+      url = https://bug783628.bugzilla-attachments.gnome.org/attachment.cgi?id=354765;
+      sha256 = "082510a934bl05mz4cyakp8mfmd97cdj7vdrbvyqc4g58dcskvz0";
+    })
+  ];
+
   outputs = [ "out" "dev" ];
 
   nativeBuildInputs = [ pkgconfig file ];

pkgs/development/libraries/gstreamer/legacy/gst-ffmpeg/default.nix

···
 
   src = fetchurl {
     urls = [
-      "http://gstreamer.freedesktop.org/src/gst-ffmpeg/${name}.tar.bz2"
+      "https://gstreamer.freedesktop.org/src/gst-ffmpeg/${name}.tar.bz2"
       "mirror://gentoo/distfiles/${name}.tar.bz2"
       ];
     sha256 = "0qmvgwcfybci78sd73mhvm4bsb7l0xsk9yljrgik80g011ds1z3n";

pkgs/development/libraries/gstreamer/legacy/gst-plugins-bad/default.nix

···
   enableParallelBuilding = true;
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
 
     description = "‘Bad’ (potentially low quality) plug-ins for GStreamer";
 

pkgs/development/libraries/gstreamer/legacy/gst-plugins-base/default.nix

···
   postInstall = "rm -rf $out/share/gtk-doc";
 
   meta = with stdenv.lib; {
-    homepage    = http://gstreamer.freedesktop.org;
+    homepage    = https://gstreamer.freedesktop.org;
     description = "Base plug-ins for GStreamer";
     license     = licenses.lgpl2Plus;
     maintainers = with maintainers; [ lovek323 ];

pkgs/development/libraries/gstreamer/legacy/gst-plugins-good/default.nix

···
   '';
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
 
     description = "`Good' plug-ins for GStreamer";
 

pkgs/development/libraries/gstreamer/legacy/gst-plugins-ugly/default.nix

···
   enableParallelBuilding = true;
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
 
     description = "‘Ugly’ (potentially patent-encumbered) plug-ins for GStreamer";
 

pkgs/development/libraries/gstreamer/legacy/gst-python/default.nix

···
   propagatedBuildInputs = [ gstreamer python ];
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
 
     description = "Python bindings for GStreamer";
 

pkgs/development/libraries/gstreamer/legacy/qt-gstreamer/default.nix

···
   pname = "qt-gstreamer";
 
   src = fetchurl {
-    url = "http://gstreamer.freedesktop.org/src/${pname}/${name}.tar.bz2";
+    url = "https://gstreamer.freedesktop.org/src/${pname}/${name}.tar.bz2";
     sha256 = "1pqg9sxzk8sdrf7pazb5v21hasqai9i4l203gbdqz29w2ll1ybsl";
   };
 

pkgs/development/libraries/gstreamer/libav/default.nix

···
 assert withSystemLibav -> libav != null;
 
 stdenv.mkDerivation rec {
-  name = "gst-libav-1.10.4";
+  name = "gst-libav-1.12.2";
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
     license = stdenv.lib.licenses.lgpl2Plus;
     platforms = stdenv.lib.platforms.unix;
   };
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-libav/${name}.tar.xz";
-    sha256 = "12r68ri03mgbbwsxyn6yklgfsq32rwvyq83zw0aq7m73fp5gx83c";
+    sha256 = "1crdahkjm23byg1awcrjkmgfbalfpvvac7h7whm6b2r1pfwkbdsv";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/qt-gstreamer/default.nix

···
   pname = "qt-gstreamer";
 
   src = fetchurl {
-    url = "http://gstreamer.freedesktop.org/src/${pname}/${name}.tar.xz";
+    url = "https://gstreamer.freedesktop.org/src/${pname}/${name}.tar.xz";
     sha256 = "9f3b492b74cad9be918e4c4db96df48dab9c012f2ae5667f438b64a4d92e8fd4";
   };
 

pkgs/development/libraries/gstreamer/ugly/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gst-plugins-ugly-1.10.4";
+  name = "gst-plugins-ugly-1.12.2";
 
   meta = with stdenv.lib; {
     description = "Gstreamer Ugly Plugins";
-    homepage    = "http://gstreamer.freedesktop.org";
+    homepage    = "https://gstreamer.freedesktop.org";
     longDescription = ''
       a set of plug-ins that have good quality and correct functionality,
       but distributing them might pose problems.  The license on either
···
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-plugins-ugly/${name}.tar.xz";
-    sha256 = "0ngsiwcsz3jd08id4mc0qiy2q1n7h2kkvdnh3r1vm725m1ycg1k3";
+    sha256 = "0rplyp1qk359c97ig9i2vc1v34g92khd8dslwfipva1ypwmr9hqw";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gstreamer/vaapi/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "gst-vaapi-${version}";
-  version = "1.10.4";
+  version = "1.12.2";
 
   src = fetchurl {
     url = "${meta.homepage}/src/gstreamer-vaapi/gstreamer-vaapi-${version}.tar.xz";
-    sha256 = "0xfyf1mgcxnwf380wxv20hakl2srp34dmiw6bm4zkncl2mi91rh3";
+    sha256 = "0fhncs27hcdcnb9a4prkxlyvr883hnzsx148zzk7lg2b8zh19ir3";
   };
 
   outputs = [ "out" "dev" ];
···
   configureFlags = "--disable-builtin-libvpx --with-gstreamer-api=1.0";
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
     license = stdenv.lib.licenses.lgpl21Plus;
     platforms = stdenv.lib.platforms.linux;
     maintainers = with stdenv.lib.maintainers; [ tstrobel ];

pkgs/development/libraries/gstreamer/validate/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "gst-validate-1.10.4";
+  name = "gst-validate-1.12.2";
 
   meta = {
     description = "Integration testing infrastructure for the GStreamer framework";
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
     license = stdenv.lib.licenses.lgpl2Plus;
     platforms = stdenv.lib.platforms.unix;
   };
 
   src = fetchurl {
     url = "${meta.homepage}/src/gst-validate/${name}.tar.xz";
-    sha256 = "0g6px08x4kq5xqlbyxvxn6cm9b1s1gfvhkmlrmvw9afccjzh1775";
+    sha256 = "1pgycs35bwmp4aicyxwyzlfy1i5l2rzmh2a8ivhgy21azp8jaykb";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/gusb/default.nix

···
 {stdenv, fetchurl
 , automake, autoconf, libtool, which, gtkdoc, gettext, pkgconfig, gobjectIntrospection, libxslt
-, glib, systemd, libusb1, vala_0_23
+, glib, systemd, libusb1, vala_0_38
 }:
 stdenv.mkDerivation rec {
   name = "gusb-${version}";
-  version = "0.2.9";
+  version = "0.2.11";
   enableParallelBuilding = true;
 
   src = fetchurl {
-    url = "http://people.freedesktop.org/~hughsient/releases/libgusb-${version}.tar.xz";
-    sha256 = "056yxlppgycsfw1l8c9j6givk1n15jylhvx89wqhsxdi1b6vs83k";
+    url = "https://people.freedesktop.org/~hughsient/releases/libgusb-${version}.tar.xz";
+    sha256 = "1pppz17lw3khyz8by1dddxdqrv6qn4a23fpxs38c67db7x4l7ccw";
   };
 
   preConfigure = "./autogen.sh";
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [
-    autoconf automake libtool which gtkdoc gettext gobjectIntrospection libxslt
-    systemd vala_0_23 glib
-  ];
+  nativeBuildInputs = [ pkgconfig autoconf automake libtool which gtkdoc gettext
+                        gobjectIntrospection libxslt vala_0_38 ];
+  buildInputs = [ systemd  glib ];
 
   propagatedBuildInputs = [ libusb1 ];
 

pkgs/development/libraries/gvfs/default.nix

···
 { stdenv, fetchurl, pkgconfig, intltool, libtool
 , glib, dbus, udev, libgudev, udisks2, libgcrypt, libcap, polkit
-, libgphoto2, avahi, libarchive, fuse, libcdio
+, libgphoto2, avahi, libarchive, fuse, libcdio, file, bzip2, lzma
 , libxml2, libxslt, docbook_xsl, samba, libmtp
 , gnomeSupport ? false, gnome, makeWrapper }:
 
 let
-  ver_maj = "1.30";
+  ver_maj = "1.34";
   version = "${ver_maj}.1";
 in
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://gnome/sources/gvfs/${ver_maj}/${name}.tar.xz";
-    sha256 = "e752e7bb46e64e4025f63428d4f5247e3e5c0d0b5eeb4f81dbf1cd7b75f59d7b";
+    sha256 = "1d3j6f252mk316hrspwy63inrhxk6l78l4bmlmql401lqapb5yby";
   };
 
   nativeBuildInputs = [
-    pkgconfig intltool libtool
+    pkgconfig intltool libtool file makeWrapper
     libxml2 libxslt docbook_xsl
   ];
 
   buildInputs =
-    [ makeWrapper glib dbus udev libgudev udisks2 libgcrypt
-      libgphoto2 avahi libarchive fuse libcdio
+    [ glib dbus udev libgudev udisks2 libgcrypt
+      libgphoto2 avahi libarchive fuse libcdio lzma bzip2
       samba libmtp libcap polkit
       # ToDo: a ligther version of libsoup to have FTP/HTTP support?
     ] ++ stdenv.lib.optionals gnomeSupport (with gnome; [
-      gtk libsoup libgnome_keyring gconf gcr
+      libsoup libgnome_keyring gconf gcr
       # ToDo: not working and probably useless until gnome3 from x-updates
     ]);
 

pkgs/development/libraries/json-glib/default.nix

···
-{ stdenv, fetchurl, glib, pkgconfig, gobjectIntrospection, dbus, libintlOrEmpty }:
+{ stdenv, fetchurl, fetchpatch, glib, meson, ninja, pkgconfig, gettext, gobjectIntrospection, dbus, libintlOrEmpty }:
 
 stdenv.mkDerivation rec {
-  name = "json-glib-${minVer}.0";
-  minVer = "1.2";
+  name = "json-glib-${minVer}.2";
+  minVer = "1.4";
 
   src = fetchurl {
     url = "mirror://gnome/sources/json-glib/${minVer}/${name}.tar.xz";
-    sha256 = "1lx7p1c7cl21byvfgw92n8dhm09vi6qxrs0zkx9dg3y096zdzmlr";
+    sha256 = "2d7709a44749c7318599a6829322e081915bdc73f5be5045882ed120bb686dc8";
   };
 
-  configureflags= "--with-introspection";
-
-  propagatedBuildInputs = [ glib gobjectIntrospection ];
-  nativeBuildInputs = [ pkgconfig ];
+  propagatedBuildInputs = [ glib ];
+  nativeBuildInputs = [ meson ninja pkgconfig gettext gobjectIntrospection ];
   buildInputs = libintlOrEmpty;
 
   NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isDarwin "-lintl";
 
+  patches = [
+    # https://gitlab.gnome.org/GNOME/json-glib/issues/27
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/json-glib/merge_requests/2.diff";
+      sha256 = "0pf006jxj1ki7a0w4ykxm6b24m0wafrhpdcmixsw9x83m227156c";
+    })
+  ];
+
   outputs = [ "out" "dev" ];
+
+  doCheck = true;
+
+  checkPhase = "meson test";
 
   meta = with stdenv.lib; {
     homepage = http://live.gnome.org/JsonGlib;

pkgs/development/libraries/libchamplain/default.nix

···
 
 stdenv.mkDerivation rec {
   major = "0.12";
-  version = "${major}.14";
+  version = "${major}.16";
   name = "libchamplain-${version}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/libchamplain/${major}/${name}.tar.xz";
-    sha256 = "13snnka1jqc5qrgij8bm22xy02pncf3dn5ij3jh4rrpzq7g1sqpi";
+    sha256 = "13chvc2n074i0jw5jlb8i7cysda4yqx58ca6y3mrlrl9g37k2zja";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/libevdev/default.nix

···
 { stdenv, fetchurl, python }:
 
 stdenv.mkDerivation rec {
-  name = "libevdev-1.5.6";
+  name = "libevdev-1.5.7";
 
   src = fetchurl {
     url = "https://www.freedesktop.org/software/libevdev/${name}.tar.xz";
-    sha256 = "1256ypz93039n6km4macg158fpmjgylhmcmk20pnklxicsfpxv7c";
+    sha256 = "08nl3p6226k51zph52fhilxvi3b31spp6fz8szzrglzhl8vrxrd1";
   };
 
   buildInputs = [ python ];

pkgs/development/libraries/libgtop/default.nix

···
 { stdenv, fetchurl, glib, pkgconfig, perl, intltool, gobjectIntrospection, libintlOrEmpty }:
 stdenv.mkDerivation rec {
   name = "libgtop-${version}";
-  major = "2.34";
-  version = "${major}.1";
+  major = "2.38";
+  version = "${major}.0";
 
   src = fetchurl {
     url = "mirror://gnome/sources/libgtop/${major}/${name}.tar.xz";
-    sha256 = "c89978a76662b18d392edbe0d1b794f5a9a399a5ccf22a02d5b9e28b5ed609e2";
+    sha256 = "04mnxgzyb26wqk6qij4iw8cxwl82r8pcsna5dg8vz2j3pdi0wv2g";
   };
 
   propagatedBuildInputs = [ glib ];

pkgs/development/libraries/libgudev/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "libgudev-${version}";
-  version = "231";
+  version = "232";
 
   src = fetchurl {
-    url = "https://download.gnome.org/sources/libgudev/${version}/${name}.tar.xz";
-    sha256 = "15iz0qp57qy5pjrblsn36l0chlncqggqsg8h8i8c71499afzj7iv";
+    url = "mirror://gnome/sources/libgudev/${version}/${name}.tar.xz";
+    sha256 = "ee4cb2b9c573cdf354f6ed744f01b111d4b5bed3503ffa956cefff50489c7860";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/libical/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "libical-${version}";
-  version = "1.0.1";
+  version = "2.0.0";
 
   src = fetchFromGitHub {
     owner = "libical";
     repo = "libical";
     rev = "v${version}";
-    sha256 = "1y6rbw24m133d984pyqzx2bi7f37dsw6f33l6arwn6yd4zlqdib9";
+    sha256 = "0xsvqy1hzmwxn783wrb2k8p751544pzv39v9ynr9pj4yzkwjzsvb";
   };
 
   nativeBuildInputs = [ perl cmake ];
 
-  patches = [ ./respect-env-tzdir.patch ];
+  patches = [
+    # TODO: upstream this patch
+    ./respect-env-tzdir.patch
+  ];
 
   meta = with stdenv.lib; {
     homepage = https://github.com/libical/libical;

pkgs/development/libraries/libical/respect-env-tzdir.patch

···
---- a/src/libical/icaltz-util.c	2015-06-11 15:40:58.843138630 +0200
-+++ b/src/libical/icaltz-util.c	2015-06-11 15:43:12.722046252 +0200
-@@ -107,7 +107,7 @@
- 	char	charcnt[4];			
- } tzinfo; 
- 
--static char *search_paths [] = {"/usr/share/zoneinfo","/usr/lib/zoneinfo","/etc/zoneinfo","/usr/share/lib/zoneinfo"};
-+static char *search_paths [] = {"/etc/zoneinfo","/usr/share/zoneinfo","/usr/lib/zoneinfo","/usr/share/lib/zoneinfo"};
+--- a/src/libical/icaltz-util.c
++++ b/src/libical/icaltz-util.c
+@@ -96,9 +96,9 @@ typedef struct
  static char *zdir = NULL;
  
- #define NUM_SEARCH_PATHS (sizeof (search_paths)/ sizeof (search_paths [0]))
-@@ -194,6 +194,15 @@
- 	const char *fname = ZONES_TAB_SYSTEM_FILENAME;
- 	unsigned int i;
+ static char *search_paths[] = {
++    "/etc/zoneinfo",
+     "/usr/share/zoneinfo",
+     "/usr/lib/zoneinfo",
+-    "/etc/zoneinfo",
+     "/usr/share/lib/zoneinfo"
+ };
  
-+	const char *env_tzdir = getenv ("TZDIR");
-+	if (env_tzdir) {
-+		sprintf (file_path, "%s/%s", env_tzdir, fname);
-+		if (!access (file_path, F_OK|R_OK)) {
-+			zdir = env_tzdir;
-+			return;
-+		}
-+	}
+@@ -179,6 +179,15 @@ static void set_zonedir(void)
+     const char *fname = ZONES_TAB_SYSTEM_FILENAME;
+     size_t i, num_search_paths;
+ 
++   const char *env_tzdir = getenv ("TZDIR");
++   if (env_tzdir) {
++       snprintf(file_path, MAXPATHLEN, "%s/%s", env_tzdir, fname);
++       if (!access (file_path, F_OK|R_OK)) {
++           zdir = env_tzdir;
++           return;
++       }
++   }
 +
- 	for (i = 0; i < NUM_SEARCH_PATHS; i++) {
- 		sprintf (file_path, "%s/%s", search_paths [i], fname);
- 		if (!access (file_path, F_OK|R_OK)) {
+     num_search_paths = sizeof(search_paths) / sizeof(search_paths[0]);
+     for (i = 0; i < num_search_paths; i++) {
+         snprintf(file_path, MAXPATHLEN, "%s/%s", search_paths[i], fname);

pkgs/development/libraries/libidn/default.nix

···
 
   outputs = [ "bin" "dev" "out" "info" "devdoc" ];
 
-  doCheck = ! stdenv.isDarwin;
+  doCheck = (stdenv.buildPlatform == stdenv.hostPlatform) && !stdenv.isDarwin;
 
   hardeningDisable = [ "format" ];
 

pkgs/development/libraries/libinput/default.nix

···
-{ stdenv, fetchurl, pkgconfig
+{ stdenv, fetchurl, pkgconfig, meson, ninja
 , libevdev, mtdev, udev, libwacom
 , documentationSupport ? false, doxygen ? null, graphviz ? null # Documentation
 , eventGUISupport ? false, cairo ? null, glib ? null, gtk3 ? null # GUI event viewer support
-, testsSupport ? false, check ? null, valgrind ? null
-, autoconf, automake
+, testsSupport ? false, check ? null, valgrind ? null, python3Packages ? null
 }:
 
 assert documentationSupport -> doxygen != null && graphviz != null;
 assert eventGUISupport -> cairo != null && glib != null && gtk3 != null;
-assert testsSupport -> check != null && valgrind != null;
+assert testsSupport -> check != null && valgrind != null && python3Packages != null;
 
 let
-  mkFlag = optSet: flag: if optSet then "--enable-${flag}" else "--disable-${flag}";
+  mkFlag = optSet: flag: "-D${flag}=${stdenv.lib.boolToString optSet}";
 in
 
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "libinput-${version}";
-  version = "1.7.3";
+  version = "1.9.1";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/libinput/${name}.tar.xz";
-    sha256 = "07fbzxddvhjcch43hdxb24sj7ri96zzpcjalvsicmw0i4wnn2v89";
+    sha256 = "1y3559146zlfizncky1jlly226i66vwikxhpdkw0jg8v47j0sy7h";
   };
 
   outputs = [ "out" "dev" ];
 
-  configureFlags = [
+  mesonFlags = [
     (mkFlag documentationSupport "documentation")
-    (mkFlag eventGUISupport "event-gui")
+    (mkFlag eventGUISupport "debug-gui")
     (mkFlag testsSupport "tests")
   ];
 
-  nativeBuildInputs = [ pkgconfig ];
-
-  buildInputs = [ libevdev mtdev libwacom autoconf automake ]
-    ++ optionals eventGUISupport [ cairo glib gtk3 ]
+  nativeBuildInputs = [ pkgconfig meson ninja ]
     ++ optionals documentationSupport [ doxygen graphviz ]
-    ++ optionals testsSupport [ check valgrind ];
+    ++ optionals testsSupport [ check valgrind python3Packages.pyparsing ];
+
+  buildInputs = [ libevdev mtdev libwacom ]
+    ++ optionals eventGUISupport [ cairo glib gtk3 ];
 
   propagatedBuildInputs = [ udev ];
 
   patches = [ ./udev-absolute-path.patch ];
-  patchFlags = [ "-p0" ];
+
+   preBuild = ''
+    # meson setup-hook changes the directory so the files are located one level up
+    patchShebangs ../udev/parse_hwdb.py
+    patchShebangs ../test/symbols-leak-test.in
+  '';
+
+  doCheck = testsSupport;
+
+  checkPhase = "meson test";
 
   meta = {
     description = "Handles input devices in Wayland compositors and provides a generic X.Org input driver";

pkgs/development/libraries/libinput/udev-absolute-path.patch

···
---- configure.ac	2016-05-27 14:00:25.248388226 +0200
-+++ configure.ac	2016-05-27 14:01:28.228943416 +0200
-@@ -214,7 +214,8 @@ AM_CONDITIONAL(BUILD_DOCS, [test "x$buil
- # Used by the udev rules so we can use callouts during testing without
- # installing everything first. Default is the empty string so the installed
- # rule will use udev's default path. Override is in udev/Makefile.am
--AC_SUBST(UDEV_TEST_PATH, "")
-+UDEV_TEST_PATH="${UDEV_DIR}/"
-+AC_SUBST(UDEV_TEST_PATH)
- AC_PATH_PROG(SED, [sed])
+--- a/meson.build
++++ b/meson.build
+@@ -100,7 +100,7 @@
+      args : model_quirks)
  
- AC_CONFIG_FILES([Makefile
+ udev_rules_config = configuration_data()
+-udev_rules_config.set('UDEV_TEST_PATH', '')
++udev_rules_config.set('UDEV_TEST_PATH', udev_dir + '/')
+ configure_file(input : 'udev/80-libinput-device-groups.rules.in',
+ 	       output : '80-libinput-device-groups.rules',
+ 	       install : true,

pkgs/development/libraries/libjpeg-turbo/default.nix

···
 
   enableParallelBuilding = true;
 
-  doCheck = true;
+  doCheck = stdenv.buildPlatform == stdenv.hostPlatform;
   checkTarget = "test";
 
   meta = with stdenv.lib; {

pkgs/development/libraries/librsvg/default.nix

···
 # no introspection by default, it's too big
 
 stdenv.mkDerivation rec {
-  name = "librsvg-2.40.17";
+  name = "librsvg-2.40.19";
 
   src = fetchurl {
-    url    = "mirror://gnome/sources/librsvg/2.40/${name}.tar.xz";
-    sha256 = "1k39gyf7f5m9x0jvpcxvfcqswdb04xhm1lbwbjabn1f4xk5wbxp6";
+    url    = "mirror://gnome/sources/librsvg/2.40/librsvg-2.40.18.tar.xz";
+    sha256 = "0k2nbd4g31qinkdfd8r5c5ih2ixl85fbkgkqqh9747lwr24c9j5z";
   };
 
   NIX_LDFLAGS = if stdenv.isDarwin then "-lintl" else null;

pkgs/development/libraries/libtiff/default.nix

···
 
   enableParallelBuilding = true;
 
-  doCheck = true;
+  doCheck = stdenv.buildPlatform == stdenv.hostPlatform;
 
   meta = with stdenv.lib; {
     description = "Library and utilities for working with the TIFF image file format";

pkgs/development/libraries/libunistring/default.nix

···
 
   # XXX: There are test failures on non-GNU systems, see
   # http://lists.gnu.org/archive/html/bug-libunistring/2010-02/msg00004.html .
-  doCheck = stdenv ? glibc;
+  doCheck = (stdenv ? glibc) && (stdenv.hostPlatform == stdenv.buildPlatform);
 
   meta = {
     homepage = http://www.gnu.org/software/libunistring/;

pkgs/development/libraries/libwacom/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "libwacom-${version}";
-  version = "0.22";
+  version = "0.26";
 
   src = fetchurl {
     url = "mirror://sourceforge/linuxwacom/libwacom/${name}.tar.bz2";
-    sha256 = "1h10awwapj5v8nik220ga0raggv3lgaq0kzwlma2qjmzdhhrrhcp";
+    sha256 = "0xpvkjvzaj9blcmw8ha46616bzfivj99kwzvr91clxd6iaf11r63";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/libxkbcommon/default.nix

···
 { stdenv, fetchurl, pkgconfig, yacc, flex, xkeyboard_config, libxcb, libX11 }:
 
 stdenv.mkDerivation rec {
-  name = "libxkbcommon-0.7.1";
+  name = "libxkbcommon-0.7.2";
 
   src = fetchurl {
     url = "http://xkbcommon.org/download/${name}.tar.xz";
-    sha256 = "ba59305d2e19e47c27ea065c2e0df96ebac6a3c6e97e28ae5620073b6084e68b";
+    sha256 = "1n5rv5n210kjnkyrvbh04gfwaa7zrmzy1393p8nyqfw66lkxr918";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/libxml2/default.nix

···
 
   enableParallelBuilding = true;
 
-  doCheck = !stdenv.isDarwin;
+  doCheck = (stdenv.hostPlatform == stdenv.buildPlatform) && !stdenv.isDarwin;
 
   crossAttrs = lib.optionalAttrs (hostPlatform.libc == "msvcrt") {
     # creating the DLL is broken ATM

pkgs/development/libraries/lzo/default.nix

···
 
   enableParallelBuilding = true;
 
-  doCheck = true;
+  doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
 
   meta = with stdenv.lib; {
     description = "Real-time data (de)compression library";

pkgs/development/libraries/portaudio/default.nix

···
   buildInputs = [ libjack2 ]
     ++ stdenv.lib.optional (!stdenv.isDarwin) alsaLib;
 
-  configureFlags = [ "--disable-mac-universal" ];
+  configureFlags = [ "--disable-mac-universal --enable-cxx" ];
 
   propagatedBuildInputs = stdenv.lib.optionals stdenv.isDarwin [ AudioUnit AudioToolbox CoreAudio CoreServices Carbon ];
 

pkgs/development/libraries/qt-5/qtbase-setup-hook-darwin.sh

···
 qtDocPrefix=@qtDocPrefix@
 
 _qtRmCMakeLink() {
-    find "${!outputLib}" -name "*.cmake" -type l | xargs rm
+    find "${!outputLib}" -name "*.cmake" -type l -delete
 }
 
 postInstallHooks+=(_qtRmCMakeLink)

pkgs/development/libraries/spice-gtk/default.nix

···
-{ stdenv, fetchurl, pkgconfig, spice_protocol, intltool, celt_0_5_1
+{ stdenv, fetchurl, pkgconfig, spice_protocol, gettext, celt_0_5_1
 , openssl, libpulseaudio, pixman, gobjectIntrospection, libjpeg_turbo, zlib
 , cyrus_sasl, python2Packages, autoreconfHook, usbredir, libsoup
 , gtk3, epoxy }:
···
 let
   inherit (python2Packages) python pygtk;
 in stdenv.mkDerivation rec {
-  name = "spice-gtk-0.33";
+  name = "spice-gtk-0.34";
 
   src = fetchurl {
     url = "http://www.spice-space.org/download/gtk/${name}.tar.bz2";
-    sha256 = "0fdgx9k4vgmasp8i2n0swrkapq8f212igcg7wsgvr3mbhsvk7bvx";
+    sha256 = "1vknp72pl6v6nf3dphhwp29hk6gv787db2pmyg4m312z2q0hwwp9";
   };
 
   buildInputs = [
···
     libjpeg_turbo zlib cyrus_sasl python pygtk usbredir gtk3 epoxy
   ];
 
-  nativeBuildInputs = [ pkgconfig intltool libsoup autoreconfHook ];
+  nativeBuildInputs = [ pkgconfig gettext libsoup autoreconfHook ];
 
   NIX_CFLAGS_COMPILE = "-fno-stack-protector";
 
   preAutoreconf = ''
     substituteInPlace src/Makefile.am \
           --replace '=codegendir pygtk-2.0' '=codegendir pygobject-2.0'
-  '';
-
-  preConfigure = ''
-    intltoolize -f
   '';
 
   configureFlags = [

pkgs/development/libraries/spice-protocol/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "spice-protocol-0.12.12";
+  name = "spice-protocol-0.12.13";
 
   src = fetchurl {
     url = "http://www.spice-space.org/download/releases/${name}.tar.bz2";
-    sha256 = "00wx81f2ml62g3maw63jq9w217zym921rdi38h7lpm5m8ckxraqp";
+    sha256 = "0cwrgkp558mblcf4vrhacb3iizz12khsrrl82w38w9nj0ar13vl9";
   };
 
   postInstall = ''

pkgs/development/libraries/telepathy/glib/default.nix

···
 { stdenv, fetchurl, dbus_glib, glib, python2, pkgconfig, libxslt
-, gobjectIntrospection, valaSupport ? true, vala_0_23, glibcLocales }:
+, gobjectIntrospection, valaSupport ? true, vala_0_38, glibcLocales }:
 
 stdenv.mkDerivation rec {
   name = "telepathy-glib-0.24.1";
···
   LC_ALL = "en_US.UTF-8";
   propagatedBuildInputs = [dbus_glib glib gobjectIntrospection];
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ libxslt glibcLocales python2 ] ++ stdenv.lib.optional valaSupport vala_0_23;
+  nativeBuildInputs = [ pkgconfig libxslt ] ++ stdenv.lib.optional valaSupport vala_0_38;
+  buildInputs = [ glibcLocales python2 ];
 
   preConfigure = ''
     substituteInPlace telepathy-glib/telepathy-glib.pc.in --replace Requires.private Requires

pkgs/development/libraries/vapoursynth/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, autoreconfHook,
-  zimg, libass, yasm, python3, libiconv, ApplicationServices,
-  ocrSupport ?  false, tesseract,
-  imwriSupport? true,  imagemagick7
+{ stdenv, fetchFromGitHub, pkgconfig, autoreconfHook
+, zimg, libass, python3, libiconv
+, ApplicationServices, nasm
+, ocrSupport ?  false, tesseract
+, imwriSupport? true,  imagemagick7
 }:
 
 assert ocrSupport   -> tesseract != null;
···
 
 stdenv.mkDerivation rec {
   name = "vapoursynth-${version}";
-  version = "R38";
+  version = "R39";
 
   src = fetchFromGitHub {
     owner  = "vapoursynth";
     repo   = "vapoursynth";
     rev    = version;
-    sha256 = "0nabl6949s7awy7rnr4ck52v50xr0hwr280fyzsqixgp8w369jn0";
+    sha256 = "0cw7w8xiwhxhwykydy13m44wm9vn9hrsi30z6017ngga9d84fhqy";
   };
 
-  nativeBuildInputs = [ pkgconfig autoreconfHook ];
+  nativeBuildInputs = [ pkgconfig autoreconfHook nasm ];
   buildInputs = [
-    zimg libass tesseract yasm
+    zimg libass
     (python3.withPackages (ps: with ps; [ sphinx cython ]))
   ] ++ optionals stdenv.isDarwin [ libiconv ApplicationServices ]
     ++ optional ocrSupport   tesseract

pkgs/development/libraries/vrb/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "vrb-${version}";
+  version = "0.5.1";
+
+  src = fetchurl {
+    url = "http://vrb.sourceforge.net/download/${name}.tar.bz2";
+    sha256 = "d579ed1998ef2d78e2ef8481a748d26e1fa12cdda806d2e31d8ec66ffb0e289f";
+  };
+
+  patches = [
+    ./removed_options.patch
+    ./unused-but-set-variable.patch
+  ];
+
+  postPatch = ''
+    patchShebangs configure
+  '';
+
+  postInstall = ''
+    mkdir -p $out/share/man/man3
+    cp -p vrb/man/man3/*.3 $out/share/man/man3/
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A virtual ring buffer library written in C";
+    license     = licenses.lgpl21;
+    homepage    = http://vrb.sourceforge.net/;
+    maintainers = [ maintainers.bobvanderlinden ];
+    platforms   = platforms.linux;
+  };
+}
+

pkgs/development/libraries/vrb/removed_options.patch

···
+--- a/configure	2010-10-05 16:32:59.000000000 +0200
++++ b/configure	2010-10-05 16:33:08.000000000 +0200
+@@ -341,8 +341,8 @@
+     pgm_warn=( "${pgm_warn[@]}" -Winline )
+ fi
+ 
+-lib_feat=( -fomit-frame-pointer -funsigned-char -funsigned-bitfields -fgnu-linker -frerun-loop-opt -finline -finline-functions -fmove-all-movables )
+-pgm_feat=( -fomit-frame-pointer -funsigned-char -funsigned-bitfields -fgnu-linker -frerun-loop-opt -finline -finline-functions -fmove-all-movables )
++lib_feat=( -fomit-frame-pointer -funsigned-char -funsigned-bitfields -frerun-loop-opt -finline -finline-functions )
++pgm_feat=( -fomit-frame-pointer -funsigned-char -funsigned-bitfields -frerun-loop-opt -finline -finline-functions )
+ 
+ lib_cp_opt=( -pipe )
+ pgm_cp_opt=( -pipe )

pkgs/development/libraries/vrb/unused-but-set-variable.patch

···
+--- a/vrb/src/bin/vbuf.c1	2011-06-13 22:14:24.000000000 +0200
++++ b/vrb/src/bin/vbuf.c	2011-06-13 22:14:43.000000000 +0200
+@@ -426,7 +426,6 @@
+     int			opt_progress		;
+     int			output_fd		;
+     int			poll_time		;
+-    int			poll_num		;
+     int			poll_write		;
+     int			poll_read		;
+ 
+@@ -861,7 +860,7 @@
+ 	    poll_time = display_time - get_time_ms();
+ 	    if ( poll_time < 0 ) poll_time = 0;
+ 	}
+-	poll_num = poll( poll_list, 2, poll_time );
++	poll( poll_list, 2, poll_time );
+ 
+ 	//-----------------------
+ 	// Check for poll events.

pkgs/development/libraries/wxwidgets/2.9/default.nix

···
     sha256 = "04jda4bns7cmp7xy68qz112yg0lribpc6xs5k9gilfqcyhshqlvc";
   };
 
+  patches = [
+    (fetchurl { # https://trac.wxwidgets.org/ticket/17942
+      url = "https://trac.wxwidgets.org/raw-attachment/ticket/17942/"
+          + "fix_assertion_using_hide_in_destroy.diff";
+      sha256 = "009y3dav79wiig789vkkc07g1qdqprg1544lih79199kb1h64lvy";
+    })
+  ];
+
   buildInputs =
     [ gtk2 libXinerama libSM libXxf86vm xf86vidmodeproto gstreamer
       gst-plugins-base GConf ]

pkgs/development/libraries/wxwidgets/3.0/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, pkgconfig, gtk2, gtk3, libXinerama, libSM, libXxf86vm
+{ stdenv, fetchFromGitHub, fetchurl, fetchpatch, pkgconfig
+, gtk2, gtk3, libXinerama, libSM, libXxf86vm
 , xf86vidmodeproto , gstreamer, gst-plugins-base, GConf, setfile
 , withMesa ? true, mesa_glu ? null, mesa_noglu ? null
 , compat24 ? false, compat26 ? true, unicode ? true
···
 
   propagatedBuildInputs = optional stdenv.isDarwin AGL;
 
-  patches =
+  patches = [
+    (fetchurl { # https://trac.wxwidgets.org/ticket/17942
+      url = "https://trac.wxwidgets.org/raw-attachment/ticket/17942/"
+          + "fix_assertion_using_hide_in_destroy.diff";
+      sha256 = "009y3dav79wiig789vkkc07g1qdqprg1544lih79199kb1h64lvy";
+    })
     # "Add support for WebKit2GTK+ in wxWebView". Will be in 3.0.4
-    optional (!withGtk2) (fetchpatch {
+  ] ++ optional (!withGtk2) (fetchpatch {
       url = "https://github.com/wxWidgets/wxWidgets/commit/ec6e54bc893fb7516731ca9c71e0d0bbc5ae9ff7.patch";
       sha256 = "0gxd83xajm7gdv9rdzyvqwa2p5nz29nr23i0zx2dgfpsvz2qjp3q";
     });

pkgs/development/libraries/zeitgeist/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, sqlite, gnome3, vala_0_23
+{ stdenv, fetchgit, pkgconfig, glib, sqlite, gnome3, vala_0_38
 , intltool, libtool, dbus_libs, telepathy_glib
 , gtk3, json_glib, librdf_raptor2, dbus_glib
 , pythonSupport ? true, python2Packages
 }:
 
 stdenv.mkDerivation rec {
-  version = "0.9.15";
+  version = "1.0";
   name = "zeitgeist-${version}";
 
-  src = fetchurl {
-    url = "https://github.com/seiflotfy/zeitgeist/archive/v${version}.tar.gz";
-    sha256 = "07pnc7kmjpd0ncm32z6s3ny5p4zl52v9lld0n0f8sp6cw87k12p0";
+  src = fetchgit {
+    url = "git://anongit.freedesktop.org/git/zeitgeist/zeitgeist";
+    rev = "v${version}";
+    sha256 = "0vw6m0azycqabbz8f0fd8xsh5kf6j3ig4wpqlhw6sklvf44ii5b8";
   };
 
   NIX_CFLAGS_COMPILE = "-I${glib.dev}/include/gio-unix-2.0";
···
 
   configureFlags = [ "--with-session-bus-services-dir=$(out)/share/dbus-1/services" ];
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ glib sqlite gnome3.gnome_common intltool
-                  libtool dbus_libs telepathy_glib vala_0_23 dbus_glib
+  nativeBuildInputs = [ pkgconfig gnome3.gnome_common intltool libtool vala_0_38 ];
+  buildInputs = [ glib sqlite dbus_libs telepathy_glib dbus_glib
                   gtk3 json_glib librdf_raptor2 python2Packages.rdflib ];
 
   prePatch = "patchShebangs .";

pkgs/development/libraries/zimg/default.nix

···
 
 stdenv.mkDerivation rec{
   name = "zimg-${version}";
-  version = "2.4";
+  version = "2.6.1";
 
   src = fetchFromGitHub {
     owner  = "sekrit-twc";
     repo   = "zimg";
-    rev    = "v${version}";
-    sha256 = "11pk8a5manr751jhy0xrql57jzab57lwqjxbpd8kvm9m8b51icwq";
+    rev    = "release-${version}";
+    sha256 = "08hynzcxz95a4i67k5cn6isafdb6xjgd0x0miyhlnp2xc220zfqj";
   };
 
   nativeBuildInputs = [ autoreconfHook ];
-  buildInputs = [ ];
 
   meta = with stdenv.lib; {
     description = "Scaling, colorspace conversion and dithering library";

pkgs/development/node-packages/default-v6.nix

···
     '';
   });
 
-  fast-cli = nodePackages.fast-cli.override (oldAttrs: {
+  fast-cli = nodePackages."fast-cli-1.x".override (oldAttrs: {
     preRebuild = ''
       # Simply ignore the phantomjs --version check. It seems to need a display but it is safe to ignore
       sed -i -e "s|console.error('Error verifying phantomjs, continuing', err)|console.error('Error verifying phantomjs, continuing', err); return true;|" node_modules/phantomjs-prebuilt/lib/util.js

pkgs/development/node-packages/node-packages-v6.json

···
 , "eslint"
 , "eslint_d"
 , "emojione"
-, "fast-cli"
+, { "fast-cli": "1.x" }
 , "fetch-bower"
 , "forever"
 , "git-run"
···
 , "sloc"
 , "smartdc"
 , "socket.io"
+, "statsd"
 , "stylus"
 , "svgo"
 , "tern"

pkgs/development/node-packages/node-packages-v6.nix

···
         sha1 = "cac328f7bee45730d404b692203fcb590e172d5e";
       };
     };
-    "aws-sdk-2.144.0" = {
+    "aws-sdk-2.145.0" = {
       name = "aws-sdk";
       packageName = "aws-sdk";
-      version = "2.144.0";
+      version = "2.145.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/aws-sdk/-/aws-sdk-2.144.0.tgz";
-        sha1 = "14d8179bb44971b08426c63a1cc5f63dc09389e7";
+        url = "https://registry.npmjs.org/aws-sdk/-/aws-sdk-2.145.0.tgz";
+        sha1 = "085bb4553231defd93b96b0d95023717c9c3c093";
       };
     };
     "request-2.83.0" = {
···
         sha1 = "415c4478f2bcc30120c22ce10ed3226f7d3e18e0";
       };
     };
-    "log-update-2.2.0" = {
+    "log-update-2.3.0" = {
       name = "log-update";
       packageName = "log-update";
-      version = "2.2.0";
+      version = "2.3.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/log-update/-/log-update-2.2.0.tgz";
-        sha1 = "e1b034d4325e3436c9df1aa7fd9c9c243bfb9198";
+        url = "https://registry.npmjs.org/log-update/-/log-update-2.3.0.tgz";
+        sha1 = "88328fd7d1ce7938b29283746f0b1bc126b24708";
       };
     };
     "prop-types-15.6.0" = {
···
         sha1 = "9d9e793165ce017a00f00418c43f942a7b1d11fa";
       };
     };
+    "log-update-1.0.2" = {
+      name = "log-update";
+      packageName = "log-update";
+      version = "1.0.2";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/log-update/-/log-update-1.0.2.tgz";
+        sha1 = "19929f64c4093d2d2e7075a1dad8af59c296b8d1";
+      };
+    };
     "ora-1.3.0" = {
       name = "ora";
       packageName = "ora";
···
         sha1 = "80078dd2b92a934af66a3ad72a5b910694ede51a";
       };
     };
-    "puppeteer-0.12.0" = {
-      name = "puppeteer";
-      packageName = "puppeteer";
-      version = "0.12.0";
+    "phantomjs-prebuilt-2.1.16" = {
+      name = "phantomjs-prebuilt";
+      packageName = "phantomjs-prebuilt";
+      version = "2.1.16";
       src = fetchurl {
-        url = "https://registry.npmjs.org/puppeteer/-/puppeteer-0.12.0.tgz";
-        sha512 = "0lz3hi4l5ajb19cspw7s46bnygfb5njss0jb7nb21p32qjpad8lmnyavipfya9fp2wdq3240b3366n5zqis2ndj6wdwqwf5vsag5xhz";
+        url = "https://registry.npmjs.org/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz";
+        sha1 = "efd212a4a3966d3647684ea8ba788549be2aefef";
       };
     };
-    "zen-observable-0.6.0" = {
+    "promise-phantom-3.1.6" = {
+      name = "promise-phantom";
+      packageName = "promise-phantom";
+      version = "3.1.6";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/promise-phantom/-/promise-phantom-3.1.6.tgz";
+        sha1 = "bbcfd248725259f2bb115a27bfa8d65dc420f931";
+      };
+    };
+    "zen-observable-0.5.2" = {
       name = "zen-observable";
       packageName = "zen-observable";
-      version = "0.6.0";
+      version = "0.5.2";
       src = fetchurl {
-        url = "https://registry.npmjs.org/zen-observable/-/zen-observable-0.6.0.tgz";
-        sha512 = "0i23iwlb1ycrijxi8b09v6fx1nms22g2aj52kmbgqr7n5fxafmjmbbfkiv57c7wzvzayzy5hyqqpcvkbibwmqjdym1a5ykmarwgi6qv";
+        url = "https://registry.npmjs.org/zen-observable/-/zen-observable-0.5.2.tgz";
+        sha512 = "3sy4za4hd6lczig5ah6ksh92i4ds0pk9b8nn4nwjwpsyyabywrnayf78zh41jf7amm6khqyjb3iknbp2mc3nfgvpkvphj3a993py6hf";
       };
     };
     "cli-spinners-1.1.0" = {
···
         sha1 = "376ff7b58ea3086a0f09facc74617eca501e1a18";
       };
     };
+    "es6-promise-4.1.1" = {
+      name = "es6-promise";
+      packageName = "es6-promise";
+      version = "4.1.1";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/es6-promise/-/es6-promise-4.1.1.tgz";
+        sha512 = "2g2gkw8cxy2lww5lqjbv0imkxkhy684pagbq4qaw6np46xcx1r6rbkg7qy4wjv12b7jy7zs208iilim7clc9v6ws2dzy9g0g223b99r";
+      };
+    };
     "extract-zip-1.6.6" = {
       name = "extract-zip";
       packageName = "extract-zip";
···
         sha1 = "1290ede8d20d0872b429fd3f351ca128ec5ef85c";
       };
     };
-    "https-proxy-agent-2.1.0" = {
-      name = "https-proxy-agent";
-      packageName = "https-proxy-agent";
-      version = "2.1.0";
+    "fs-extra-1.0.0" = {
+      name = "fs-extra";
+      packageName = "fs-extra";
+      version = "1.0.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.1.0.tgz";
-        sha512 = "17fg8xbji1zam9ksqgdfsyhqfw1nyniz8gwp54q0z7rz1pxw2m3agniawm870nn4j88m1w9l0lfkw5wa4qf1593if0cwicv814xad7w";
+        url = "https://registry.npmjs.org/fs-extra/-/fs-extra-1.0.0.tgz";
+        sha1 = "cd3ce5f7e7cb6145883fcae3191e9877f8587950";
       };
     };
-    "proxy-from-env-1.0.0" = {
-      name = "proxy-from-env";
-      packageName = "proxy-from-env";
-      version = "1.0.0";
+    "hasha-2.2.0" = {
+      name = "hasha";
+      packageName = "hasha";
+      version = "2.2.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.0.0.tgz";
-        sha1 = "33c50398f70ea7eb96d21f7b817630a55791c7ee";
+        url = "https://registry.npmjs.org/hasha/-/hasha-2.2.0.tgz";
+        sha1 = "78d7cbfc1e6d66303fe79837365984517b2f6ee1";
       };
     };
-    "ws-3.2.0" = {
-      name = "ws";
-      packageName = "ws";
-      version = "3.2.0";
+    "kew-0.7.0" = {
+      name = "kew";
+      packageName = "kew";
+      version = "0.7.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/ws/-/ws-3.2.0.tgz";
-        sha512 = "1bj83dg7c5sca2v9cpzz4m83y9mm8icldvpk2c9sq3216cr6cn7qvfwhw9hq881nq7pii3xxbg8lz6g2p6223ililwkzzp68ndbfd45";
+        url = "https://registry.npmjs.org/kew/-/kew-0.7.0.tgz";
+        sha1 = "79d93d2d33363d6fdd2970b335d9141ad591d79b";
+      };
+    };
+    "request-progress-2.0.1" = {
+      name = "request-progress";
+      packageName = "request-progress";
+      version = "2.0.1";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/request-progress/-/request-progress-2.0.1.tgz";
+        sha1 = "5d36bb57961c673aa5b788dbc8141fdf23b44e08";
       };
     };
     "mkdirp-0.5.0" = {
···
         sha1 = "7a57eb550a6783f9115331fcf4663d5c8e007a50";
       };
     };
-    "agent-base-4.1.1" = {
-      name = "agent-base";
-      packageName = "agent-base";
-      version = "4.1.1";
+    "throttleit-1.0.0" = {
+      name = "throttleit";
+      packageName = "throttleit";
+      version = "1.0.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/agent-base/-/agent-base-4.1.1.tgz";
-        sha512 = "2naw79i4m7pj1n5qw9xq6c0c8cdjfcqhdqk4j552nbrpb4c60hic13jfikqw7xga8xywpr57z2y5z70gn5xiihq47vzs3wrc1998qf9";
+        url = "https://registry.npmjs.org/throttleit/-/throttleit-1.0.0.tgz";
+        sha1 = "9e785836daf46743145a5984b6268d828528ac6c";
       };
     };
-    "es6-promisify-5.0.0" = {
-      name = "es6-promisify";
-      packageName = "es6-promisify";
-      version = "5.0.0";
+    "mkpath-1.0.0" = {
+      name = "mkpath";
+      packageName = "mkpath";
+      version = "1.0.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz";
-        sha1 = "5109d62f3e56ea967c4b63505aef08291c8a5203";
+        url = "https://registry.npmjs.org/mkpath/-/mkpath-1.0.0.tgz";
+        sha1 = "ebb3a977e7af1c683ae6fda12b545a6ba6c5853d";
       };
     };
-    "es6-promise-4.1.1" = {
-      name = "es6-promise";
-      packageName = "es6-promise";
-      version = "4.1.1";
+    "node-phantom-simple-2.2.4" = {
+      name = "node-phantom-simple";
+      packageName = "node-phantom-simple";
+      version = "2.2.4";
       src = fetchurl {
-        url = "https://registry.npmjs.org/es6-promise/-/es6-promise-4.1.1.tgz";
-        sha512 = "2g2gkw8cxy2lww5lqjbv0imkxkhy684pagbq4qaw6np46xcx1r6rbkg7qy4wjv12b7jy7zs208iilim7clc9v6ws2dzy9g0g223b99r";
+        url = "https://registry.npmjs.org/node-phantom-simple/-/node-phantom-simple-2.2.4.tgz";
+        sha1 = "4fc4effbb02f241fb5082bd4fbab398e4aecb64d";
       };
     };
-    "async-limiter-1.0.0" = {
-      name = "async-limiter";
-      packageName = "async-limiter";
-      version = "1.0.0";
+    "tmp-0.0.31" = {
+      name = "tmp";
+      packageName = "tmp";
+      version = "0.0.31";
       src = fetchurl {
-        url = "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz";
-        sha512 = "1ddib7nbyayhldvsyrfdpxk7khyi6s72570gkf3qqf4b1xwzdh52w0vlj6bknl40imispychhwfjb2bm29pjxbd5yz26fi8g8bfx7wf";
+        url = "https://registry.npmjs.org/tmp/-/tmp-0.0.31.tgz";
+        sha1 = "8f38ab9438e17315e5dbd8b3657e8bfb277ae4a7";
       };
     };
     "glob-3.2.11" = {
···
         sha512 = "2b8y1xdv7szw0hvad64rghp2zdahs6qhx0k79c0s9xa0a35zbcrb9b9gywixhcxqi1c9ab7ah8ibra22k8baakh7rvmhf904d559g32";
       };
     };
+    "ws-3.3.0" = {
+      name = "ws";
+      packageName = "ws";
+      version = "3.3.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/ws/-/ws-3.3.0.tgz";
+        sha512 = "04dfjwby2clbbb8pijv63a46hi2s4vl03p1l6yg533ra5hz5x6205z8bgdwkm5y2xw1j067msjbl08x7175lqhsh2rqw91cirzhdz2w";
+      };
+    };
     "netmask-1.0.6" = {
       name = "netmask";
       packageName = "netmask";
···
       src = fetchurl {
         url = "https://registry.npmjs.org/bytes/-/bytes-1.0.0.tgz";
         sha1 = "3569ede8ba34315fab99c3e92cb04c7220de1fa8";
+      };
+    };
+    "async-limiter-1.0.0" = {
+      name = "async-limiter";
+      packageName = "async-limiter";
+      version = "1.0.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz";
+        sha512 = "1ddib7nbyayhldvsyrfdpxk7khyi6s72570gkf3qqf4b1xwzdh52w0vlj6bknl40imispychhwfjb2bm29pjxbd5yz26fi8g8bfx7wf";
       };
     };
     "is-wsl-1.1.0" = {
···
         sha1 = "b8af9caba00949e568e369f1327ea9be9ea2461b";
       };
     };
-    "tmp-0.0.31" = {
-      name = "tmp";
-      packageName = "tmp";
-      version = "0.0.31";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/tmp/-/tmp-0.0.31.tgz";
-        sha1 = "8f38ab9438e17315e5dbd8b3657e8bfb277ae4a7";
-      };
-    };
     "useragent-2.2.1" = {
       name = "useragent";
       packageName = "useragent";
···
         sha512 = "2mxs6nll208xgqy9asgc0iq4k9ynd2aanig2qkfi3drd8axdafhhx36a58ssksmjgl6s1m2bh2j8igrlpm3k11cg58nhmqbxhlkmv2a";
       };
     };
-    "fs-extra-1.0.0" = {
-      name = "fs-extra";
-      packageName = "fs-extra";
-      version = "1.0.0";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/fs-extra/-/fs-extra-1.0.0.tgz";
-        sha1 = "cd3ce5f7e7cb6145883fcae3191e9877f8587950";
-      };
-    };
     "fs.notify-0.0.4" = {
       name = "fs.notify";
       packageName = "fs.notify";
···
         sha1 = "32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a";
       };
     };
-    "lokijs-1.5.0" = {
+    "lokijs-1.5.1" = {
       name = "lokijs";
       packageName = "lokijs";
-      version = "1.5.0";
+      version = "1.5.1";
       src = fetchurl {
-        url = "https://registry.npmjs.org/lokijs/-/lokijs-1.5.0.tgz";
-        sha1 = "99e403d6a89e47e11ed0c5d499fb55a0603d5efc";
+        url = "https://registry.npmjs.org/lokijs/-/lokijs-1.5.1.tgz";
+        sha512 = "1pi08ry0a4zvg7mqj14gl0vacka95k77bbvljmcf25whxxbkh2rprsxpd8pv6frqh4ix6vslk44silx83sk65xhaw7ia2zssf0vngiy";
       };
     };
     "vscode-languageclient-3.4.5" = {
···
         sha1 = "92ccf6d81ef70a9fa4c1747114ccef6d8688a6c4";
       };
     };
-    "hasha-2.2.0" = {
-      name = "hasha";
-      packageName = "hasha";
-      version = "2.2.0";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/hasha/-/hasha-2.2.0.tgz";
-        sha1 = "78d7cbfc1e6d66303fe79837365984517b2f6ee1";
-      };
-    };
-    "kew-0.7.0" = {
-      name = "kew";
-      packageName = "kew";
-      version = "0.7.0";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/kew/-/kew-0.7.0.tgz";
-        sha1 = "79d93d2d33363d6fdd2970b335d9141ad591d79b";
-      };
-    };
     "request-2.67.0" = {
       name = "request";
       packageName = "request";
···
       src = fetchurl {
         url = "https://registry.npmjs.org/request/-/request-2.67.0.tgz";
         sha1 = "8af74780e2bf11ea0ae9aa965c11f11afd272742";
-      };
-    };
-    "request-progress-2.0.1" = {
-      name = "request-progress";
-      packageName = "request-progress";
-      version = "2.0.1";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/request-progress/-/request-progress-2.0.1.tgz";
-        sha1 = "5d36bb57961c673aa5b788dbc8141fdf23b44e08";
       };
     };
     "which-1.2.14" = {
···
       src = fetchurl {
         url = "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.2.2.tgz";
         sha1 = "c83a1830f4e5ef0b93ef2a3488e724f8de016ac7";
-      };
-    };
-    "throttleit-1.0.0" = {
-      name = "throttleit";
-      packageName = "throttleit";
-      version = "1.0.0";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/throttleit/-/throttleit-1.0.0.tgz";
-        sha1 = "9e785836daf46743145a5984b6268d828528ac6c";
       };
     };
     "browserify-13.3.0" = {
···
         sha512 = "1qi9fsw42grlhv4aj7v42xikvicr5657809syvp4dca33fjzzr1h7x1q9zwhclpyb879g6bgb2yd4i2iasnpmxn8ng1dcnq85yg001r";
       };
     };
-    "boxen-1.2.1" = {
-      name = "boxen";
-      packageName = "boxen";
-      version = "1.2.1";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/boxen/-/boxen-1.2.1.tgz";
-        sha1 = "0f11e7fe344edb9397977fc13ede7f64d956481d";
-      };
-    };
-    "chalk-2.1.0" = {
-      name = "chalk";
-      packageName = "chalk";
-      version = "2.1.0";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/chalk/-/chalk-2.1.0.tgz";
-        sha512 = "1fnn3znivja3xq1lacvsdwkl2s8ki9w95sylnf2pkmaia1mjz3llbdb5r2dxsflqfky3h8f1bh0piv0l5waw2bkdniqnyv0yx5wch9d";
-      };
-    };
     "detect-port-1.2.1" = {
       name = "detect-port";
       packageName = "detect-port";
···
         sha512 = "0r0mpkpa1r78cmagyv47v38fc8ik7pr3zvlnqg57v8nkh4ipd83rla5s1j2c8gymfbwzzlna6pp7h9xw94h93gic3l2z9hzpd68p9fq";
       };
     };
-    "filesize-3.5.10" = {
+    "filesize-3.5.11" = {
       name = "filesize";
       packageName = "filesize";
-      version = "3.5.10";
+      version = "3.5.11";
       src = fetchurl {
-        url = "https://registry.npmjs.org/filesize/-/filesize-3.5.10.tgz";
-        sha1 = "fc8fa23ddb4ef9e5e0ab6e1e64f679a24a56761f";
-      };
-    };
-    "handlebars-4.0.10" = {
-      name = "handlebars";
-      packageName = "handlebars";
-      version = "4.0.10";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/handlebars/-/handlebars-4.0.10.tgz";
-        sha1 = "3d30c718b09a3d96f23ea4cc1f403c4d3ba9ff4f";
+        url = "https://registry.npmjs.org/filesize/-/filesize-3.5.11.tgz";
+        sha512 = "3bg35im21jf6dhyrcajczdjl3rjm5mphdhansyfbpzm067vv3jp91n43nrzxf8q6nx3b5vkn2my1rskyp4pmg91xzdq01lawyifazk4";
       };
     };
     "micro-9.0.0" = {
···
       src = fetchurl {
         url = "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz";
         sha512 = "2z1csf4c3fmlwl0ahk533z5zqkjdf36ccfx11kakl9xran9f5asxm4cxjq4lx1kwqdp8gki786cgpldvgrkvfc7pcvh07j5ssqm8rjg";
+      };
+    };
+    "chalk-2.1.0" = {
+      name = "chalk";
+      packageName = "chalk";
+      version = "2.1.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/chalk/-/chalk-2.1.0.tgz";
+        sha512 = "1fnn3znivja3xq1lacvsdwkl2s8ki9w95sylnf2pkmaia1mjz3llbdb5r2dxsflqfky3h8f1bh0piv0l5waw2bkdniqnyv0yx5wch9d";
       };
     };
     "mri-1.1.0" = {
···
         sha1 = "8a6a4ac3a8c774b6f687fece49bdffd78552e2cd";
       };
     };
+    "generic-pool-2.2.0" = {
+      name = "generic-pool";
+      packageName = "generic-pool";
+      version = "2.2.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/generic-pool/-/generic-pool-2.2.0.tgz";
+        sha1 = "8b465c1a7588ea9dd2bb133bda0bb66bfef8a63e";
+      };
+    };
+    "modern-syslog-1.1.2" = {
+      name = "modern-syslog";
+      packageName = "modern-syslog";
+      version = "1.1.2";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/modern-syslog/-/modern-syslog-1.1.2.tgz";
+        sha1 = "f1fa58899f3f452d788f1573401212a4ef898de5";
+      };
+    };
+    "hashring-3.2.0" = {
+      name = "hashring";
+      packageName = "hashring";
+      version = "3.2.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/hashring/-/hashring-3.2.0.tgz";
+        sha1 = "fda4efde8aa22cdb97fb1d2a65e88401e1c144ce";
+      };
+    };
+    "winser-0.1.6" = {
+      name = "winser";
+      packageName = "winser";
+      version = "0.1.6";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/winser/-/winser-0.1.6.tgz";
+        sha1 = "08663dc32878a12bbce162d840da5097b48466c9";
+      };
+    };
+    "connection-parse-0.0.7" = {
+      name = "connection-parse";
+      packageName = "connection-parse";
+      version = "0.0.7";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/connection-parse/-/connection-parse-0.0.7.tgz";
+        sha1 = "18e7318aab06a699267372b10c5226d25a1c9a69";
+      };
+    };
+    "simple-lru-cache-0.0.2" = {
+      name = "simple-lru-cache";
+      packageName = "simple-lru-cache";
+      version = "0.0.2";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/simple-lru-cache/-/simple-lru-cache-0.0.2.tgz";
+        sha1 = "d59cc3a193c1a5d0320f84ee732f6e4713e511dd";
+      };
+    };
+    "sequence-2.2.1" = {
+      name = "sequence";
+      packageName = "sequence";
+      version = "2.2.1";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/sequence/-/sequence-2.2.1.tgz";
+        sha1 = "7f5617895d44351c0a047e764467690490a16b03";
+      };
+    };
+    "commander-1.3.1" = {
+      name = "commander";
+      packageName = "commander";
+      version = "1.3.1";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/commander/-/commander-1.3.1.tgz";
+        sha1 = "02443e02db96f4b32b674225451abb6e9510000e";
+      };
+    };
     "css-parse-1.7.0" = {
       name = "css-parse";
       packageName = "css-parse";
···
         sha512 = "3a7768nyac729dk372kmbf8f28j0pajy699g45bs8vrlx605wiad3i692a8y58x437bvnfy7015lx08sxhm2vknmsi83a69dwnv2bjw";
       };
     };
-    "csso-3.3.1" = {
+    "csso-3.4.0" = {
       name = "csso";
       packageName = "csso";
-      version = "3.3.1";
+      version = "3.4.0";
       src = fetchurl {
-        url = "https://registry.npmjs.org/csso/-/csso-3.3.1.tgz";
-        sha512 = "087ks3lnvyygbxivwf2fnn53a033ncz1ywm3jyarhz2hvsflka09iw611cwc55ix974bflcf0wmg6zvfkhxsjqmqfrz61w5y1yi6c9s";
+        url = "https://registry.npmjs.org/csso/-/csso-3.4.0.tgz";
+        sha1 = "57b27ef553cccbf5aa964c641748641e9af113f3";
       };
     };
     "object.values-1.0.4" = {
···
       src = fetchurl {
         url = "https://registry.npmjs.org/listify/-/listify-1.0.0.tgz";
         sha1 = "03ca7ba2d150d4267773f74e57558d1053d2bee3";
-      };
-    };
-    "log-update-1.0.2" = {
-      name = "log-update";
-      packageName = "log-update";
-      version = "1.0.2";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/log-update/-/log-update-1.0.2.tgz";
-        sha1 = "19929f64c4093d2d2e7075a1dad8af59c296b8d1";
       };
     };
     "promise-finally-3.0.0" = {
···
         sha1 = "b951f4abb6bd617e66f63eb891498e391763e309";
       };
     };
-    "webpack-sources-1.0.1" = {
+    "webpack-sources-1.0.2" = {
       name = "webpack-sources";
       packageName = "webpack-sources";
-      version = "1.0.1";
+      version = "1.0.2";
       src = fetchurl {
-        url = "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.0.1.tgz";
-        sha512 = "27l6lhqai0bhgk7mbchvf608bgmrgbqmgjd07k1rsg7xh12lnaflr459cy7ay108jr7dk8g5ybx70xi7cbz6lm5c7m022sl5b34r6yk";
+        url = "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.0.2.tgz";
+        sha512 = "1mk1l1f1bv2cnxbyr13i5rbiwm9cgv91d28rk3mmy8z2m6f0xksgkjv5k00xcmvkd3sjsbrica8a1xrlzz0crydrfix3sdgq1s1vdb3";
       };
     };
     "es6-map-0.1.5" = {
···
         sha1 = "eec5c726eacef51b7f6b73c20db6e1b13b069c98";
       };
     };
+    "es6-promisify-5.0.0" = {
+      name = "es6-promisify";
+      packageName = "es6-promisify";
+      version = "5.0.0";
+      src = fetchurl {
+        url = "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz";
+        sha1 = "5109d62f3e56ea967c4b63505aef08291c8a5203";
+      };
+    };
     "event-to-promise-0.8.0" = {
       name = "event-to-promise";
       packageName = "event-to-promise";
···
         sha1 = "79450aff22b2a9c5a41ef54e02db907ccfbf9ee2";
       };
     };
-    "parse5-3.0.2" = {
+    "parse5-3.0.3" = {
       name = "parse5";
       packageName = "parse5";
-      version = "3.0.2";
+      version = "3.0.3";
       src = fetchurl {
-        url = "https://registry.npmjs.org/parse5/-/parse5-3.0.2.tgz";
-        sha1 = "05eff57f0ef4577fb144a79f8b9a967a6cc44510";
-      };
-    };
-    "@types/node-6.0.90" = {
-      name = "_at_types_slash_node";
-      packageName = "@types/node";
-      version = "6.0.90";
-      src = fetchurl {
-        url = "https://registry.npmjs.org/@types/node/-/node-6.0.90.tgz";
-        sha512 = "2q3rymdpikk7mc1rlmv8r1n0rlw856xmw64dx65mi90khgn1plppcsal3jvcbbhc527f06fh2wk9yargn2mlmgxxibhdvv2ax2hcymm";
+        url = "https://registry.npmjs.org/parse5/-/parse5-3.0.3.tgz";
+        sha512 = "005xscj5zlz7pkxa5ngys7i7pdb2f4pirj1zw7hr1145zhxxgg04nhykjh1csy2ncr5lyjw8phq8m2ylqhfhi2z4hgvjb2b1rkbs0xf";
       };
     };
     "anchor-markdown-header-0.5.7" = {
···
       sources."JSONStream-1.3.1"
       sources."async-2.5.0"
       sources."aws4-1.6.0"
-      sources."aws-sdk-2.144.0"
+      sources."aws-sdk-2.145.0"
       sources."ini-1.3.4"
       sources."optimist-0.6.1"
       sources."request-2.83.0"
···
       sources."indent-string-2.1.0"
       sources."lodash.flattendeep-4.4.0"
       sources."lodash.isequal-4.5.0"
-      sources."log-update-2.2.0"
+      sources."log-update-2.3.0"
       sources."prop-types-15.6.0"
       sources."color-convert-1.9.0"
       sources."color-name-1.1.3"
···
     };
     production = true;
   };
-  fast-cli = nodeEnv.buildNodePackage {
+  "fast-cli-1.x" = nodeEnv.buildNodePackage {
     name = "fast-cli";
     packageName = "fast-cli";
-    version = "2.1.0";
+    version = "1.0.0";
     src = fetchurl {
-      url = "https://registry.npmjs.org/fast-cli/-/fast-cli-2.1.0.tgz";
-      sha512 = "10v8s8wk027pmsk69zgmnhhmbjiq33sz8fv92g30m488hm62j9kzpsqjrxvr28zm6s2abszgsflp5m62rjwxi9kjy89r867728fbkb6";
+      url = "https://registry.npmjs.org/fast-cli/-/fast-cli-1.0.0.tgz";
+      sha1 = "81f5f98043cc2517053f96ba5d61ef5db430c010";
     };
     dependencies = [
-      sources."chalk-2.3.0"
-      sources."log-update-2.2.0"
+      sources."chalk-1.1.3"
+      sources."log-update-1.0.2"
       sources."meow-3.7.0"
-      (sources."ora-1.3.0" // {
-        dependencies = [
-          sources."chalk-1.1.3"
-        ];
-      })
-      sources."puppeteer-0.12.0"
-      sources."zen-observable-0.6.0"
+      sources."ora-1.3.0"
+      sources."phantomjs-prebuilt-2.1.16"
+      sources."promise-phantom-3.1.6"
+      sources."zen-observable-0.5.2"
       sources."ansi-styles-2.2.1"
       sources."escape-string-regexp-1.0.5"
+      sources."has-ansi-2.0.0"
+      sources."strip-ansi-3.0.1"
       sources."supports-color-2.0.0"
-      sources."color-convert-1.9.0"
-      sources."color-name-1.1.3"
-      sources."has-flag-2.0.0"
-      sources."ansi-escapes-3.0.0"
+      sources."ansi-regex-2.1.1"
+      sources."ansi-escapes-1.4.0"
       sources."cli-cursor-2.1.0"
-      sources."wrap-ansi-3.0.1"
       sources."restore-cursor-2.0.0"
+      sources."exit-hook-1.1.1"
       sources."onetime-2.0.1"
-      sources."signal-exit-3.0.2"
-      sources."mimic-fn-1.1.0"
-      sources."string-width-2.1.1"
-      sources."strip-ansi-3.0.1"
-      sources."is-fullwidth-code-point-2.0.0"
-      sources."ansi-regex-2.1.1"
       sources."camelcase-keys-2.1.0"
       sources."decamelize-1.2.0"
       sources."loud-rejection-1.6.0"
···
       sources."trim-newlines-1.0.0"
       sources."camelcase-2.1.1"
       sources."currently-unhandled-0.4.1"
+      sources."signal-exit-3.0.2"
       sources."array-find-index-1.0.2"
       sources."hosted-git-info-2.5.0"
       sources."is-builtin-module-1.0.0"
···
       sources."get-stdin-4.0.1"
       sources."cli-spinners-1.1.0"
       sources."log-symbols-1.0.2"
-      sources."has-ansi-2.0.0"
-      sources."debug-2.6.9"
+      sources."mimic-fn-1.1.0"
+      sources."es6-promise-4.1.1"
       sources."extract-zip-1.6.6"
-      sources."https-proxy-agent-2.1.0"
-      sources."mime-1.4.1"
-      sources."progress-2.0.0"
-      sources."proxy-from-env-1.0.0"
-      sources."rimraf-2.6.2"
-      sources."ws-3.2.0"
-      sources."ms-2.0.0"
+      sources."fs-extra-1.0.0"
+      sources."hasha-2.2.0"
+      sources."kew-0.7.0"
+      sources."progress-1.1.8"
+      sources."request-2.83.0"
+      sources."request-progress-2.0.1"
+      sources."which-1.3.0"
       sources."concat-stream-1.6.0"
+      sources."debug-2.6.9"
       sources."mkdirp-0.5.0"
       sources."yauzl-2.4.1"
       sources."inherits-2.0.3"
···
       sources."safe-buffer-5.1.1"
       sources."string_decoder-1.0.3"
       sources."util-deprecate-1.0.2"
+      sources."ms-2.0.0"
       sources."fd-slicer-1.0.1"
       sources."pend-1.2.0"
-      sources."agent-base-4.1.1"
-      sources."es6-promisify-5.0.0"
-      sources."es6-promise-4.1.1"
-      sources."glob-7.1.2"
-      sources."fs.realpath-1.0.0"
-      sources."inflight-1.0.6"
-      sources."minimatch-3.0.4"
-      sources."once-1.4.0"
-      sources."path-is-absolute-1.0.1"
-      sources."wrappy-1.0.2"
-      sources."brace-expansion-1.1.8"
-      sources."balanced-match-1.0.0"
-      sources."concat-map-0.0.1"
-      sources."async-limiter-1.0.0"
-      sources."ultron-1.1.0"
+      sources."jsonfile-2.4.0"
+      sources."klaw-1.3.1"
+      sources."is-stream-1.1.0"
+      sources."aws-sign2-0.7.0"
+      sources."aws4-1.6.0"
+      sources."caseless-0.12.0"
+      sources."combined-stream-1.0.5"
+      sources."extend-3.0.1"
+      sources."forever-agent-0.6.1"
+      sources."form-data-2.3.1"
+      sources."har-validator-5.0.3"
+      sources."hawk-6.0.2"
+      sources."http-signature-1.2.0"
+      sources."is-typedarray-1.0.0"
+      sources."isstream-0.1.2"
+      sources."json-stringify-safe-5.0.1"
+      sources."mime-types-2.1.17"
+      sources."oauth-sign-0.8.2"
+      sources."performance-now-2.1.0"
+      sources."qs-6.5.1"
+      sources."stringstream-0.0.5"
+      sources."tough-cookie-2.3.3"
+      sources."tunnel-agent-0.6.0"
+      sources."uuid-3.1.0"
+      sources."delayed-stream-1.0.0"
+      sources."asynckit-0.4.0"
+      sources."ajv-5.3.0"
+      sources."har-schema-2.0.0"
+      sources."co-4.6.0"
+      sources."fast-deep-equal-1.0.0"
+      sources."fast-json-stable-stringify-2.0.0"
+      sources."json-schema-traverse-0.3.1"
+      sources."hoek-4.2.0"
+      sources."boom-5.2.0"
+      sources."cryptiles-3.1.2"
+      sources."sntp-2.1.0"
+      sources."assert-plus-1.0.0"
+      sources."jsprim-1.4.1"
+      sources."sshpk-1.13.1"
+      sources."extsprintf-1.3.0"
+      sources."json-schema-0.2.3"
+      sources."verror-1.10.0"
+      sources."asn1-0.2.3"
+      sources."dashdash-1.14.1"
+      sources."getpass-0.1.7"
+      sources."jsbn-0.1.1"
+      sources."tweetnacl-0.14.5"
+      sources."ecc-jsbn-0.1.1"
+      sources."bcrypt-pbkdf-1.0.1"
+      sources."mime-db-1.30.0"
+      sources."punycode-1.4.1"
+      sources."throttleit-1.0.0"
+      sources."isexe-2.0.0"
+      sources."mkpath-1.0.0"
+      sources."node-phantom-simple-2.2.4"
+      sources."tmp-0.0.31"
+      sources."os-tmpdir-1.0.2"
     ];
     buildInputs = globalBuildInputs;
     meta = {
···
       sources."tiny-lr-1.0.5"
       sources."uuid-3.1.0"
       sources."wrap-ansi-3.0.1"
-      sources."ws-3.2.0"
+      sources."ws-3.3.0"
       sources."netmask-1.0.6"
       sources."archiver-utils-1.3.0"
       sources."async-2.5.0"
···
       sources."media-typer-0.3.0"
       (sources."mqtt-2.9.0" // {
         dependencies = [
-          sources."ws-3.2.0"
+          sources."ws-3.3.0"
         ];
       })
       sources."multer-1.3.0"
···
   ocaml-language-server = nodeEnv.buildNodePackage {
     name = "ocaml-language-server";
     packageName = "ocaml-language-server";
-    version = "1.0.1";
+    version = "1.0.4";
     src = fetchurl {
-      url = "https://registry.npmjs.org/ocaml-language-server/-/ocaml-language-server-1.0.1.tgz";
-      sha512 = "05wpkgddw5r99fm8082l7sm48yd4xi2892w95fbsqhvy81xas0v2z8k9c7s09m7bvw3hn8rhl7c7cdwf4xafzphwax8zx5w22prpp15";
+      url = "https://registry.npmjs.org/ocaml-language-server/-/ocaml-language-server-1.0.4.tgz";
+      sha512 = "1ppin5vfrqf2x1d1mmw98r4j9iblgv7lhhmfbvmzqp97ynkksyzajx5ssm1l8drn79k8l1iqqx1y4ldpq83hnvlfv3h8zh053iv8p04";
     };
     dependencies = [
       sources."async-2.5.0"
       sources."glob-7.1.2"
       sources."lodash-4.17.4"
-      sources."lokijs-1.5.0"
+      sources."lokijs-1.5.1"
       sources."pegjs-0.10.0"
       sources."vscode-jsonrpc-3.4.1"
       sources."vscode-languageclient-3.4.5"
···
   serve = nodeEnv.buildNodePackage {
     name = "serve";
     packageName = "serve";
-    version = "6.4.0";
+    version = "6.4.1";
     src = fetchurl {
-      url = "https://registry.npmjs.org/serve/-/serve-6.4.0.tgz";
-      sha512 = "0kb65fj5n5z4j11c8247zvabb0qp4w5w9ls29bypm11ay9g2a1riv5wl72ya44b4arwxhyawxxijb5r5zjlwfs9zsbklcp6vbc8mphs";
+      url = "https://registry.npmjs.org/serve/-/serve-6.4.1.tgz";
+      sha512 = "385jwid220bqcnr46ck6vz22ic9kxmxghcpy4m15lvzcl7r3g8f6jyigwmjvdfypf8jaiv1shrfwj2fsgq7wsg6mh7q9hc3pkfk99x0";
     };
     dependencies = [
-      sources."args-3.0.7"
+      (sources."args-3.0.7" // {
+        dependencies = [
+          sources."chalk-2.1.0"
+        ];
+      })
       sources."basic-auth-2.0.0"
       sources."bluebird-3.5.1"
-      sources."boxen-1.2.1"
-      sources."chalk-2.1.0"
+      sources."boxen-1.2.2"
+      sources."chalk-2.3.0"
       sources."clipboardy-1.1.4"
       sources."dargs-5.1.0"
       sources."detect-port-1.2.1"
-      sources."filesize-3.5.10"
+      sources."filesize-3.5.11"
       sources."fs-extra-4.0.2"
-      sources."handlebars-4.0.10"
+      sources."handlebars-4.0.11"
       sources."ip-1.1.5"
       sources."micro-9.0.0"
       sources."micro-compress-1.0.0"
···
       sources."mri-1.1.0"
       sources."pkginfo-0.4.1"
       sources."string-similarity-1.2.0"
+      sources."ansi-styles-3.2.0"
+      sources."escape-string-regexp-1.0.5"
+      sources."supports-color-4.5.0"
+      sources."color-convert-1.9.0"
+      sources."color-name-1.1.3"
+      sources."has-flag-2.0.0"
       sources."lodash-4.17.4"
       sources."safe-buffer-5.1.1"
       sources."ansi-align-2.0.0"
···
       sources."path-key-2.0.1"
       sources."code-point-at-1.1.0"
       sources."number-is-nan-1.0.1"
-      sources."ansi-styles-3.2.0"
-      sources."escape-string-regexp-1.0.5"
-      sources."supports-color-4.5.0"
-      sources."color-convert-1.9.0"
-      sources."color-name-1.1.3"
-      sources."has-flag-2.0.0"
       sources."address-1.0.3"
       sources."debug-2.6.9"
       sources."ms-2.0.0"
···
     };
     production = true;
   };
+  statsd = nodeEnv.buildNodePackage {
+    name = "statsd";
+    packageName = "statsd";
+    version = "0.8.0";
+    src = fetchurl {
+      url = "https://registry.npmjs.org/statsd/-/statsd-0.8.0.tgz";
+      sha1 = "92041479e174a214df7147f2fab1348af0839052";
+    };
+    dependencies = [
+      sources."generic-pool-2.2.0"
+      sources."modern-syslog-1.1.2"
+      sources."hashring-3.2.0"
+      sources."winser-0.1.6"
+      sources."nan-2.7.0"
+      sources."connection-parse-0.0.7"
+      sources."simple-lru-cache-0.0.2"
+      sources."sequence-2.2.1"
+      sources."commander-1.3.1"
+      sources."keypress-0.1.0"
+    ];
+    buildInputs = globalBuildInputs;
+    meta = {
+      description = "Network daemon for the collection and aggregation of realtime application metrics";
+      homepage = https://github.com/etsy/statsd;
+      license = "MIT";
+    };
+    production = true;
+  };
   stylus = nodeEnv.buildNodePackage {
     name = "stylus";
     packageName = "stylus";
···
       sources."css-select-1.3.0-rc0"
       sources."css-select-base-adapter-0.1.0"
       sources."css-tree-1.0.0-alpha25"
-      sources."csso-3.3.1"
+      sources."csso-3.4.0"
       sources."js-yaml-3.10.0"
       sources."object.values-1.0.4"
       sources."sax-1.2.4"
···
   uglify-js = nodeEnv.buildNodePackage {
     name = "uglify-js";
     packageName = "uglify-js";
-    version = "3.1.6";
+    version = "3.1.7";
     src = fetchurl {
-      url = "https://registry.npmjs.org/uglify-js/-/uglify-js-3.1.6.tgz";
-      sha512 = "1hffvxym85dy9nzmjriwyazvy7k6x3iwp0j0dway300hawcdbmfirbglvshxjflzci25z725zl07650m5dgdfydlc0m648a275ixfzy";
+      url = "https://registry.npmjs.org/uglify-js/-/uglify-js-3.1.7.tgz";
+      sha512 = "2797l10f7jfyy5pljy05q04aa7000bzdyj6c57b91fvhvdnh1g4gk71ghn6399qgpja92k5s6fjsw9dnvyiwxr3xnfbd169l81ky6v5";
     };
     dependencies = [
       sources."commander-2.11.0"
···
         ];
       })
       sources."watchpack-1.4.0"
-      sources."webpack-sources-1.0.1"
+      (sources."webpack-sources-1.0.2" // {
+        dependencies = [
+          sources."source-map-0.6.1"
+        ];
+      })
       sources."yargs-8.0.2"
       sources."co-4.6.0"
       sources."fast-deep-equal-1.0.0"
···
       sources."dom-serializer-0.1.0"
       sources."entities-1.1.1"
       sources."htmlparser2-3.9.2"
-      sources."parse5-3.0.2"
+      sources."parse5-3.0.3"
       sources."css-what-2.1.0"
       sources."domutils-1.5.1"
       sources."boolbase-1.0.0"
···
       sources."safe-buffer-5.1.1"
       sources."string_decoder-1.0.3"
       sources."util-deprecate-1.0.2"
-      sources."@types/node-6.0.90"
+      sources."@types/node-8.0.47"
       sources."wcwidth-1.0.1"
       sources."defaults-1.0.3"
       sources."clone-1.0.2"

pkgs/development/ocaml-modules/janestreet/default.nix

···
 { stdenv, lib, janePackage, ocaml, ocamlbuild, cryptokit, ctypes, magic-mime,
-  ocaml-migrate-parsetree, octavius, ounit, ppx_deriving, re, zarith,
+  ocaml-migrate-parsetree, octavius, ounit, ppx_deriving, re, zarith, num,
   openssl }:
 
 rec {
 
   # Jane Street packages, up to ppx_core
 
-  sexplib = janePackage {
+  sexplib = janePackage ({
     name = "sexplib";
-    version = "0.9.2";
-    hash = "0szj7gi5ksy7kif5g71rkr6xhxc41xl8hq6s5zz610cjyngzyzjl";
     meta.description = "Automated S-expression conversion";
-  };
+  } // (if lib.versionAtLeast ocaml.version "4.05"
+    then {
+      version = "0.9.3";
+      hash = "0a2sqh235ja3qwy7b2k3qym2616dz7369a195qwi6ljy3cnh7s53";
+      buildInputs = [ num ];
+    } else {
+      version = "0.9.2";
+      hash = "0szj7gi5ksy7kif5g71rkr6xhxc41xl8hq6s5zz610cjyngzyzjl";
+    }
+  ));
 
   base = janePackage {
     name = "base";
-    version = "0.9.3";
-    hash = "14v3zsr7za9h1gkxdmkk1yagnrfjk3y9snraywv9hsqbhv39ajvv";
+    version = "0.9.4";
+    hash = "0x85xi66b4zwlbdwmyc99zcmawgpp75gxqbl55rr67awavw162rw";
     propagatedBuildInputs = [ sexplib ];
     meta.description = "Full standard library replacement for OCaml";
   };
···
 
   stdio = janePackage {
     name = "stdio";
-    hash = "1c08jg930j7yxn0sjvlm3fs2fvwaf15sn9513yf1rb7y1lxrgwc4";
+    version = "0.9.1";
+    hash = "13rj3ii0rvmklfim9ild0ib44ssdadig7a9ccjbz22m0pw84a1sx";
     propagatedBuildInputs = [ base ];
     meta.description = "Standard IO library for OCaml";
   };

pkgs/development/ocaml-modules/ocaml-migrate-parsetree/default.nix

···
 
 stdenv.mkDerivation rec {
    name = "ocaml${ocaml.version}-ocaml-migrate-parsetree-${version}";
-   version = "1.0.5";
+   version = "1.0.7";
 
    src = fetchFromGitHub {
      owner = "let-def";
      repo = "ocaml-migrate-parsetree";
      rev = "v${version}";
-     sha256 = "1wj66nb16zijacpfrcm7yi0hlg315v71nxri3ia7r0sa3mlzxl34";
+     sha256 = "0v1h943xv5bd8qy5mr8pvyjbgamhs59nkgr94j3vznabrcfqzkh7";
    };
 
    buildInputs = [ ocaml findlib ocamlbuild jbuilder ];

pkgs/development/python-modules/Cython/default.nix

···
 buildPythonPackage rec {
   pname = "Cython";
   name = "${pname}-${version}";
-  version = "0.27.2";
+  version = "0.27.3";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "265dacf64ed8c0819f4be9355c39beaa13dc2ad2f85237a2c4e478f5ce644b48";
+    sha256 = "6a00512de1f2e3ce66ba35c5420babaef1fe2d9c43a8faab4080b0dbcc26bc64";
   };
 
   # With Python 2.x on i686-linux or 32-bit ARM this test fails because the

pkgs/development/python-modules/affinity/default.nix

···
+{ lib, buildPythonPackage, fetchPypi }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "affinity";
+  version = "0.1.0";
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1i6j7kszvnzh5vh9k48cqwx2kzf73a6abgv9s6bf0j2zmfjl2wb6";
+  };
+  meta = {
+    description = "control processor affinity on windows and linux";
+    homepage    = http://cheeseshop.python.org/pypi/affinity;
+    license     = with lib.licenses; [ psfl ];
+  };
+}

pkgs/development/python-modules/aiohttp/default.nix

···
 
 buildPythonPackage rec {
   pname = "aiohttp";
-  version = "2.3.1";
+  version = "2.3.2";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "04f58bbcc9ae6f9aec30b9219ae47fa3c31586c77679405720545738ea62236e";
+    sha256 = "42373fbdbe8f09233c17e74f53cee877bc7d5b495b4fc14c32a119255e85e736";
   };
 
   disabled = pythonOlder "3.4";

pkgs/development/python-modules/asgi_ipc/default.nix

···
   asgiref, msgpack, posix_ipc
 }:
 buildPythonPackage rec {
-  version = "1.4.1";
+  version = "1.4.2";
   pname = "asgi_ipc";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/a/asgi_ipc/${name}.tar.gz";
-    sha256 = "87cc9dda476d28f335261b73f0f3070f28847718de2e64da9a80492638203e43";
+    sha256 = "2403f41184405791b05e7aee570bd6ccd47e2d91845d78fe17adcf58ef48c037";
   };
 
   propagatedBuildInputs = [ asgiref msgpack posix_ipc ];

pkgs/development/python-modules/django/1_11.nix

···
 buildPythonPackage rec {
   pname = "Django";
   name = "${pname}-${version}";
-  version = "1.11.6";
+  version = "1.11.7";
 
   disabled = pythonOlder "2.7";
 
   src = fetchurl {
     url = "http://www.djangoproject.com/m/releases/1.11/${name}.tar.gz";
-    sha256 = "0q0cmwifa6c0k6kh8fpa3mjmqw7yqd616qz8m4ls3h51xyhjrd63";
+    sha256 = "16ab3p6jj1da94wkz2b5fb128ycy4826bbsnbabcd3qdaf9f6649";
   };
 
   patches = stdenv.lib.optionals withGdal [

pkgs/development/python-modules/dulwich.nix pkgs/development/python-modules/dulwich/default.nix

···
 , git, glibcLocales }:
 
 buildPythonPackage rec {
-  version = "0.18.4";
+  version = "0.18.5";
   pname = "dulwich";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/d/dulwich/${name}.tar.gz";
-    sha256 = "b4baace48dde5e0a76f37b251c246c7e1829bda0617679f00cbade0e70a5ac5b";
+    sha256 = "838bac318fd0ed79e0eedb6cfd53b6424dc618fec6b99dc959881b12da7bd6e0";
   };
 
   LC_ALL = "en_US.UTF-8";

pkgs/development/python-modules/faulthandler/default.nix

···
+{ stdenv, fetchPypi, buildPythonPackage }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "faulthandler";
+  version = "2.6";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0zywq3jaznddvqc3hnfrlv24wmpyq4xgajk9xhv6578qw1rpfj2r";
+  };
+
+  meta = {
+    description = "Dump the Python traceback";
+    license = stdenv.lib.licenses.bsd2;
+    maintainers = with stdenv.lib.maintainers; [ sauyon ];
+    homepage = http://faulthandler.readthedocs.io/;
+  };
+}

pkgs/development/python-modules/fiona/default.nix

···
 
 buildPythonPackage rec {
   pname = "Fiona";
-  version = "1.7.9.post1";
+  version = "1.7.10.post1";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "68e8a925b23e3987845c11b0fdd6378fdec4316fe8ba767a935151b6ee1fc607";
+    sha256 = "fc4c8996be3131f36c791d66273317d38b72b19dc24c2afc332fd734752eb7a8";
   };
 
   buildInputs = [

pkgs/development/python-modules/gflags/default.nix

···
 { lib, buildPythonPackage, fetchPypi, six, pytest }:
 
 buildPythonPackage rec {
-  version = "3.1.1";
+  version = "3.1.2";
   name = "gflags-${version}";
 
   src = fetchPypi {
     inherit version;
     pname = "python-gflags";
-    sha256 = "0qvcizlz6r4511kl4jlg6fr34y1ka956dr2jj1q0qcklr94n9zxa";
+    sha256 = "40ae131e899ef68e9e14aa53ca063839c34f6a168afe622217b5b875492a1ee2";
   };
 
   buildInputs = [ pytest ];

pkgs/development/python-modules/gst-python/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gst-python";
-  version = "1.10.4";
+  version = "1.12.2";
   name = "${pname}-${version}";
 
   src = fetchurl {
···
       "${meta.homepage}/src/gst-python/${name}.tar.xz"
       "mirror://gentoo/distfiles/${name}.tar.xz"
       ];
-    sha256 = "04l2hvvz9b0f3nyds1k3yfk5di8a91fpr6maj19c11mwp1s82l2r";
+    sha256 = "0iwy0v2k27wd3957ich6j5f0f04b0wb2mb175ypf2lx68snk5k7l";
   };
 
   patches = [ ./different-path-with-pygobject.patch ];
···
   passthru.pythonPath = [];
 
   meta = {
-    homepage = http://gstreamer.freedesktop.org;
+    homepage = https://gstreamer.freedesktop.org;
 
     description = "Python bindings for GStreamer";
 

pkgs/development/python-modules/jug/default.nix

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "Jug";
-  version = "1.6.3";
+  version = "1.6.4";
   buildInputs = [ nose numpy ];
   propagatedBuildInputs = [
     bottle
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0dpcwjaf8zzqpdz8w8h0p7vmd6z6bzfz2805a6bdjqs9hhkhrg86";
+    sha256 = "e739b20e7fe53ac50f5954b9e32568bdd92012dd4bd199d13e2a675ccd69d97d";
   };
 
   meta = with stdenv.lib; {

pkgs/development/python-modules/keras/default.nix

···
 
 buildPythonPackage rec {
   pname = "Keras";
-  version = "2.0.8";
+  version = "2.0.9";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "899dc6aaed366f20100b9f80cf1093ea5b43eecc74afd1dc63a4e48dfa776ab9";
+    sha256 = "6b8572cf1b4a22fd0120b7c23382ba4fa04a6f0397e02af1249be9a7309d1767";
   };
 
   checkInputs = [

pkgs/development/python-modules/meliae/default.nix

···
   name = "${pname}-${version}";
 
   src = fetchPypi {
-    inherit pname version;
+    inherit pname;
+    # FIXME when updating to the next version: The tarball on pypi is called
+    # "meliae-0.4.0.tar.gz" while the version within that tarball is
+    # "0.4.0.final.0".
+    version = "0.4.0";
     sha256 = "976519ab02aaa6a8fb5f596dc4dd9f64fc9510b00e054979566e51c9be7cec99";
   };
 

pkgs/development/python-modules/multidict/default.nix

···
 
 let
   pname = "multidict";
-  version = "3.3.0";
+  version = "3.3.2";
 in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/${builtins.substring 0 1 pname}/${pname}/${name}.tar.gz";
-    sha256 = "e76909da2fad6966281d4e0e4ccfd3c3025699ebcc30806afa09fa1384c3532b";
+    sha256 = "f82e61c7408ed0dce1862100db55595481911f159d6ddec0b375d35b6449509b";
   };
 
   buildInputs = [ cython ];

pkgs/development/python-modules/netcdf4/default.nix

···
 buildPythonPackage rec {
   pname = "netCDF4";
   name = "${pname}-${version}";
-  version = "1.3.0";
+  version = "1.3.1";
 
   disabled = isPyPy;
 
   src = fetchurl {
     url = "mirror://pypi/n/netCDF4/${name}.tar.gz";
-    sha256 = "1982372aeacc6b36054d90d8cb54ee9506b66b6f44d5cff10e2ffb162aad5476";
+    sha256 = "570ea59992aa6d98a9b672c71161d11ba5683f787da53446086077470a869957";
   };
 
   buildInputs = [

pkgs/development/python-modules/notebook/default.nix

···
 
 buildPythonPackage rec {
   pname = "notebook";
-  version = "5.2.0";
+  version = "5.2.1";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1sh3jkkmjzv17c3r8ii3kfhpxi6dkjk846b2lfy71g9qwqdcvbvz";
+    sha256 = "4ae5b81dd39b37cdd99dcffe83a5182c849947b92d46ac4d2b5093af2bb9f224";
   };
 
   LC_ALL = "en_US.utf8";

pkgs/development/python-modules/pelican-fix-tests-with-pygments-2.1.patch

···
-diff --git a/pelican/tests/output/basic/feeds/all-en.atom.xml b/pelican/tests/output/basic/feeds/all-en.atom.xml
-index 3ce41d7..3cf97a8 100644
---- a/pelican/tests/output/basic/feeds/all-en.atom.xml
-+++ b/pelican/tests/output/basic/feeds/all-en.atom.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.</p>
- </div>
- <div class="section" id="testing-more-sourcecode-directives">
- <h2>Testing more sourcecode directives</h2>
--<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8</span> <span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">  </span>     <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10</span>     <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">  </span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12</span>     <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">  </span>         <span class="testingc"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14</span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">  </span> <br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16</span>     <span class="testingk">if</span> <span class="testingp">(</span><span class="testings">'linenos'</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">  </span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">'linenos'</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">'table'</span><span class="testingp">,</span> <span class="testings">'inline'</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18</span>         <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">'linenos'</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings">'table'</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">  </span> <br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20</span>     <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">'nowrap'</span><span class="testingp">,</span> <span class="testings">'nobackground'</span><span class="testingp">,</span> <span class="testings">'anchorlinenos'</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">  </span>         <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22</span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">  </span> <br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24</span>     <span class="testingc"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">  </span>     <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26</span>     <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings">'</span><span class="testingse">\n</span><span class="testings">'</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">  </span>     <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings">''</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings">'html'</span><span class="testingp">)]</span><br></span></pre></div>
-+<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8 </span><span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">   </span>    <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10 </span>    <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">   </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12 </span>    <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">   </span>        <span class="testingc1"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14 </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">   </span><br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16 </span>    <span class="testingk">if</span> <span class="testingp">(</span><span class="testings1">'linenos'</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">   </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">'linenos'</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">'table'</span><span class="testingp">,</span> <span class="testings1">'inline'</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18 </span>        <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">'linenos'</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings1">'table'</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">   </span><br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20 </span>    <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">'nowrap'</span><span class="testingp">,</span> <span class="testings1">'nobackground'</span><span class="testingp">,</span> <span class="testings1">'anchorlinenos'</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">   </span>        <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22 </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">   </span><br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24 </span>    <span class="testingc1"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">   </span>    <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26 </span>    <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings1">'</span><span class="testingse">\n</span><span class="testings1">'</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">   </span>    <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings1">''</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings1">'html'</span><span class="testingp">)]</span><br></span></pre></div>
- <p>Lovely.</p>
- </div>
- <div class="section" id="testing-even-more-sourcecode-directives">
-@@ -58,4 +58,4 @@ pelican.conf, it will have nothing in default.</p>
- <p>Lovely.</p>
- </div>
- </summary></entry><entry><title>The baz tag</title><link href="/tag/baz.html" rel="alternate"></link><updated>2010-03-14T00:00:00+00:00</updated><author><name></name></author><id>tag:,2010-03-14:tag/baz.html</id><summary type="html">&lt;p&gt;This article overrides the listening of the articles under the &lt;em&gt;baz&lt;/em&gt; tag.&lt;/p&gt;
--</summary></entry></feed>
-+</summary></entry></feed>
-\ No newline at end of file
-diff --git a/pelican/tests/output/basic/feeds/all.atom.xml b/pelican/tests/output/basic/feeds/all.atom.xml
-index 3a9478a..24d31a9 100644
---- a/pelican/tests/output/basic/feeds/all.atom.xml
-+++ b/pelican/tests/output/basic/feeds/all.atom.xml
-@@ -43,7 +43,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-@@ -59,4 +59,4 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- </summary></entry><entry><title>The baz tag</title><link href="/tag/baz.html" rel="alternate"></link><updated>2010-03-14T00:00:00+00:00</updated><author><name></name></author><id>tag:,2010-03-14:tag/baz.html</id><summary type="html">&lt;p&gt;This article overrides the listening of the articles under the &lt;em&gt;baz&lt;/em&gt; tag.&lt;/p&gt;
--</summary></entry></feed>
-+</summary></entry></feed>
-\ No newline at end of file
-diff --git a/pelican/tests/output/basic/feeds/misc.atom.xml b/pelican/tests/output/basic/feeds/misc.atom.xml
-index a9b5977..4ad7008 100644
---- a/pelican/tests/output/basic/feeds/misc.atom.xml
-+++ b/pelican/tests/output/basic/feeds/misc.atom.xml
-@@ -19,7 +19,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-@@ -35,4 +35,4 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- </summary></entry><entry><title>The baz tag</title><link href="/tag/baz.html" rel="alternate"></link><updated>2010-03-14T00:00:00+00:00</updated><author><name></name></author><id>tag:,2010-03-14:tag/baz.html</id><summary type="html">&lt;p&gt;This article overrides the listening of the articles under the &lt;em&gt;baz&lt;/em&gt; tag.&lt;/p&gt;
--</summary></entry></feed>
-+</summary></entry></feed>
-\ No newline at end of file
-diff --git a/pelican/tests/output/basic/unbelievable.html b/pelican/tests/output/basic/unbelievable.html
-index dfb0c54..b7f8a7e 100644
---- a/pelican/tests/output/basic/unbelievable.html
-+++ b/pelican/tests/output/basic/unbelievable.html
-@@ -38,7 +38,7 @@
-                 Published: Fri 15 October 2010
-         </abbr>
- 
--<p>In <a href="/category/misc.html">misc</a>. </p>
-+<p>In <a href="/category/misc.html">misc</a>.</p>
- 
- </footer><!-- /.post-info -->      <p>Or completely awesome. Depends the needs.</p>
- <p><a class="reference external" href="/a-markdown-powered-article.html">a root-relative link to markdown-article</a>
-@@ -58,7 +58,7 @@ pelican.conf, it will have nothing in default.</p>
- </div>
- <div class="section" id="testing-more-sourcecode-directives">
- <h2>Testing more sourcecode directives</h2>
--<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8</span> <span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">  </span>     <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10</span>     <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">  </span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12</span>     <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">  </span>         <span class="testingc"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14</span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">  </span> <br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16</span>     <span class="testingk">if</span> <span class="testingp">(</span><span class="testings">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">  </span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18</span>         <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">  </span> <br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20</span>     <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">  </span>         <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22</span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">  </span> <br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24</span>     <span class="testingc"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">  </span>     <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26</span>     <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings">&#39;</span><span class="testingse">\n</span><span class="testings">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">  </span>     <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
-+<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8 </span><span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">   </span>    <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10 </span>    <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">   </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12 </span>    <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">   </span>        <span class="testingc1"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14 </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">   </span><br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16 </span>    <span class="testingk">if</span> <span class="testingp">(</span><span class="testings1">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">   </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18 </span>        <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings1">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">   </span><br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20 </span>    <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">   </span>        <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22 </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">   </span><br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24 </span>    <span class="testingc1"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">   </span>    <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26 </span>    <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings1">&#39;</span><span class="testingse">\n</span><span class="testings1">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">   </span>    <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings1">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings1">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
- <p>Lovely.</p>
- </div>
- <div class="section" id="testing-even-more-sourcecode-directives">
-@@ -97,4 +97,4 @@ pelican.conf, it will have nothing in default.</p>
-         </footer><!-- /#contentinfo -->
- 
- </body>
--</html>
-+</html>
-\ No newline at end of file
-diff --git a/pelican/tests/output/custom/feeds/alexis-metaireau.atom.xml b/pelican/tests/output/custom/feeds/alexis-metaireau.atom.xml
-index cb74637..987f987 100644
---- a/pelican/tests/output/custom/feeds/alexis-metaireau.atom.xml
-+++ b/pelican/tests/output/custom/feeds/alexis-metaireau.atom.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/alexis-metaireau.rss.xml b/pelican/tests/output/custom/feeds/alexis-metaireau.rss.xml
-index 2c4b116..89082ee 100644
---- a/pelican/tests/output/custom/feeds/alexis-metaireau.rss.xml
-+++ b/pelican/tests/output/custom/feeds/alexis-metaireau.rss.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/all-en.atom.xml b/pelican/tests/output/custom/feeds/all-en.atom.xml
-index 3574ab4..75b6333 100644
---- a/pelican/tests/output/custom/feeds/all-en.atom.xml
-+++ b/pelican/tests/output/custom/feeds/all-en.atom.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/all.atom.xml b/pelican/tests/output/custom/feeds/all.atom.xml
-index 391ab85..efb43cd 100644
---- a/pelican/tests/output/custom/feeds/all.atom.xml
-+++ b/pelican/tests/output/custom/feeds/all.atom.xml
-@@ -44,7 +44,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/all.rss.xml b/pelican/tests/output/custom/feeds/all.rss.xml
-index a78d2de..548b16c 100644
---- a/pelican/tests/output/custom/feeds/all.rss.xml
-+++ b/pelican/tests/output/custom/feeds/all.rss.xml
-@@ -44,7 +44,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/misc.atom.xml b/pelican/tests/output/custom/feeds/misc.atom.xml
-index 91d6b28..dbab63c 100644
---- a/pelican/tests/output/custom/feeds/misc.atom.xml
-+++ b/pelican/tests/output/custom/feeds/misc.atom.xml
-@@ -19,7 +19,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/feeds/misc.rss.xml b/pelican/tests/output/custom/feeds/misc.rss.xml
-index 3493d2a..2d13bda 100644
---- a/pelican/tests/output/custom/feeds/misc.rss.xml
-+++ b/pelican/tests/output/custom/feeds/misc.rss.xml
-@@ -19,7 +19,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom/unbelievable.html b/pelican/tests/output/custom/unbelievable.html
-index 2e51cf0..b6d2136 100644
---- a/pelican/tests/output/custom/unbelievable.html
-+++ b/pelican/tests/output/custom/unbelievable.html
-@@ -43,9 +43,9 @@
-         </abbr>
- 
-         <address class="vcard author">
--                By <a class="url fn" href="./author/alexis-metaireau.html">Alexis Métaireau</a>
-+                By                         <a class="url fn" href="./author/alexis-metaireau.html">Alexis Métaireau</a>
-         </address>
--<p>In <a href="./category/misc.html">misc</a>. </p>
-+<p>In <a href="./category/misc.html">misc</a>.</p>
- 
- </footer><!-- /.post-info -->      <p>Or completely awesome. Depends the needs.</p>
- <p><a class="reference external" href="./a-markdown-powered-article.html">a root-relative link to markdown-article</a>
-@@ -65,7 +65,7 @@ pelican.conf, it will have nothing in default.</p>
- </div>
- <div class="section" id="testing-more-sourcecode-directives">
- <h2>Testing more sourcecode directives</h2>
--<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8</span> <span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">  </span>     <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10</span>     <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">  </span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12</span>     <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">  </span>         <span class="testingc"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14</span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">  </span> <br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16</span>     <span class="testingk">if</span> <span class="testingp">(</span><span class="testings">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">  </span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18</span>         <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">  </span> <br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20</span>     <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">  </span>         <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22</span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">  </span> <br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24</span>     <span class="testingc"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">  </span>     <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26</span>     <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings">&#39;</span><span class="testingse">\n</span><span class="testings">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">  </span>     <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
-+<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8 </span><span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">   </span>    <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10 </span>    <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">   </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12 </span>    <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">   </span>        <span class="testingc1"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14 </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">   </span><br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16 </span>    <span class="testingk">if</span> <span class="testingp">(</span><span class="testings1">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">   </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18 </span>        <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings1">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">   </span><br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20 </span>    <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">   </span>        <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22 </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">   </span><br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24 </span>    <span class="testingc1"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">   </span>    <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26 </span>    <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings1">&#39;</span><span class="testingse">\n</span><span class="testings1">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">   </span>    <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings1">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings1">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
- <p>Lovely.</p>
- </div>
- <div class="section" id="testing-even-more-sourcecode-directives">
-diff --git a/pelican/tests/output/custom_locale/feeds/alexis-metaireau.atom.xml b/pelican/tests/output/custom_locale/feeds/alexis-metaireau.atom.xml
-index 8fb3ef6..2090087 100644
---- a/pelican/tests/output/custom_locale/feeds/alexis-metaireau.atom.xml
-+++ b/pelican/tests/output/custom_locale/feeds/alexis-metaireau.atom.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/alexis-metaireau.rss.xml b/pelican/tests/output/custom_locale/feeds/alexis-metaireau.rss.xml
-index 99255ee..00944ce 100644
---- a/pelican/tests/output/custom_locale/feeds/alexis-metaireau.rss.xml
-+++ b/pelican/tests/output/custom_locale/feeds/alexis-metaireau.rss.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/all-en.atom.xml b/pelican/tests/output/custom_locale/feeds/all-en.atom.xml
-index 6b2f09b..297558d 100644
---- a/pelican/tests/output/custom_locale/feeds/all-en.atom.xml
-+++ b/pelican/tests/output/custom_locale/feeds/all-en.atom.xml
-@@ -42,7 +42,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/all.atom.xml b/pelican/tests/output/custom_locale/feeds/all.atom.xml
-index 5ef59e0..78da527 100644
---- a/pelican/tests/output/custom_locale/feeds/all.atom.xml
-+++ b/pelican/tests/output/custom_locale/feeds/all.atom.xml
-@@ -44,7 +44,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/all.rss.xml b/pelican/tests/output/custom_locale/feeds/all.rss.xml
-index 071e2f1..84fd5df 100644
---- a/pelican/tests/output/custom_locale/feeds/all.rss.xml
-+++ b/pelican/tests/output/custom_locale/feeds/all.rss.xml
-@@ -44,7 +44,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/misc.atom.xml b/pelican/tests/output/custom_locale/feeds/misc.atom.xml
-index c91d4d7..fde02e6 100644
---- a/pelican/tests/output/custom_locale/feeds/misc.atom.xml
-+++ b/pelican/tests/output/custom_locale/feeds/misc.atom.xml
-@@ -19,7 +19,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/feeds/misc.rss.xml b/pelican/tests/output/custom_locale/feeds/misc.rss.xml
-index 82b5898..bd727bb 100644
---- a/pelican/tests/output/custom_locale/feeds/misc.rss.xml
-+++ b/pelican/tests/output/custom_locale/feeds/misc.rss.xml
-@@ -19,7 +19,7 @@ pelican.conf, it will have nothing in default.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-more-sourcecode-directives"&gt;
- &lt;h2&gt;Testing more sourcecode directives&lt;/h2&gt;
--&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8&lt;/span&gt; &lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10&lt;/span&gt;     &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12&lt;/span&gt;     &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingc"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14&lt;/span&gt;         &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16&lt;/span&gt;     &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18&lt;/span&gt;         &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20&lt;/span&gt;     &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;         &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22&lt;/span&gt;             &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt; &lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24&lt;/span&gt;     &lt;span class="testingc"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26&lt;/span&gt;     &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;  &lt;/span&gt;     &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
-+&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span id="foo-8"&gt;&lt;a name="foo-8"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt; 8 &lt;/span&gt;&lt;span class="testingk"&gt;def&lt;/span&gt; &lt;span class="testingnf"&gt;run&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-9"&gt;&lt;a name="foo-9"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;assert_has_content&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-10"&gt;&lt;a name="foo-10"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;10 &lt;/span&gt;    &lt;span class="testingk"&gt;try&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-11"&gt;&lt;a name="foo-11"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;get_lexer_by_name&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;arguments&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingmi"&gt;0&lt;/span&gt;&lt;span class="testingp"&gt;])&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-12"&gt;&lt;a name="foo-12"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;12 &lt;/span&gt;    &lt;span class="testingk"&gt;except&lt;/span&gt; &lt;span class="testingne"&gt;ValueError&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-13"&gt;&lt;a name="foo-13"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingc1"&gt;# no lexer found - use the text one instead of an exception&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-14"&gt;&lt;a name="foo-14"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;14 &lt;/span&gt;        &lt;span class="testingn"&gt;lexer&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;TextLexer&lt;/span&gt;&lt;span class="testingp"&gt;()&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-15"&gt;&lt;a name="foo-15"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-16"&gt;&lt;a name="foo-16"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;16 &lt;/span&gt;    &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt; &lt;span class="testingow"&gt;and&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-17"&gt;&lt;a name="foo-17"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingow"&gt;not&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;inline&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-18"&gt;&lt;a name="foo-18"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;18 &lt;/span&gt;        &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;linenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;table&amp;#39;&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-19"&gt;&lt;a name="foo-19"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-20"&gt;&lt;a name="foo-20"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;20 &lt;/span&gt;    &lt;span class="testingk"&gt;for&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;nowrap&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;nobackground&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testings1"&gt;&amp;#39;anchorlinenos&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;):&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-21"&gt;&lt;a name="foo-21"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;        &lt;span class="testingk"&gt;if&lt;/span&gt; &lt;span class="testingn"&gt;flag&lt;/span&gt; &lt;span class="testingow"&gt;in&lt;/span&gt; &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;:&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-22"&gt;&lt;a name="foo-22"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;22 &lt;/span&gt;            &lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;flag&lt;/span&gt;&lt;span class="testingp"&gt;]&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingbp"&gt;True&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-23"&gt;&lt;a name="foo-23"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-24"&gt;&lt;a name="foo-24"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;24 &lt;/span&gt;    &lt;span class="testingc1"&gt;# noclasses should already default to False, but just in case...&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-25"&gt;&lt;a name="foo-25"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingn"&gt;formatter&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;HtmlFormatter&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingn"&gt;noclasses&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testingbp"&gt;False&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingo"&gt;**&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;options&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-26"&gt;&lt;a name="foo-26"&gt;&lt;/a&gt;&lt;span class="lineno special"&gt;26 &lt;/span&gt;    &lt;span class="testingn"&gt;parsed&lt;/span&gt; &lt;span class="testingo"&gt;=&lt;/span&gt; &lt;span class="testingn"&gt;highlight&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingse"&gt;\n&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;join&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testingbp"&gt;self&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;content&lt;/span&gt;&lt;span class="testingp"&gt;),&lt;/span&gt; &lt;span class="testingn"&gt;lexer&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;formatter&lt;/span&gt;&lt;span class="testingp"&gt;)&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;span id="foo-27"&gt;&lt;a name="foo-27"&gt;&lt;/a&gt;&lt;span class="lineno"&gt;   &lt;/span&gt;    &lt;span class="testingk"&gt;return&lt;/span&gt; &lt;span class="testingp"&gt;[&lt;/span&gt;&lt;span class="testingn"&gt;nodes&lt;/span&gt;&lt;span class="testingo"&gt;.&lt;/span&gt;&lt;span class="testingn"&gt;raw&lt;/span&gt;&lt;span class="testingp"&gt;(&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;parsed&lt;/span&gt;&lt;span class="testingp"&gt;,&lt;/span&gt; &lt;span class="testingn"&gt;format&lt;/span&gt;&lt;span class="testingo"&gt;=&lt;/span&gt;&lt;span class="testings1"&gt;&amp;#39;html&amp;#39;&lt;/span&gt;&lt;span class="testingp"&gt;)]&lt;/span&gt;&lt;br&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/div&gt;
- &lt;p&gt;Lovely.&lt;/p&gt;
- &lt;/div&gt;
- &lt;div class="section" id="testing-even-more-sourcecode-directives"&gt;
-diff --git a/pelican/tests/output/custom_locale/posts/2010/octobre/15/unbelievable/index.html b/pelican/tests/output/custom_locale/posts/2010/octobre/15/unbelievable/index.html
-index a6ea869..1e2d78f 100644
---- a/pelican/tests/output/custom_locale/posts/2010/octobre/15/unbelievable/index.html
-+++ b/pelican/tests/output/custom_locale/posts/2010/octobre/15/unbelievable/index.html
-@@ -45,7 +45,7 @@
-         <address class="vcard author">
-                 By                         <a class="url fn" href="../../../../../author/alexis-metaireau.html">Alexis Métaireau</a>
-         </address>
--<p>In <a href="../../../../../category/misc.html">misc</a>. </p>
-+<p>In <a href="../../../../../category/misc.html">misc</a>.</p>
- 
- </footer><!-- /.post-info -->      <p>Or completely awesome. Depends the needs.</p>
- <p><a class="reference external" href="../../../../../posts/2011/avril/20/a-markdown-powered-article/">a root-relative link to markdown-article</a>
-@@ -65,7 +65,7 @@ pelican.conf, it will have nothing in default.</p>
- </div>
- <div class="section" id="testing-more-sourcecode-directives">
- <h2>Testing more sourcecode directives</h2>
--<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8</span> <span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">  </span>     <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10</span>     <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">  </span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12</span>     <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">  </span>         <span class="testingc"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14</span>         <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">  </span> <br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16</span>     <span class="testingk">if</span> <span class="testingp">(</span><span class="testings">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">  </span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18</span>         <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">  </span> <br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20</span>     <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">  </span>         <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22</span>             <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">  </span> <br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24</span>     <span class="testingc"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">  </span>     <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26</span>     <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings">&#39;</span><span class="testingse">\n</span><span class="testings">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">  </span>     <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
-+<div class="highlight"><pre><span id="foo-8"><a name="foo-8"></a><span class="lineno special"> 8 </span><span class="testingk">def</span> <span class="testingnf">run</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingp">):</span><br></span><span id="foo-9"><a name="foo-9"></a><span class="lineno">   </span>    <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">assert_has_content</span><span class="testingp">()</span><br></span><span id="foo-10"><a name="foo-10"></a><span class="lineno special">10 </span>    <span class="testingk">try</span><span class="testingp">:</span><br></span><span id="foo-11"><a name="foo-11"></a><span class="lineno">   </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">get_lexer_by_name</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">arguments</span><span class="testingp">[</span><span class="testingmi">0</span><span class="testingp">])</span><br></span><span id="foo-12"><a name="foo-12"></a><span class="lineno special">12 </span>    <span class="testingk">except</span> <span class="testingne">ValueError</span><span class="testingp">:</span><br></span><span id="foo-13"><a name="foo-13"></a><span class="lineno">   </span>        <span class="testingc1"># no lexer found - use the text one instead of an exception</span><br></span><span id="foo-14"><a name="foo-14"></a><span class="lineno special">14 </span>        <span class="testingn">lexer</span> <span class="testingo">=</span> <span class="testingn">TextLexer</span><span class="testingp">()</span><br></span><span id="foo-15"><a name="foo-15"></a><span class="lineno">   </span><br></span><span id="foo-16"><a name="foo-16"></a><span class="lineno special">16 </span>    <span class="testingk">if</span> <span class="testingp">(</span><span class="testings1">&#39;linenos&#39;</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span> <span class="testingow">and</span><br></span><span id="foo-17"><a name="foo-17"></a><span class="lineno">   </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingow">not</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;table&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;inline&#39;</span><span class="testingp">)):</span><br></span><span id="foo-18"><a name="foo-18"></a><span class="lineno special">18 </span>        <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testings1">&#39;linenos&#39;</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testings1">&#39;table&#39;</span><br></span><span id="foo-19"><a name="foo-19"></a><span class="lineno">   </span><br></span><span id="foo-20"><a name="foo-20"></a><span class="lineno special">20 </span>    <span class="testingk">for</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingp">(</span><span class="testings1">&#39;nowrap&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;nobackground&#39;</span><span class="testingp">,</span> <span class="testings1">&#39;anchorlinenos&#39;</span><span class="testingp">):</span><br></span><span id="foo-21"><a name="foo-21"></a><span class="lineno">   </span>        <span class="testingk">if</span> <span class="testingn">flag</span> <span class="testingow">in</span> <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">:</span><br></span><span id="foo-22"><a name="foo-22"></a><span class="lineno special">22 </span>            <span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">[</span><span class="testingn">flag</span><span class="testingp">]</span> <span class="testingo">=</span> <span class="testingbp">True</span><br></span><span id="foo-23"><a name="foo-23"></a><span class="lineno">   </span><br></span><span id="foo-24"><a name="foo-24"></a><span class="lineno special">24 </span>    <span class="testingc1"># noclasses should already default to False, but just in case...</span><br></span><span id="foo-25"><a name="foo-25"></a><span class="lineno">   </span>    <span class="testingn">formatter</span> <span class="testingo">=</span> <span class="testingn">HtmlFormatter</span><span class="testingp">(</span><span class="testingn">noclasses</span><span class="testingo">=</span><span class="testingbp">False</span><span class="testingp">,</span> <span class="testingo">**</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">options</span><span class="testingp">)</span><br></span><span id="foo-26"><a name="foo-26"></a><span class="lineno special">26 </span>    <span class="testingn">parsed</span> <span class="testingo">=</span> <span class="testingn">highlight</span><span class="testingp">(</span><span class="testings1">&#39;</span><span class="testingse">\n</span><span class="testings1">&#39;</span><span class="testingo">.</span><span class="testingn">join</span><span class="testingp">(</span><span class="testingbp">self</span><span class="testingo">.</span><span class="testingn">content</span><span class="testingp">),</span> <span class="testingn">lexer</span><span class="testingp">,</span> <span class="testingn">formatter</span><span class="testingp">)</span><br></span><span id="foo-27"><a name="foo-27"></a><span class="lineno">   </span>    <span class="testingk">return</span> <span class="testingp">[</span><span class="testingn">nodes</span><span class="testingo">.</span><span class="testingn">raw</span><span class="testingp">(</span><span class="testings1">&#39;&#39;</span><span class="testingp">,</span> <span class="testingn">parsed</span><span class="testingp">,</span> <span class="testingn">format</span><span class="testingo">=</span><span class="testings1">&#39;html&#39;</span><span class="testingp">)]</span><br></span></pre></div>
- <p>Lovely.</p>
- </div>
- <div class="section" id="testing-even-more-sourcecode-directives">

pkgs/development/python-modules/phonenumbers/default.nix

···
 
 buildPythonPackage rec {
   pname = "phonenumbers";
-  version = "8.8.4";
+  version = "8.8.5";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "01kim7mwgm97wysclhyxcwvd2a8ifinaidkskglx7b2k0r7ji5sj";
+    sha256 = "adb2dd985f875ac035bbdc6a1cc57e30834e106e2ff7899e09a1690b474c1774";
   };
 
   meta = {

pkgs/development/python-modules/py3exiv2/default.nix

···
+{ buildPythonPackage, isPy3k, fetchPypi, stdenv, exiv2, boost, libcxx }:
+
+buildPythonPackage rec {
+  pname = "py3exiv2";
+  version = "0.2.1";
+  name = "${pname}-${version}";
+  disabled = !(isPy3k);
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "06q7mlqy05c3jr61nmz93fxb6ilizfyggbh5sg0krwjap2sw1fr8";
+  };
+
+  buildInputs = [ exiv2 boost ];
+
+  # work around python distutils compiling C++ with $CC (see issue #26709)
+  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isDarwin "-I${libcxx}/include/c++/v1";
+
+  # fix broken libboost_python3 detection
+  patches = [ ./setup.patch ];
+
+  meta = {
+    homepage = "https://launchpad.net/py3exiv2";
+    description = "A Python3 binding to the library exiv2";
+    license = with stdenv.lib.licenses; [ gpl3 ];
+    maintainers = with stdenv.lib.maintainers; [ vinymeuh ];
+    platforms = with stdenv.lib.platforms; linux ++ darwin;
+  };
+}

pkgs/development/python-modules/py3exiv2/setup.patch

···
+--- a/setup.py	2017-10-16 22:03:02.000000000 +0200
++++ b/setup.py	2017-10-16 22:03:34.000000000 +0200
+@@ -39,7 +39,7 @@
+                 if '3' in l[2:]:
+                     return l.replace('libboost', 'boost')
+ 
+-libboost = get_libboost_name()
++libboost = 'boost_python3'
+ 
+ setup(
+     name='py3exiv2',

pkgs/development/python-modules/pyobjc/default.nix

···
+{ stdenv, fetchPypi, isPy3k, buildPythonPackage }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "pyobjc";
+  version = "4.0b1";
+
+  # Gives "No matching distribution found for
+  # pyobjc-framework-Collaboration==4.0b1 (from pyobjc==4.0b1)"
+  disabled = isPy3k;
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "16bng6960c1m57nnh1l09ycnyimrqzw9mx9pnyjxn5zzm5kalr37";
+  };
+
+  meta = {
+    description = "A bridge between the Python and Objective-C programming languages";
+    license = stdenv.lib.licenses.mit;
+    maintainers = with stdenv.lib.maintainers; [ sauyon ];
+    homepage = https://pythonhosted.org/pyobjc/;
+  };
+}

pkgs/development/python-modules/pyodbc/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyodbc";
-  version = "4.0.19";
+  version = "4.0.21";
   name = "${pname}-${version}";
   disabled = isPyPy;  # use pypypdbc instead
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "05mkaxbi9n02bpr3l0qnyfb3458f35hk71bq8jmadikp3h8al7dg";
+    sha256 = "9655f84ca9e5cb2dfffff705601017420c840d55271ba62dd44f05383eff0329";
   };
 
   buildInputs = [ libiodbc ];

pkgs/development/python-modules/pyspread/default.nix

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "pyspread";
-  version = "1.1";
+  version = "1.1.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0m1a4zvzrfrnc42j8mrbm7747w03nzyl9z02wjagccmlhi6nd9hx";
+    sha256 = "b90edb92c7fce3b8332cdddd3dd1c72ba14440ab39a10ca89c9888ad973a8862";
   };
 
   propagatedBuildInputs = [ numpy wxPython matplotlib pycairo python-gnupg xlrd xlwt jedi pyenchant basemap pygtk ];

pkgs/development/python-modules/shapely/default.nix

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "Shapely";
-  version = "1.6.1";
+  version = "1.6.2.post1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1iyhrkm6g233gwbd20sf4aq4by0kg52cz1d2k7imnqgzjpmkgqas";
+    sha256 = "07fba518e76b3276558f62a5829bdfa476f790cdef752383ccdc8c66b04b0899";
   };
 
   buildInputs = [ geos glibcLocales cython ];

pkgs/development/python-modules/six/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "six";
+  version = "1.11.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "70e8a77beed4562e7f14fe23a786b54f6296e34344c23bc42f07b15018ff98e9";
+  };
+
+  checkInputs = [ pytest ];
+
+  checkPhase = ''
+    py.test test_six.py
+  '';
+
+  meta = {
+    description = "A Python 2 and 3 compatibility library";
+    homepage = http://pypi.python.org/pypi/six/;
+    license = lib.licenses.mit;
+  };
+}

pkgs/development/python-modules/sqlalchemy-0.7.10-test-failures.patch

···
-From abd9f52ade78c737571be69f21dba384be3edf4e Mon Sep 17 00:00:00 2001
-From: Mike Bayer <[e-mail]>
-Date: Sat, 2 Mar 2013 16:24:50 -0500
-Subject: [PATCH] - Fixed an import of "logging" in test_execute which was not
- working on some linux platforms. [ticket:2669]
-
----
- doc/build/changelog/changelog_07.rst | 10 ++++++++++
- lib/sqlalchemy/__init__.py           |  2 +-
- test/engine/test_execute.py          |  2 +-
- 3 files changed, 12 insertions(+), 2 deletions(-)
-
-diff --git a/doc/build/changelog/changelog_07.rst b/doc/build/changelog/changelog_07.rst
-index 416df5a..f07c9ec 100644
---- a/doc/build/changelog/changelog_07.rst
-+++ b/doc/build/changelog/changelog_07.rst
-@@ -3,6 +3,16 @@
- 0.7 Changelog
- ==============
- 
-+.. changelog::
-+    :version: 0.7.11
-+
-+    .. change::
-+        :tags: bug, tests
-+        :tickets: 2669
-+        :pullreq: 41
-+
-+      Fixed an import of "logging" in test_execute which was not
-+      working on some linux platforms.
- 
- .. changelog::
-     :version: 0.7.10
-diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
-index 69b94f1..a37f684 100644
---- a/test/engine/test_execute.py
-+++ b/test/engine/test_execute.py
-@@ -9,7 +9,7 @@
- import sqlalchemy as tsa
- from test.lib import testing, engines
- from test.lib.engines import testing_engine
--import logging
-+import logging.handlers
- from sqlalchemy.dialects.oracle.zxjdbc import ReturningParam
- from sqlalchemy.engine import base, default
- from sqlalchemy.engine.base import Connection, Engine
--- 
-1.8.1.6
-

pkgs/development/python-modules/sqlalchemy/default.nix

···
 buildPythonPackage rec {
   pname = "SQLAlchemy";
   name = "${pname}-${version}";
-  version = "1.1.14";
+  version = "1.1.15";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f1191e29e35b6fe1aef7175a09b1707ebb7bd08d0b17cb0feada76c49e5a2d1e";
+    sha256 = "8b79a5ed91cdcb5abe97b0045664c55c140aec09e5dd5c01303e23de5fe7a95a";
   };
 
   checkInputs = [

pkgs/development/python-modules/sqlmap/default.nix

···
 
 buildPythonPackage rec {
   pname = "sqlmap";
-  version = "1.1.10";
+  version = "1.1.11";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "90db96664955c6a576b495c973bd3976b9d4eaffaea205c0343ac7e8f8147cbe";
+    sha256 = "bb5297df9cd97316b3c7ca64f8e31cae5cc6b94c015afd84c546877f1f77d6e4";
   };
 
   # No tests in archive

pkgs/development/python-modules/urwid/default.nix

···
   patches = [
    # fix tests
    (fetchpatch {
-     url = "https://github.com/mwhudson/urwid/commit/4b0ed8b6030450e6d99909a7c683e9642e546387.patch";
+     url = "https://github.com/urwid/urwid/commit/4b0ed8b6030450e6d99909a7c683e9642e546387.patch";
      sha256 = "0azpn0ylbg8mfpr0y27n4lnq0ph75a4d4m9wdv3napnhf1vh9ahx";
    })
    # fix tests

pkgs/development/r-modules/README.md

···
 Then like above, `nix-env -f "<nixpkgs>" -iA rstudioEnv` will install
 this into your user profile.
 
+Alternatively, you can create a self-contained `shell.nix` without the need to
+modify any configuration files:
+
+```nix
+{ pkgs ? import <nixpkgs> {}
+}:
+
+pkgs.rstudioWrapper.override {
+  packages = with pkgs.rPackages; [ dplyr ggplot2 reshape2 ];
+}
+
+```
+
+Executing `nix-shell` will then drop you into an environment equivalent to the
+one above. If you need additional packages just add them to the list and
+re-enter the shell.
+
 ## Updating the package set
 
 ```bash

pkgs/development/tools/analysis/splint/darwin.patch

···
+diff --git a/src/osd.c b/src/osd.c
+index ebe214a..4ba81d5 100644
+--- a/src/osd.c
++++ b/src/osd.c
+@@ -516,7 +516,7 @@ osd_getPid ()
+ # if defined (WIN32) || defined (OS2) && defined (__IBMC__)
+   int pid = _getpid ();
+ # else
+-  __pid_t pid = getpid ();
++  pid_t pid = getpid ();
+ # endif
+ 
+   return (int) pid;

pkgs/development/tools/analysis/splint/default.nix

···
     sha256 = "02pv8kscsrkrzip9r08pfs9xs98q74c52mlxzbii6cv6vx1vd3f7";
   };
 
-  patches = [ ./tmpdir.patch ];
+  patches = [ ./tmpdir.patch ] ++ stdenv.lib.optional stdenv.isDarwin ./darwin.patch;
 
   buildInputs = [ flex ];
 
···
     '';
 
     license = licenses.gpl2Plus;
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

pkgs/development/tools/build-managers/sbt-extras/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ stdenv, fetchFromGitHub, which, curl, makeWrapper }:
 
 let
   rev = "77686b3dfa20a34270cc52377c8e37c3a461e484";
···
 
   dontBuild = true;
 
+  buildInputs = [ makeWrapper ];
+
   installPhase = ''
     mkdir -p $out/bin
     install bin/sbt $out/bin
+
+    wrapProgram $out/bin/sbt --prefix PATH : ${stdenv.lib.makeBinPath [ which curl]}
   '';
 
   meta = {

pkgs/development/tools/haskell/ihaskell/wrapper.nix

···
-{ stdenv, writeScriptBin, makeWrapper, buildEnv, ghcWithPackages, ihaskell, ipython, packages }:
+{ stdenv, writeScriptBin, makeWrapper, buildEnv, haskell, ghcWithPackages, ihaskell, jupyter, packages }:
 let
   ihaskellEnv = ghcWithPackages (self: [
     self.ihaskell
-    self.ihaskell-blaze
-    self.ihaskell-diagrams
-    self.ihaskell-display
+    (haskell.lib.doJailbreak self.ihaskell-blaze)
+    (haskell.lib.doJailbreak self.ihaskell-diagrams)
+    (haskell.lib.doJailbreak self.ihaskell-display)
   ] ++ packages self);
   ihaskellSh = writeScriptBin "ihaskell-notebook" ''
     #! ${stdenv.shell}
     export GHC_PACKAGE_PATH="$(echo ${ihaskellEnv}/lib/*/package.conf.d| tr ' ' ':'):$GHC_PACKAGE_PATH"
-    export PATH="${stdenv.lib.makeBinPath [ ihaskell ihaskellEnv ipython ]}"
-    ${ihaskell}/bin/ihaskell install -l $(${ihaskellEnv}/bin/ghc --print-libdir) && ${ipython}/bin/ipython notebook --kernel=haskell
+    export PATH="${stdenv.lib.makeBinPath ([ ihaskell ihaskellEnv jupyter ])}"
+    ${ihaskell}/bin/ihaskell install -l $(${ihaskellEnv}/bin/ghc --print-libdir) && ${jupyter}/bin/jupyter notebook
   '';
-  profile = "${ihaskell.pname}-${ihaskell.version}/profile/profile.tar";
 in
 buildEnv {
   name = "ihaskell-with-packages";
-  paths = [ ihaskellEnv ipython ];
+  buildInputs = [ makeWrapper ];
+  paths = [ ihaskellEnv jupyter ];
   postBuild = ''
-    . "${makeWrapper}/nix-support/setup-hook"
-    ln -s ${ihaskellSh}/bin/ihaskell-notebook $out/bin/.
+    ln -s ${ihaskellSh}/bin/ihaskell-notebook $out/bin/
     for prg in $out/bin"/"*;do
-      wrapProgram $prg --set PYTHONPATH "$(echo ${ipython}/lib/*/site-packages)"
+      if [[ -f $prg && -x $prg ]]; then
+        wrapProgram $prg --set PYTHONPATH "$(echo ${jupyter}/lib/*/site-packages)"
+      fi
     done
   '';
 }

pkgs/development/tools/icestorm/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "icestorm-${version}";
-  version = "2017.10.16";
+  version = "2017.11.05";
 
   src = fetchFromGitHub {
-    owner = "cliffordwolf";
-    repo = "icestorm";
-    rev = "d9d2a3dcaa749014f5b9a539768b8368bb529b28";
-    sha256 = "1a755jnbjq3v7a3l90qjlgihmrpbdfiiabb4g8sw3ay3qmvzwh6b";
+    owner  = "cliffordwolf";
+    repo   = "icestorm";
+    rev    = "3ba18d001754de563ab0baa2a1c8eecbe63ef121";
+    sha256 = "1c7yv91xi4vx0130xn2zq74gfjbf7fhm2q4fma9xgwj5xpdy8rmn";
   };
 
   buildInputs = [ python3 libftdi ];

pkgs/development/tools/ocaml/omake/default.nix

···
 stdenv.mkDerivation rec {
 
   name = "omake-${version}";
-  version = "0.10.2";
+  version = "0.10.3";
 
   src = fetchurl {
     url = "http://download.camlcity.org/download/${name}.tar.gz";
-    sha256 = "1znnlkpz89hk44byvnl1pr92ym6hwfyyw2qm9clq446r6l2z4m64";
+    sha256 = "07bdg1h5i7qnlv9xq81ad5hfypl10hxm771h4rjyl5cn8plhfcgz";
   };
 
   buildInputs = [ ocaml ncurses ];

pkgs/development/tools/sqsh/default.nix

···
-{ stdenv, fetchurl, freetds, readline }:
+{ stdenv, fetchurl, autoreconfHook, freetds, readline }:
 
-stdenv.mkDerivation rec {
-  version = "2.5.16.1";
+let
+  mainVersion = "2.5";
+
+in stdenv.mkDerivation rec {
   name = "sqsh-${version}";
+  version = "${mainVersion}.16.1";
 
   src = fetchurl {
-    url = "http://www.mirrorservice.org/sites/downloads.sourceforge.net/s/sq/sqsh/sqsh/sqsh-2.5/${name}.tgz";
+    url    = "mirror://sourceforge/sqsh/sqsh/sqsh-${mainVersion}/${name}.tgz";
     sha256 = "1wi0hdmhk7l8nrz4j3kaa177mmxyklmzhj7sq1gj4q6fb8v1yr6n";
   };
 
-  preConfigure =
-    ''
+  preConfigure = ''
     export SYBASE=${freetds}
-    '';
+
+    substituteInPlace src/cmd_connect.c \
+      --replace CS_TDS_80 CS_TDS_73
+  '';
+
+  enableParallelBuilding = true;
 
-  buildInputs = [
-    freetds
-    readline
-  ];
+  buildInputs = [ freetds readline ];
+
+  nativeBuildInputs = [ autoreconfHook ];
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Command line tool for querying Sybase/MSSQL databases";
-    longDescription = 
-      ''
+    longDescription = ''
       Sqsh (pronounced skwish) is short for SQshelL (pronounced s-q-shell),
       it is intended as a replacement for the venerable 'isql' program supplied
       by Sybase.
-      '';
-    homepage = http://www.cs.washington.edu/~rose/sqsh/sqsh.html;
-    platforms = stdenv.lib.platforms.all;
+    '';
+    homepage = http://sourceforge.net/projects/sqsh/;
+    platforms = platforms.all;
   };
 }

pkgs/games/arx-libertatis/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "arx-libertatis-${version}";
-  version = "2017-02-26";
+  version = "2017-10-30";
 
   src = fetchFromGitHub {
     owner  = "arx";
     repo   = "ArxLibertatis";
-    rev    = "0d2bb46025b2ad0fd5c8bcddd1cc04750282608d";
+    rev    = "e5ea4e8f0f7e86102cfc9113c53daeb0bdee6dd3";
     sha256 = "11z0ndhk802jr3w3z5gfqw064g98v99xin883q1qd36jw96s27p5";
   };
 

pkgs/games/torcs/default.nix

···
-{ fetchpatch, fetchurl, stdenv, mesa, freeglut, libX11, plib, openal, freealut, libXrandr, xproto,
+{ fetchpatch, fetchurl, stdenv, mesa_glu, freeglut, libX11, plib, openal, freealut, libXrandr, xproto,
 libXext, libSM, libICE, libXi, libXt, libXrender, libXxf86vm, libvorbis,
 libpng, zlib, bash, makeWrapper }:
 
···
     sed -i -e s,/bin/bash,`type -P bash`, src/linux/torcs.in
   '';
 
-  buildInputs = [ mesa freeglut libX11 plib openal freealut libXrandr xproto
+  buildInputs = [ mesa_glu freeglut libX11 plib openal freealut libXrandr xproto
     libXext libSM libICE libXi libXt libXrender libXxf86vm libpng zlib libvorbis makeWrapper ];
 
-  nativeBuildInputs = [ bash ];
-
   installTargets = "install datainstall";
-
-  postInstall = ''
-    wrapProgram $out/bin/torcs \
-      --prefix LD_LIBRARY_PATH : ${mesa}/lib
-  '';
 
   meta = {
     description = "Car racing game";

pkgs/misc/lilypond/default.nix

···
       fontforge help2man groff makeWrapper t1utils
     ];
 
-  enableParallelBuilding = true;
+  #enableParallelBuilding = true; # fatal error: parser.hh: No such file or directory
 
   meta = with stdenv.lib; {
     description = "Music typesetting system";

pkgs/misc/themes/adapta/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "adapta-gtk-theme-${version}";
-  version = "3.91.2.147";
+  version = "3.92.1.72";
 
   src = fetchFromGitHub {
-    owner = "tista500";
-    repo = "Adapta";
+    owner = "adapta-project";
+    repo = "adapta-gtk-theme";
     rev = version;
-    sha256 = "1sv4s8rcc40v4lanapdqanlqf1l60rbc5wd7h73l5cigbqxxgda9";
+    sha256 = "19kav8m6aj4h7qg0z92k09lppzdgy6h9lxxv3qqqrl3hmg7bn0sx";
   };
 
   preferLocalBuild = true;
···
 
   meta = with stdenv.lib; {
     description = "An adaptive Gtk+ theme based on Material Design";
-    homepage = https://github.com/tista500/Adapta;
+    homepage = https://github.com/adapta-project/adapta-gtk-theme;
     license = with licenses; [ gpl2 cc-by-sa-30 ];
     platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];

pkgs/os-specific/linux/kernel/generic.nix

···
 , ...
 }:
 
-assert stdenv.platform.name == "sheevaplug" -> stdenv.platform.uboot != null;
 assert stdenv.isLinux;
 
 let

pkgs/os-specific/linux/kernel/linux-mptcp.nix

···
-{ stdenv, hostPlatform, fetchurl, perl, buildLinux, ... } @ args:
+{ stdenv, hostPlatform, fetchFromGitHub, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  mptcpVersion = "0.92.1";
-  modDirVersion = "4.4.83";
+  mptcpVersion = "0.93";
+  modDirVersion = "4.9.60";
   version = "${modDirVersion}-mptcp_v${mptcpVersion}";
 
   extraMeta = {
···
     maintainers = with stdenv.lib.maintainers; [ teto layus ];
   };
 
-  src = fetchurl {
-    url = "https://github.com/multipath-tcp/mptcp/archive/v${mptcpVersion}.tar.gz";
-    sha256 = "1afjqmxq9p5gyr6r607bx3mqpnx451kfpwlffzxwgdwnf93alngz";
+  src = fetchFromGitHub {
+    owner = "multipath-tcp";
+    repo = "mptcp";
+    rev = "v${mptcpVersion}";
+    sha256 = "1irlppzvcmckrazs2c4vg6y8ji31552izc3wqabf401v57jvxcys";
   };
 
   extraConfig = ''

pkgs/os-specific/linux/kernel/linux-testing.nix

···
 { stdenv, hostPlatform, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.14-rc7";
-  modDirVersion = "4.14.0-rc7";
+  version = "4.14-rc8";
+  modDirVersion = "4.14.0-rc8";
   extraMeta.branch = "4.14";
 
   src = fetchurl {
     url = "https://git.kernel.org/torvalds/t/linux-${version}.tar.gz";
-    sha256 = "1w7b1sc5dsxcqywsdbwgs92i8jpj7hsnss67yzb58z3bz3hb73m3";
+    sha256 = "0ir2ggflm1xjnn1kvv2c99m5zni5kg0ygzlpm588wnhkzd93nqjh";
   };
 
   # Should the testing kernels ever be built on Hydra?

pkgs/os-specific/linux/kernel/manual-config.nix

···
 { runCommand, nettools, bc, perl, gmp, libmpc, mpfr, kmod, openssl
-, writeTextFile, ubootChooser
+, writeTextFile, ubootTools
 , hostPlatform
 }:
 
···
 
   enableParallelBuilding = true;
 
-  nativeBuildInputs = [ perl bc nettools openssl gmp libmpc mpfr ] ++ optional (stdenv.platform.uboot != null)
-    (ubootChooser stdenv.platform.uboot);
+  nativeBuildInputs = [ perl bc nettools openssl gmp libmpc mpfr ]
+    ++ optional (stdenv.platform.kernelTarget == "uImage") ubootTools;
 
   hardeningDisable = [ "bindnow" "format" "fortify" "stackprotector" "pic" ];
 
···
 
       karch = cp.kernelArch;
 
-      # !!! uboot has messed up cross-compiling, nativeDrv builds arm tools on x86,
-      # crossDrv builds x86 tools on x86 (but arm uboot). If this is fixed, uboot
-      # can just go into buildInputs (but not nativeBuildInputs since cp.uboot
-      # may be different from stdenv.platform.uboot)
-      buildInputs = optional (cp.uboot != null) (ubootChooser cp.uboot).crossDrv;
+      nativeBuildInputs = optional (cp.kernelTarget == "uImage") ubootTools;
   };
 })

pkgs/os-specific/linux/rewritefs/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "rewritefs-${version}";
-  version = "2016-07-27";
+  version = "2017-08-14";
 
   src = fetchFromGitHub {
-    owner = "sloonz";
-    repo = "rewritefs";
-    rev = "fe19d389746bdffcc1cc7b3e3156dbacd04b4e9b";
+    owner  = "sloonz";
+    repo   = "rewritefs";
+    rev    = "33fb844d8e8ff441a3fc80d2715e8c64f8563d81";
     sha256 = "15bcxprkxf0xqxljsqhb0jpi7p1vwqcb00sjs7nzrj7vh2p7mqla";
   };
  

pkgs/os-specific/linux/service-wrapper/default.nix

···
+{ lib, runCommand, substituteAll, fetchurl, systemd, coreutils }:
+
+let
+  name = "service-wrapper-${version}";
+  version = "16.04.0"; # Ajar to Ubuntu Release
+in
+runCommand "${name}" {
+  script = substituteAll {
+    src = ./service-wrapper.sh;
+    inherit coreutils;
+  };
+
+  meta = with lib; {
+    description = "A convenient wrapper for the systemctl commands, borrow from Ubuntu";
+    license     = licenses.gpl2Plus;
+    platforms   = platforms.linux;
+    maintainers = with maintainers; [ DerTim1 ];
+  };
+}
+''
+  mkdir -p $out/bin
+  ln -s $out/bin $out/sbin
+  cp $script $out/bin/service
+  chmod a+x $out/bin/service
+''

pkgs/os-specific/linux/service-wrapper/service-wrapper.sh

···
+#!/bin/sh
+
+###########################################################################
+# /usr/bin/service
+#
+# A convenient wrapper for the /etc/init.d init scripts.
+#
+# This script is a modified version of the /sbin/service utility found on
+# Red Hat/Fedora systems (licensed GPLv2+).
+#
+# Copyright (C) 2006 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2008 Canonical Ltd.
+#   * August 2008 - Dustin Kirkland <[e-mail]>
+# Copyright (C) 2013 Michael Stapelberg <[e-mail]>
+#
+# This program 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 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# On Debian GNU/Linux systems, the complete text of the GNU General
+# Public License can be found in `/usr/share/common-licenses/GPL-2'.
+###########################################################################
+
+
+is_ignored_file() {
+	case "$1" in
+		skeleton | README | *.dpkg-dist | *.dpkg-old | rc | rcS | single | reboot | bootclean.sh)
+			return 0
+		;;
+	esac
+	return 1
+}
+
+VERSION=$(@coreutils@/bin/basename $0)" ver. 0.91-ubuntu1"
+USAGE="Usage: "$(@coreutils@/bin/basename $0)" < option > | --status-all | \
+[ service_name [ command | --full-restart ] ]"
+SERVICE=
+ACTION=
+SERVICEDIR="/etc/init.d"
+OPTIONS=
+is_systemd=
+
+
+if [ $# -eq 0 ]; then
+   echo "${USAGE}" >&2
+   exit 1
+fi
+
+if [ -d /run/systemd/system ]; then
+   is_systemd=1
+fi
+
+cd /
+while [ $# -gt 0 ]; do
+  case "${1}" in
+    --help | -h | --h* )
+       echo "${USAGE}" >&2
+       exit 0
+       ;;
+    --version | -V )
+       echo "${VERSION}" >&2
+       exit 0
+       ;;
+    *)
+       if [ -z "${SERVICE}" -a $# -eq 1 -a "${1}" = "--status-all" ]; then
+          if [ -d "${SERVICEDIR}" ]; then
+             cd ${SERVICEDIR}
+	     for SERVICE in * ; do
+	       case "${SERVICE}" in
+	         functions | halt | killall | single| linuxconf| kudzu)
+	             ;;
+	         *)
+	           if ! is_ignored_file "${SERVICE}" \
+	   	    && [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+	                   out=$(env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" status 2>&1)
+	                   retval=$?
+	                   if echo "$out" | egrep -iq "usage:"; then
+	                     #printf " %s %-60s %s\n" "[?]" "$SERVICE:" "unknown" 1>&2
+	                     echo " [ ? ]  $SERVICE" 1>&2
+	                     continue
+	                   else
+	                     if [ "$retval" = "0" -a -n "$out" ]; then
+	                       #printf " %s %-60s %s\n" "[+]" "$SERVICE:" "running"
+	                       echo " [ + ]  $SERVICE"
+	                       continue
+	                     else
+	                       #printf " %s %-60s %s\n" "[-]" "$SERVICE:" "NOT running"
+	                       echo " [ - ]  $SERVICE"
+	                       continue
+	                     fi
+	                   fi
+	             #env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" status
+	           fi
+	           ;;
+	       esac
+	     done
+          else
+             systemctl $sctl_args list-units
+          fi
+          exit 0
+       elif [ $# -eq 2 -a "${2}" = "--full-restart" ]; then
+          SERVICE="${1}"
+          # On systems using systemd, we just perform a normal restart:
+          # A restart with systemd is already a full restart.
+          if [ -n "$is_systemd" ]; then
+             ACTION="restart"
+          else
+             if [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+               env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" stop
+               env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" start
+               exit $?
+             fi
+          fi
+       elif [ -z "${SERVICE}" ]; then
+         SERVICE="${1}"
+       elif [ -z "${ACTION}" ]; then
+         ACTION="${1}"
+       else
+         OPTIONS="${OPTIONS} ${1}"
+       fi
+       shift
+       ;;
+   esac
+done
+
+# Operate against system upstart, not session
+unset UPSTART_SESSION
+if [ -r "/etc/init/${SERVICE}.conf" ] && which initctl >/dev/null \
+   && initctl version 2>/dev/null | grep -q upstart \
+   && initctl status ${SERVICE} 2>/dev/null 1>/dev/null
+then
+   # Upstart configuration exists for this job and we're running on upstart
+   case "${ACTION}" in
+      start|stop|status|reload)
+         # Action is a valid upstart action
+         exec ${ACTION} ${SERVICE} ${OPTIONS}
+      ;;
+      restart|force-reload)
+        # Map restart to the usual sysvinit behavior.
+        # Map force-reload to restart as per Debian policy 9.3.2,
+        # since there is no way to know if "reload" is supported
+         stop ${SERVICE} ${OPTIONS} || :
+         exec start ${SERVICE} ${OPTIONS}
+      ;;
+   esac
+fi
+
+
+run_via_sysvinit() {
+   # Otherwise, use the traditional sysvinit
+   if [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+      exec env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" ${ACTION} ${OPTIONS}
+   else
+      echo "${SERVICE}: unrecognized service" >&2
+      exit 1
+   fi
+}
+
+update_openrc_started_symlinks() {
+   # maintain the symlinks of /run/openrc/started so that
+   # rc-status works with the service command as well
+   if [ -d /run/openrc/started ] ; then
+      case "${ACTION}" in
+      start)
+         if [ ! -h /run/openrc/started/$SERVICE ] ; then
+            ln -s $SERVICEDIR/$SERVICE /run/openrc/started/$SERVICE || true
+         fi
+      ;;
+      stop)
+         rm /run/openrc/started/$SERVICE || true
+      ;;
+      esac
+   fi
+}
+
+# When this machine is running systemd, standard service calls are turned into
+# systemctl calls.
+if [ -n "$is_systemd" ]
+then
+   UNIT="${SERVICE%.sh}.service"
+   # avoid deadlocks during bootup and shutdown from units/hooks
+   # which call "invoke-rc.d service reload" and similar, since
+   # the synchronous wait plus systemd's normal behaviour of
+   # transactionally processing all dependencies first easily
+   # causes dependency loops
+   if ! systemctl --quiet is-active multi-user.target; then
+       sctl_args="--job-mode=ignore-dependencies"
+   fi
+
+   case "${ACTION}" in
+      restart|status)
+         exec systemctl $sctl_args ${ACTION} ${UNIT}
+      ;;
+      start|stop)
+         # Follow the principle of least surprise for SysV people:
+         # When running "service foo stop" and foo happens to be a service that
+         # has one or more .socket files, we also stop the .socket units.
+         # Users who need more control will use systemctl directly.
+         for unit in $(systemctl list-unit-files --full --type=socket 2>/dev/null | sed -ne 's/\.socket\s*[a-z]*\s*$/.socket/p'); do
+             if [ "$(systemctl -p Triggers show $unit)" = "Triggers=${UNIT}" ]; then
+                systemctl $sctl_args ${ACTION} $unit
+             fi
+         done
+         exec systemctl $sctl_args ${ACTION} ${UNIT}
+      ;;
+      reload)
+         _canreload="$(SYSTEMCTL -p CanReload show ${UNIT} 2>/dev/null)"
+         if [ "$_canreload" = "CanReload=no" ]; then
+            # The reload action falls back to the sysv init script just in case
+            # the systemd service file does not (yet) support reload for a
+            # specific service.
+            run_via_sysvinit
+         else
+            exec systemctl $sctl_args reload "${UNIT}"
+         fi
+         ;;
+      force-stop)
+         exec systemctl --signal=KILL kill "${UNIT}"
+         ;;
+      force-reload)
+         _canreload="$(systemctl -p CanReload show ${UNIT} 2>/dev/null)"
+         if [ "$_canreload" = "CanReload=no" ]; then
+            exec systemctl $sctl_args restart "${UNIT}"
+         else
+            exec systemctl $sctl_args reload "${UNIT}"
+         fi
+         ;;
+      *)
+         # We try to run non-standard actions by running
+         # the init script directly.
+         run_via_sysvinit
+         ;;
+   esac
+fi
+
+update_openrc_started_symlinks
+run_via_sysvinit

pkgs/os-specific/linux/xf86-input-wacom/default.nix

···
 , ncurses, pkgconfig, randrproto, xorgserver, xproto, udev, libXinerama, pixman }:
 
 stdenv.mkDerivation rec {
-  name = "xf86-input-wacom-0.34.0";
+  name = "xf86-input-wacom-0.35.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/linuxwacom/${name}.tar.bz2";
-    sha256 = "0idhkigl0pnyp08sqm6bqfb4h20v6rjrb71z1gdv59gk7d7qwpgi";
+    sha256 = "0za44snc0zirq65a4lxsmg7blp1bynj6j835hm459x8yx1qhmxjm";
   };
 
   buildInputs = [ inputproto libX11 libXext libXi libXrandr libXrender

pkgs/servers/dns/pdns-recursor/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "pdns-recursor-${version}";
-  version = "4.0.4";
+  version = "4.0.6";
 
   src = fetchurl {
     url = "https://downloads.powerdns.com/releases/pdns-recursor-${version}.tar.bz2";
-    sha256 = "0k8y9zxj2lz4rq782vgzr28yd43q0hwlnvszwq0k9l6c967pff13";
+    sha256 = "03fnjiacvhdlkr3a2206mham0p6p24gkawashs5v12r68k32l67j";
   };
 
   nativeBuildInputs = [ pkgconfig ];
···
     "--enable-reproducible"
     "--with-systemd"
   ];
+
+  enableParallelBuilding = true;
 
   meta = {
     description = "A recursive DNS server";

pkgs/servers/matrix-synapse/default.nix

···
 { lib, pkgs, stdenv, pythonPackages, fetchurl, fetchFromGitHub }:
 let
-  matrix-angular-sdk = pythonPackages.buildPythonApplication rec {
+  matrix-angular-sdk = pythonPackages.buildPythonPackage rec {
     name = "matrix-angular-sdk-${version}";
     version = "0.6.8";
 
···
       sha256 = "0gmx4y5kqqphnq3m7xk2vpzb0w2a4palicw7wfdr1q2schl9fhz2";
     };
   };
-  matrix-synapse-ldap3 = pythonPackages.buildPythonApplication rec {
+  matrix-synapse-ldap3 = pythonPackages.buildPythonPackage rec {
     name = "matrix-synapse-ldap3-${version}";
     version = "0.1.2";
 
···
   };
 in pythonPackages.buildPythonApplication rec {
   name = "matrix-synapse-${version}";
-  version = "0.22.1";
+  version = "0.24.1";
 
   src = fetchFromGitHub {
     owner = "matrix-org";
     repo = "synapse";
     rev = "v${version}";
-    sha256 = "06kqqsfqmziff7i99yyxqvkqjm7fwi56abc2vy25g9kqzpdvkay7";
+    sha256 = "08w8sawq0nj28dzi9wc4rsg9z2qv528djj4zbcs5c4yc3mylq1nq";
   };
 
   patches = [ ./matrix-synapse.patch ];
 
   propagatedBuildInputs = with pythonPackages; [
-    blist canonicaljson daemonize dateutil frozendict pillow pybcrypt pyasn1
+    blist canonicaljson daemonize dateutil frozendict pillow pyasn1
     pydenticon pymacaroons-pynacl pynacl pyopenssl pysaml2 pytz requests
     signedjson systemd twisted ujson unpaddedbase64 pyyaml
     matrix-angular-sdk bleach netaddr jinja2 psycopg2
     psutil msgpack lxml matrix-synapse-ldap3
-    phonenumbers jsonschema
+    phonenumbers jsonschema affinity bcrypt
   ];
 
   # Checks fail because of Tox.

pkgs/servers/sql/postgresql/timescaledb/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "timescaledb-${version}";
-  version = "0.5.0";
+  version = "0.6.0";
 
   buildInputs = [ postgresql ];
 
···
     owner = "timescale";
     repo = "timescaledb";
     rev = version;
-    sha256 = "01swgjw563c42azxsg55ry7cyiipxkcvfrxmw71jil5dxl3s0fkz";
+    sha256 = "061z1ll3x7ca7fj12rl2difkdvmqykksqhpsql552qkkylg7iq4d";
   };
 
   installPhase = ''

pkgs/tools/X11/xosview2/default.nix

···
+{ stdenv, fetchurl, libX11 }:
+
+stdenv.mkDerivation rec {
+  name = "xosview2-${version}";
+  version = "2.2.2";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/xosview/${name}.tar.gz";
+    sha256 = "3502e119a5305ff2396f559340132910807351c7d4e375f13b5c338404990406";
+  };
+
+  # The software failed to buid with this enabled; it seemed tests were not implemented
+  doCheck = false;
+
+  buildInputs = [ libX11 ];
+
+  meta = with stdenv.lib; {
+    description = "Lightweight program that gathers information from your operating system and displays it in graphical form";
+    longDescription = ''
+      xosview is a lightweight program that gathers information from your
+      operating system and displays it in graphical form. It attempts to show
+      you in a quick glance an overview of how your system resources are being
+      utilized.
+
+      It can be configured to be nothing more than a small strip showing a
+      couple of parameters on a desktop task bar. Or it can display dozens of
+      meters and rolling graphical charts over your entire screen.
+
+      Since xosview renders all graphics with core X11 drawing methods, you can
+      run it on one machine and display it on another. This works even if your
+      other host is an operating system not running an X server inside a
+      virtual machine running on a physically different host. If you can
+      connect to it on a network, then you can popup an xosview instance and
+      monitor what is going on.
+    '';
+    homepage = "http://xosview.sourceforge.net/index.html";
+    license = licenses.gpl1;
+    maintainers = [ maintainers.SeanZicari ];
+    platforms = platforms.all;
+  };
+}

pkgs/tools/filesystems/snapraid/default.nix

···
     owner = "amadvance";
     repo = "snapraid";
     rev = "v${version}";
-    sha256 = "13v0gz22ng09gs87f7900z2sk2hg5543njl32rfn4cxxp0jncs3r";
+    sha256 = "1vgyiagn6qvyyz4jkf8pzlg0w9apb6mzza97a9x03p82fav2afx0";
   };
 
   doCheck = true;

pkgs/tools/filesystems/sshfs-fuse/default.nix

···
 
 let
   inherit (stdenv.lib) optional;
-  rpath = stdenv.lib.makeLibraryPath [ fuse3 glib ];
 in stdenv.mkDerivation rec {
   version = "3.3.1";
   name = "sshfs-fuse-${version}";
···
   postInstall = ''
     mkdir -p $out/sbin
     ln -sf $out/bin/sshfs $out/sbin/mount.sshfs
-  '';
-
-  postFixup = ''
-       patchelf --set-rpath '${rpath}' "$out/bin/sshfs"
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/misc/bdf2psf/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "bdf2psf-${version}";
-  version = "1.158";
+  version = "1.170";
 
   src = fetchurl {
     url = "mirror://debian/pool/main/c/console-setup/bdf2psf_${version}_all.deb";
-    sha256 = "12zaj7hi5gzdh9r7rcyqnkwik1ljw1qzj6j7rw80bgw6fn611rs9";
+    sha256 = "0xh743cr21qk8cmc6ijp59d61dqra4ggdlgbin9v991xqa0mqdxb";
   };
 
   buildInputs = [ dpkg ];

pkgs/tools/misc/colord/default.nix

···
 { stdenv, fetchurl, bash-completion
-, glib, polkit, pkgconfig, intltool, gusb, libusb1, lcms2, sqlite, systemd, dbus
-, gtk_doc, gobjectIntrospection, argyllcms, autoreconfHook
+, glib, polkit, pkgconfig, gettext, gusb, lcms2, sqlite, systemd, dbus
+, gobjectIntrospection, argyllcms, meson, ninja, libxml2, vala_0_38
 , libgudev, sane-backends }:
 
 stdenv.mkDerivation rec {
-  name = "colord-1.2.12";
+  name = "colord-1.4.1";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/colord/releases/${name}.tar.xz";
-    sha256 = "0flcsr148xshjbff030pgyk9ar25an901m9q1pjgjdvaq5j1h96m";
+    sha256 = "0m854clp8szvq38z16jpazzlqfb3lb3icxcfnsisfrc25748y1ib";
   };
 
   enableParallelBuilding = true;
 
-  # Version mismatch requires intltoolize to overwrite
-  # with newer version.
-  preConfigure = ''
-    intltoolize --force
-  '';
-
-  configureFlags = [
-    "--enable-sane"
-    "--with-udevrulesdir=$(out)/lib/udev/rules.d"
-    "--with-systemdsystemunitdir=$(out)/etc/systemd/system"
+  mesonFlags = [
+    "-Denable-sane=true"
+    "-Denable-vala=true"
     "--localstatedir=/var"
-    "--disable-bash-completion"
+    "-Denable-bash-completion=true"
+    # TODO: man page cannot be build with docbook2x
+    "-Denable-man=false"
+    "-Denable-docs=false"
   ];
 
+  patches = [
+    ./fix-build-paths.patch
+  ];
 
-  # don't touch /var at install time, colord creates what it needs at runtime
-  postPatch = ''
-    sed -e "s|if test -w .*;|if false;|" -i src/Makefile.{am,in}
-  '';
+  nativeBuildInputs = [ meson pkgconfig vala_0_38 ninja gettext libxml2 gobjectIntrospection ];
 
-  nativeBuildInputs = [ autoreconfHook intltool pkgconfig ];
-
-  buildInputs = [ glib polkit gusb libusb1 lcms2 sqlite systemd dbus gobjectIntrospection
+  buildInputs = [ glib polkit gusb lcms2 sqlite systemd dbus
                   bash-completion argyllcms libgudev sane-backends ];
 
   postInstall = ''
-    mkdir -p $out/etc/bash_completion.d
-    cp -v data/colormgr $out/etc/bash_completion.d
+    glib-compile-schemas $out/share/glib-2.0/schemas
   '';
 
   meta = {
     description = "System service to manage, install and generate color profiles to accurately color manage input and output devices";
-    homepage = http://www.freedesktop.org/software/colord/intro.html;
+    homepage = https://www.freedesktop.org/software/colord/;
     license = stdenv.lib.licenses.lgpl2Plus;
     maintainers = [stdenv.lib.maintainers.marcweber];
     platforms = stdenv.lib.platforms.linux;

pkgs/tools/misc/colord/fix-build-paths.patch

···
+--- a/contrib/session-helper/meson.build
++++ b/contrib/session-helper/meson.build
+@@ -21,7 +21,7 @@
+     output : 'colord-session.service',
+     configuration : con2,
+     install: true,
+-    install_dir: systemd.get_pkgconfig_variable('systemduserunitdir'),
++    install_dir: join_paths(get_option('prefix'), 'etc', 'systemd', 'user'),
+   )
+ endif
+ 
+--- a/data/meson.build
++++ b/data/meson.build
+@@ -8,13 +8,13 @@
+ 
+ if get_option('enable-systemd')
+   install_data('colord.conf',
+-    install_dir: systemd.get_pkgconfig_variable('tmpfilesdir')
++    install_dir: join_paths(get_option('prefix'), 'lib', 'tmpfiles.d')
+   )
+ endif
+ 
+ if get_option('enable-bash-completion')
+   install_data('colormgr',
+-    install_dir: bash_completion.get_pkgconfig_variable('completionsdir')
++    install_dir: join_paths(get_option('prefix'), 'etc', 'bash_completion.d')
+   )
+ endif
+ 
+@@ -31,7 +31,7 @@
+     output : 'colord.service',
+     configuration : con2,
+     install: true,
+-    install_dir: systemd.get_pkgconfig_variable('systemdsystemunitdir'),
++    install_dir: join_paths(get_option('prefix'), 'etc', 'systemd', 'system'),
+   )
+ endif
+ 
+--- a/meson.build
++++ b/meson.build
+@@ -258,6 +258,3 @@
+ subdir('policy')
+ subdir('rules')
+ subdir('src')
+-
+-meson.add_install_script('meson_post_install.sh',
+-                         localstatedir, get_option('with-daemon-user'))
+--- a/rules/meson.build
++++ b/rules/meson.build
+@@ -9,5 +9,5 @@
+     sensor_rules_in,
+     '95-cd-devices.rules',
+   ],
+-  install_dir : join_paths(udev.get_pkgconfig_variable('udevdir'), 'rules.d')
++  install_dir : join_paths(get_option('prefix'), 'lib', 'udev', 'rules.d')
+ )

pkgs/tools/misc/ddcutil/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "ddcutil-${version}";
-  version = "0.8.2";
+  version = "0.8.4";
 
   src = fetchFromGitHub {
     owner  = "rockowitz";
     repo   = "ddcutil";
     rev    = "v${version}";
-    sha256 = "1hcdg54xyb1pfl03iqll14y9yglwmyvxyvhbql87hd9q0dywah6m";
+    sha256 = "1w9bkrlxlgc58rpf03xfd2qbkj73rlbiqrhy8nhwxqqhsj1kkdb0";
   };
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];

pkgs/tools/misc/fwup/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "fwup-${version}";
-  version = "0.14.3";
+  version = "0.16.1";
 
   src = fetchFromGitHub {
     owner = "fhunleth";
     repo = "fwup";
     rev = "v${version}";
-    sha256 = "15sjpxw1llpipshriivpha6470lkvhcgs5wh5mlaabjbvrgxygqh";
+    sha256 = "1hphgpwxzdbfswzxbx0jm7lma1xkkwxvm8ll3jp2ljmimqzzb7jf";
   };
 
   doCheck = true;

pkgs/tools/misc/ostree/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, gtk_doc, gobjectIntrospection
 , libgsystem, xz, e2fsprogs, libsoup, gpgme, which, autoconf, automake, libtool, fuse
-, libcap, yacc, libxslt, docbook_xsl, docbook_xml_dtd_42
+, libarchive, libcap, bzip2, yacc, libxslt, docbook_xsl, docbook_xml_dtd_42
 }:
 
 let
   libglnx-src = fetchFromGitHub {
     owner  = "GNOME";
     repo   = "libglnx";
-    rev    = "50a0feaba03ffa5a1980d3a14487276b8f49f8a6";
-    sha256 = "1rn5jdh84y1yfpqmvidx82lkm0jr7scjzdrps57r37ksxvrk3ibs";
+    rev    = "5362f6bc3ff3e30f379e767b203d15c9e56d6f08";
+    sha256 = "1l4vm7bx3cf4q44n3a1i2gszyryqyimcxvx54gna72q7dw130mrr";
   };
 
   bsdiff-src = fetchFromGitHub {
     owner  = "mendsley";
     repo   = "bsdiff";
-    rev    = "7d70d8f4ff48345bc76e314c9d98da91f78873fa";
-    sha256 = "0ai2kykj8i4bqcy3gry36r3n4ax0fldncfhksl5b293nf2fihnws";
+    rev    = "1edf9f656850c0c64dae260960fabd8249ea9c60";
+    sha256 = "1h71d2h2d3anp4msvpaff445rnzdxii3id2yglqk7af9i43kdsn1";
   };
 
-  version = "2017.9";
+  version = "2017.12";
 in stdenv.mkDerivation {
   name = "ostree-${version}";
 
···
     rev    = "v${version}";
     owner  = "ostreedev";
     repo   = "ostree";
-    sha256 = "1040xcw8qcs6xq8x4wg47hha3915qzb6lndb38wjyn6wzl1680q3";
+    sha256 = "0gxvpzwz7z4zihz5hkn6ajv7f6gas4zi2pznhi5v6wy7cw06if68";
   };
 
   nativeBuildInputs = [
···
     libxslt docbook_xsl docbook_xml_dtd_42
   ];
 
-  buildInputs = [ libgsystem xz e2fsprogs libsoup gpgme fuse libcap ];
+  buildInputs = [ libgsystem xz e2fsprogs libsoup gpgme fuse libarchive libcap bzip2 ];
 
   prePatch = ''
     rmdir libglnx bsdiff
···
 
   meta = with stdenv.lib; {
     description = "Git for operating system binaries";
-    homepage    = "http://live.gnome.org/OSTree/";
+    homepage    = https://ostree.readthedocs.io/en/latest/;
     license     = licenses.lgpl2Plus;
     platforms   = platforms.linux;
     maintainers = with maintainers; [ copumpkin ];

pkgs/tools/networking/nat-traverse/default.nix

···
+{ stdenv, fetchurl, perl }:
+
+stdenv.mkDerivation rec {
+  name = "nat-traverse-${version}";
+  version = "0.7";
+
+  src = fetchurl {
+    url = "https://www.speicherleck.de/iblech/nat-traverse/nat-traverse-${version}.tar.bz2";
+    sha256 = "0knwnqsjwv7sa5wjb863ghabs7s269a73qwkmxpsbngjw9s0j2ih";
+  };
+
+  nativeBuildInputs = [ perl ];
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share/man/man1
+    cp nat-traverse $out/bin
+    gzip -c nat-traverse.1 > $out/share/man/man1/nat-traverse.1.gz
+  '';
+
+  meta = with stdenv.lib; {
+    description = "NAT gateway traversal utility";
+    longDescription = ''
+      nat-traverse establishes direct connections between nodes which are
+      behind NAT gateways, i.e. hosts which do not have public IP addresses.
+      This is done using an UDP NAT traversal technique. Additionally, it's
+      possible to setup a small VPN by using pppd on top of nat-traverse.
+
+      nat-traverse does not need an external server on the Internet, and it
+      isn't necessary to reconfigure the involved NAT gateways, either.
+      nat-traverse works out-of-the-box.
+    '';
+    homepage = https://www.speicherleck.de/iblech/nat-traverse/;
+    license = licenses.gpl3Plus;
+    platforms = platforms.all;
+    maintainers = [ maintainers.iblech ];
+  };
+}

pkgs/tools/networking/network-manager-applet/default.nix

···
 { stdenv, fetchurl, intltool, pkgconfig, libglade, networkmanager, gnome3
-, libnotify, libsecret, polkit, isocodes, modemmanager, librsvg
+, libnotify, libsecret, polkit, isocodes, modemmanager
 , mobile_broadband_provider_info, glib_networking, gsettings_desktop_schemas
-, makeWrapper, udev, libgudev, hicolor_icon_theme, jansson, wrapGAppsHook, webkitgtk
+, udev, libgudev, hicolor_icon_theme, jansson, wrapGAppsHook, webkitgtk
 , withGnome ? false }:
 
 stdenv.mkDerivation rec {
···
 
   buildInputs = [
     gnome3.gtk libglade networkmanager libnotify libsecret gsettings_desktop_schemas
-    polkit isocodes makeWrapper udev libgudev gnome3.gconf gnome3.libgnome_keyring
-    modemmanager jansson librsvg glib_networking gnome3.dconf
+    polkit isocodes udev libgudev gnome3.libgnome_keyring
+    modemmanager jansson glib_networking
   ] ++ stdenv.lib.optional withGnome webkitgtk;
 
   nativeBuildInputs = [ intltool pkgconfig wrapGAppsHook ];
 
-  propagatedUserEnvPkgs = [ gnome3.gconf gnome3.gnome_keyring hicolor_icon_theme ];
+  propagatedUserEnvPkgs = [ gnome3.gnome_keyring hicolor_icon_theme ];
 
   makeFlags = [
     ''CFLAGS=-DMOBILE_BROADBAND_PROVIDER_INFO=\"${mobile_broadband_provider_info}/share/mobile-broadband-provider-info/serviceproviders.xml\"''

pkgs/tools/networking/statsd/default.nix

···
-{ recurseIntoAttrs, callPackage, nodejs
-}:
-
-let
-  self = recurseIntoAttrs (
-    callPackage ../../../top-level/node-packages.nix {
-      inherit nodejs self;
-      generated = callPackage ./node-packages.nix { inherit self; };
-      overrides = {
-        "statsd" = { passthru.nodePackages = self; };
-      };
-    });
-in self.statsd

pkgs/tools/networking/statsd/node-packages.json

···
-[
-  "statsd"
-, "statsd-librato-backend"
-, "stackdriver-statsd-backend"
-, "statsd-influxdb-backend"
-]

pkgs/tools/networking/statsd/node-packages.nix

···
-{ self, fetchurl, fetchgit ? null, lib }:
-
-{
-  by-spec."commander"."1.3.1" =
-    self.by-version."commander"."1.3.1";
-  by-version."commander"."1.3.1" = self.buildNodePackage {
-    name = "commander-1.3.1";
-    version = "1.3.1";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/commander/-/commander-1.3.1.tgz";
-      name = "commander-1.3.1.tgz";
-      sha1 = "02443e02db96f4b32b674225451abb6e9510000e";
-    };
-    deps = {
-      "keypress-0.1.0" = self.by-version."keypress"."0.1.0";
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."connection-parse"."0.0.x" =
-    self.by-version."connection-parse"."0.0.7";
-  by-version."connection-parse"."0.0.7" = self.buildNodePackage {
-    name = "connection-parse-0.0.7";
-    version = "0.0.7";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/connection-parse/-/connection-parse-0.0.7.tgz";
-      name = "connection-parse-0.0.7.tgz";
-      sha1 = "18e7318aab06a699267372b10c5226d25a1c9a69";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."generic-pool"."2.2.0" =
-    self.by-version."generic-pool"."2.2.0";
-  by-version."generic-pool"."2.2.0" = self.buildNodePackage {
-    name = "generic-pool-2.2.0";
-    version = "2.2.0";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/generic-pool/-/generic-pool-2.2.0.tgz";
-      name = "generic-pool-2.2.0.tgz";
-      sha1 = "8b465c1a7588ea9dd2bb133bda0bb66bfef8a63e";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."hashring"."3.2.0" =
-    self.by-version."hashring"."3.2.0";
-  by-version."hashring"."3.2.0" = self.buildNodePackage {
-    name = "hashring-3.2.0";
-    version = "3.2.0";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/hashring/-/hashring-3.2.0.tgz";
-      name = "hashring-3.2.0.tgz";
-      sha1 = "fda4efde8aa22cdb97fb1d2a65e88401e1c144ce";
-    };
-    deps = {
-      "connection-parse-0.0.7" = self.by-version."connection-parse"."0.0.7";
-      "simple-lru-cache-0.0.2" = self.by-version."simple-lru-cache"."0.0.2";
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."keypress"."0.1.x" =
-    self.by-version."keypress"."0.1.0";
-  by-version."keypress"."0.1.0" = self.buildNodePackage {
-    name = "keypress-0.1.0";
-    version = "0.1.0";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/keypress/-/keypress-0.1.0.tgz";
-      name = "keypress-0.1.0.tgz";
-      sha1 = "4a3188d4291b66b4f65edb99f806aa9ae293592a";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."modern-syslog"."1.1.2" =
-    self.by-version."modern-syslog"."1.1.2";
-  by-version."modern-syslog"."1.1.2" = self.buildNodePackage {
-    name = "modern-syslog-1.1.2";
-    version = "1.1.2";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/modern-syslog/-/modern-syslog-1.1.2.tgz";
-      name = "modern-syslog-1.1.2.tgz";
-      sha1 = "f1fa58899f3f452d788f1573401212a4ef898de5";
-    };
-    deps = {
-      "nan-2.4.0" = self.by-version."nan"."2.4.0";
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ "!win32" ];
-    cpu = [ ];
-  };
-  by-spec."nan"."^2.0.5" =
-    self.by-version."nan"."2.4.0";
-  by-version."nan"."2.4.0" = self.buildNodePackage {
-    name = "nan-2.4.0";
-    version = "2.4.0";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/nan/-/nan-2.4.0.tgz";
-      name = "nan-2.4.0.tgz";
-      sha1 = "fb3c59d45fe4effe215f0b890f8adf6eb32d2232";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."sequence"."2.2.1" =
-    self.by-version."sequence"."2.2.1";
-  by-version."sequence"."2.2.1" = self.buildNodePackage {
-    name = "sequence-2.2.1";
-    version = "2.2.1";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/sequence/-/sequence-2.2.1.tgz";
-      name = "sequence-2.2.1.tgz";
-      sha1 = "7f5617895d44351c0a047e764467690490a16b03";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."simple-lru-cache"."0.0.x" =
-    self.by-version."simple-lru-cache"."0.0.2";
-  by-version."simple-lru-cache"."0.0.2" = self.buildNodePackage {
-    name = "simple-lru-cache-0.0.2";
-    version = "0.0.2";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/simple-lru-cache/-/simple-lru-cache-0.0.2.tgz";
-      name = "simple-lru-cache-0.0.2.tgz";
-      sha1 = "d59cc3a193c1a5d0320f84ee732f6e4713e511dd";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  by-spec."stackdriver-statsd-backend"."*" =
-    self.by-version."stackdriver-statsd-backend"."0.2.3";
-  by-version."stackdriver-statsd-backend"."0.2.3" = self.buildNodePackage {
-    name = "stackdriver-statsd-backend-0.2.3";
-    version = "0.2.3";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/stackdriver-statsd-backend/-/stackdriver-statsd-backend-0.2.3.tgz";
-      name = "stackdriver-statsd-backend-0.2.3.tgz";
-      sha1 = "6ffead71e5655d4d787c39da8d1c9eaaa59c91d7";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  "stackdriver-statsd-backend" = self.by-version."stackdriver-statsd-backend"."0.2.3";
-  by-spec."statsd"."*" =
-    self.by-version."statsd"."0.8.0";
-  by-version."statsd"."0.8.0" = self.buildNodePackage {
-    name = "statsd-0.8.0";
-    version = "0.8.0";
-    bin = true;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/statsd/-/statsd-0.8.0.tgz";
-      name = "statsd-0.8.0.tgz";
-      sha1 = "92041479e174a214df7147f2fab1348af0839052";
-    };
-    deps = {
-      "generic-pool-2.2.0" = self.by-version."generic-pool"."2.2.0";
-    };
-    optionalDependencies = {
-      "modern-syslog-1.1.2" = self.by-version."modern-syslog"."1.1.2";
-      "hashring-3.2.0" = self.by-version."hashring"."3.2.0";
-      "winser-0.1.6" = self.by-version."winser"."0.1.6";
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  "statsd" = self.by-version."statsd"."0.8.0";
-  by-spec."statsd-influxdb-backend"."*" =
-    self.by-version."statsd-influxdb-backend"."0.6.0";
-  by-version."statsd-influxdb-backend"."0.6.0" = self.buildNodePackage {
-    name = "statsd-influxdb-backend-0.6.0";
-    version = "0.6.0";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/statsd-influxdb-backend/-/statsd-influxdb-backend-0.6.0.tgz";
-      name = "statsd-influxdb-backend-0.6.0.tgz";
-      sha1 = "25fb83cf0b3af923dfc7d506eb1208def8790d78";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  "statsd-influxdb-backend" = self.by-version."statsd-influxdb-backend"."0.6.0";
-  by-spec."statsd-librato-backend"."*" =
-    self.by-version."statsd-librato-backend"."0.1.7";
-  by-version."statsd-librato-backend"."0.1.7" = self.buildNodePackage {
-    name = "statsd-librato-backend-0.1.7";
-    version = "0.1.7";
-    bin = false;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/statsd-librato-backend/-/statsd-librato-backend-0.1.7.tgz";
-      name = "statsd-librato-backend-0.1.7.tgz";
-      sha1 = "270dc406481c0e6a6f4e72957681a73015f478f6";
-    };
-    deps = {
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-  "statsd-librato-backend" = self.by-version."statsd-librato-backend"."0.1.7";
-  by-spec."winser"."=0.1.6" =
-    self.by-version."winser"."0.1.6";
-  by-version."winser"."0.1.6" = self.buildNodePackage {
-    name = "winser-0.1.6";
-    version = "0.1.6";
-    bin = true;
-    src = fetchurl {
-      url = "https://registry.npmjs.org/winser/-/winser-0.1.6.tgz";
-      name = "winser-0.1.6.tgz";
-      sha1 = "08663dc32878a12bbce162d840da5097b48466c9";
-    };
-    deps = {
-      "sequence-2.2.1" = self.by-version."sequence"."2.2.1";
-      "commander-1.3.1" = self.by-version."commander"."1.3.1";
-    };
-    optionalDependencies = {
-    };
-    peerDependencies = [];
-    os = [ ];
-    cpu = [ ];
-  };
-}

pkgs/tools/package-management/packagekit/default.nix

···
 { stdenv, fetchFromGitHub, lib
 , intltool, glib, pkgconfig, polkit, python, sqlite, systemd
-, gobjectIntrospection, vala_0_23, gtk_doc, autoreconfHook, autoconf-archive
+, gobjectIntrospection, vala_0_38, gtk_doc, autoreconfHook, autoconf-archive
 # TODO: set enableNixBackend to true, as soon as it builds
 , nix, enableNixBackend ? false, boost
 , enableCommandNotFound ? false
···
 
 stdenv.mkDerivation rec {
   name = "packagekit-${version}";
-  version = "1.1.3";
+  version = "1.1.7";
 
   src = fetchFromGitHub {
     owner = "hughsie";
     repo = "PackageKit";
     rev = "PACKAGEKIT_${lib.replaceStrings ["."] ["_"] version}";
-    sha256 = "150mpar7bhlvwfpwsr6zrjn3yggvklzr6nlhk0shaxnrfkfxvvb6";
+    sha256 = "076rrczmyhapj87pxqldsar5pbz4mid6cm9l1n91zh2q403chdkb";
   };
 
-  buildInputs = [ glib polkit systemd python gobjectIntrospection vala_0_23 ]
+  buildInputs = [ glib polkit systemd python gobjectIntrospection vala_0_38 ]
                   ++ lib.optional enableBashCompletion bash-completion;
   propagatedBuildInputs = [ sqlite nix boost ];
   nativeBuildInputs = [ intltool pkgconfig autoreconfHook autoconf-archive gtk_doc ];

pkgs/tools/security/browserpass/default.nix

···
 
 buildGoPackage rec {
   name = "browserpass-${version}";
-  version = "1.0.6";
+  version = "2.0.7";
 
   goPackagePath = "github.com/dannyvankooten/browserpass";
 
+  goDeps = ./deps.nix;
+
   src = fetchFromGitHub {
     repo = "browserpass";
     owner = "dannyvankooten";
     rev = version;
-    sha256 = "07wkvwb9klzxnlrm9a07kxzj3skpy0lymc9ijr8ykfbz6l0bpbqy";
+    sha256 = "1dbp5za5qh6xmgh3w2cx5fbw13mh1szgj2y7ilmq0jh2ik09fbnd";
   };
 
   postInstall = ''

pkgs/tools/security/browserpass/deps.nix

···
+# This file was generated by https://github.com/kamilchm/go2nix v1.2.1
+[
+  {
+    goPackagePath = "github.com/gokyle/twofactor";
+    fetch = {
+      type = "git";
+      url = "https://github.com/gokyle/twofactor";
+      rev = "eaad1884d40f9cabff98a57a524c17afd00c9fe7";
+      sha256 = "07kvga6f2b56kpy52a3xk16garvlqz950s350dax97x7cayba95g";
+    };
+  }
+  {
+    goPackagePath = "github.com/mattn/go-zglob";
+    fetch = {
+      type = "git";
+      url = "https://github.com/mattn/go-zglob";
+      rev = "4b74c24375b3b1ee226867156e01996f4e19a8d6";
+      sha256 = "1qc502an4q3wgvrd9zw6zprgm28d90d2f98bdamdf4js03jj22xn";
+    };
+  }
+  {
+    goPackagePath = "rsc.io/qr";
+    fetch = {
+      type = "git";
+      url = "https://github.com/rsc/qr";
+      rev = "48b2ede4844e13f1a2b7ce4d2529c9af7e359fc5";
+      sha256 = "1npxy32glnkvsp0871972jzjzgkwaqmbv6jsj9wgqsa1s2jr004p";
+    };
+  }
+]

pkgs/tools/security/masscan/default.nix

···
-{ stdenv, fetchFromGitHub, libpcap }:
+{ stdenv, fetchFromGitHub, makeWrapper, libpcap }:
 
 stdenv.mkDerivation rec {
   name = "masscan-${version}";
-  version = "2016-11-03";
+  version = "1.0.4";
 
   src = fetchFromGitHub {
     owner  = "robertdavidgraham";
     repo   = "masscan";
-    rev    = "dc88677a11dc3d9a5f6aa55cc1377bc17dba1496";
-    sha256 = "1mdjqkn4gnbwr5nci6i6xn7qzkjgq7dx37fzd6gghv87xgw7cdbg";
+    rev    = "39061a5e9ef158dde1e6618f6fbf379739934a73";
+    sha256 = "0mjvwh4i0ncsa3ywavw2s55v5bfv7pyga028c8m8xfash9764wwf";
   };
 
-  buildInputs = [ libpcap ];
+  buildInputs = [ makeWrapper ];
 
   makeFlags = [ "PREFIX=$(out)" "CC=cc" "-j" ];
 
···
     cp -t $out/share/doc/masscan doc/algorithm.js doc/howto-afl.md doc/bot.hml
     cp doc/masscan.8 $out/share/man/man8/masscan.8
     cp LICENSE $out/share/licenses/masscan/LICENSE
+
+    wrapProgram $out/bin/masscan --prefix LD_LIBRARY_PATH : "${libpcap}/lib"
   '';
 
   meta = with stdenv.lib; {
     description = "Fast scan of the Internet";
     homepage    = https://github.com/robertdavidgraham/masscan;
     license     = licenses.agpl3;
-    platforms   = with platforms; allBut darwin;
+    platforms   = platforms.unix;
     maintainers = with maintainers; [ rnhmjoj ];
   };
 }

pkgs/tools/security/nsjail/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "nsjail-${version}";
-  version = "2.1";
+  version = "2.2";
 
   src = fetchFromGitHub {
     owner           = "google";
     repo            = "nsjail";
     rev             = version;
     fetchSubmodules = true;
-    sha256          = "1wkhy86d0vgzngdvv593yhcghjh63chb8s67v891zll6bwgwg5h2";
+    sha256          = "11323j5wd02nm8ibvzbzq7dla70bmcldc71lv5bpk4x7h64ai14v";
   };
 
   nativeBuildInputs = [ autoconf libtool pkgconfig ];
   buildInputs = [ bison flex libnl protobuf protobufc ];
+  enableParallelBuilding = true;
 
   installPhase = ''
-    mkdir -p $out/bin
-    cp nsjail $out/bin
+    mkdir -p $out/bin $out/share/man/man1
+    install nsjail $out/bin/
+    install nsjail.1 $out/share/man/man1/
   '';
 
   meta = with stdenv.lib; {
     description = "A light-weight process isolation tool, making use of Linux namespaces and seccomp-bpf syscall filters";
     homepage    = http://nsjail.com/;
-    license     = licenses.apsl20;
-    maintainers = [ maintainers.bosu ];
+    license     = licenses.asl20;
+    maintainers = with maintainers; [ bosu c0bw3b ];
     platforms   = platforms.linux;
   };
 }

pkgs/tools/security/pgpdump/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ stdenv, fetchFromGitHub
+, supportCompressedPackets ? true, zlib, bzip2
+}:
 
 stdenv.mkDerivation rec {
   name = "pgpdump-${version}";
···
     rev = "v${version}";
     sha256 = "1ip7q5sgh3nwdqbrzpp6sllkls5kma98kns53yspw1830xi1n8xc";
   };
+
+  buildInputs = stdenv.lib.optionals supportCompressedPackets [ zlib bzip2 ];
 
   meta = with stdenv.lib; {
     description = "A PGP packet visualizer";

pkgs/tools/security/sshguard/default.nix

···
 { stdenv, fetchurl, autoreconfHook, yacc, flex}:
 
-
 stdenv.mkDerivation rec {
-  version = "2.0.0";
+  version = "2.1.0";
   name = "sshguard-${version}";
 
   src = fetchurl {
-    url = "mirror://sourceforge/sshguard/sshguard-2.0.0.tar.gz";
-    sha256 = "e87c6c4a6dddf06f440ea76464eb6197869c0293f0a60ffa51f8a6a0d7b0cb06";
+    url = "mirror://sourceforge/sshguard/${name}.tar.gz";
+    sha256 = "12h2rx40lf3p3kgazmgakkgajjk2d3sdvr2f73ghi15d6i42l991";
   };
 
   doCheck = true;
···
   nativeBuildInputs = [ autoreconfHook yacc flex ];
 
   configureFlags = [ "--sysconfdir=/etc" ];
-
-  patches = [ ./0001-Remove-the-unnecessary-from-ipset-cmds.patch ];
 
   meta = with stdenv.lib; {
     description = "SSHGuard protects hosts from brute-force attacks";

pkgs/top-level/all-packages.nix

···
 
   dispad = callPackage ../tools/X11/dispad { };
 
+  dump1090 = callPackage ../applications/misc/dump1090 { };
+
   vsenv = callPackage ../build-support/vsenv {
     vs = vs90wrapper;
   };
···
   };
 
   fetchRepoProject = callPackage ../build-support/fetchrepoproject { };
+
+  fetchipfs = import ../build-support/fetchipfs {
+    inherit curl stdenv;
+  };
 
   # fetchurlBoot is used for curl and its dependencies in order to
   # prevent a cyclic dependency (curl depends on curl.tar.bz2,
···
   };
 
 
-  # ihaskell = callPackage ../development/tools/haskell/ihaskell/wrapper.nix {
-  #   inherit (haskellPackages) ihaskell ghcWithPackages;
+  ihaskell = callPackage ../development/tools/haskell/ihaskell/wrapper.nix {
+    inherit (haskellPackages) ihaskell ghcWithPackages;
 
-  #   ipython = python3.buildEnv.override {
-  #     extraLibs = with python3Packages; [ ipython ipykernel jupyter_client notebook ];
-  #   };
+    jupyter = python3.withPackages (ps: [ ps.jupyter ps.notebook ]);
 
-  #   packages = config.ihaskell.packages or (self: []);
-  # };
+    packages = config.ihaskell.packages or (self: []);
+  };
 
   imapproxy = callPackage ../tools/networking/imapproxy { };
 
···
   namazu = callPackage ../tools/text/namazu { };
 
   nasty = callPackage ../tools/security/nasty { };
+
+  nat-traverse = callPackage ../tools/networking/nat-traverse { };
 
   nawk = callPackage ../tools/text/nawk { };
 
···
 
   sbclBootstrap = callPackage ../development/compilers/sbcl/bootstrap.nix {};
   sbcl = callPackage ../development/compilers/sbcl {};
-  # For Maxima
-  sbcl_1_3_12 = callPackage ../development/compilers/sbcl/1.3.12.nix { };
-  # For ACL2
-  sbcl_1_2_0 = callPackage ../development/compilers/sbcl/1.2.0.nix {
-    clisp = clisp;
-  };
 
   scala_2_9 = callPackage ../development/compilers/scala/2.9.nix { };
   scala_2_10 = callPackage ../development/compilers/scala/2.10.nix { };
···
 
   ### DEVELOPMENT / INTERPRETERS
 
-  acl2 = callPackage ../development/interpreters/acl2 {
-    sbcl = sbcl_1_2_0;
-  };
+  acl2 = callPackage ../development/interpreters/acl2 { };
 
   angelscript = callPackage ../development/interpreters/angelscript {};
 
···
   spidermonkey_17 = callPackage ../development/interpreters/spidermonkey/17.nix { };
   spidermonkey_31 = callPackage ../development/interpreters/spidermonkey/31.nix { };
   spidermonkey_38 = callPackage ../development/interpreters/spidermonkey/38.nix { };
+  spidermonkey_52 = callPackage ../development/interpreters/spidermonkey/52.nix { };
   spidermonkey = spidermonkey_31;
 
   ssm-agent = callPackage ../applications/networking/cluster/ssm-agent { };
···
 
   obuild = callPackage ../development/tools/ocaml/obuild { };
 
-  omake = callPackage ../development/tools/ocaml/omake {
-    inherit (ocamlPackages_4_02) ocaml;
-  };
+  omake = callPackage ../development/tools/ocaml/omake { };
 
   inherit (ocamlPackages) omake_rc1;
 
···
 
   vmime = callPackage ../development/libraries/vmime { };
 
+  vrb = callPackage ../development/libraries/vrb { };
+
   vrpn = callPackage ../development/libraries/vrpn { };
 
   vsqlite = callPackage ../development/libraries/vsqlite { };
···
     kernelPatches =
       [ kernelPatches.bridge_stp_helper
         kernelPatches.p9_fixes
-        kernelPatches.cpu-cgroup-v2."4.4"
+        kernelPatches.cpu-cgroup-v2."4.9"
+        kernelPatches.modinst_arg_list_too_long
       ]
       ++ lib.optionals ((platform.kernelArch or null) == "mips")
       [ kernelPatches.mips_fpureg_emu
···
 
   tunctl = callPackage ../os-specific/linux/tunctl { };
 
-  # TODO(dezgeg): either refactor & use ubootTools directly, or remove completely
-  ubootChooser = name: ubootTools;
-
   # Upstream U-Boots:
   inherit (callPackage ../misc/uboot {})
     buildUBoot
···
   };
 
   adobe-reader = callPackage_i686 ../applications/misc/adobe-reader { };
+
+  masterpdfeditor = libsForQt5.callPackage ../applications/misc/masterpdfeditor { };
 
   aeolus = callPackage ../applications/audio/aeolus { };
 
···
 
   ht = callPackage ../applications/editors/ht { };
 
+  hubstaff = callPackage ../applications/misc/hubstaff { };
+
   hue-cli = callPackage ../tools/networking/hue-cli { };
 
   hugin = callPackage ../applications/graphics/hugin {
···
     inherit (gnome3) libpeas gsettings_desktop_schemas dconf;
   };
 
+  lightworks = callPackage ../applications/video/lightworks { };
+
   lingot = callPackage ../applications/audio/lingot {
     inherit (gnome2) libglade;
   };
···
 
   quiterss = libsForQt5.callPackage ../applications/networking/newsreaders/quiterss {};
 
-  quodlibet-without-gst-plugins = callPackage ../applications/audio/quodlibet { };
+  falkon = libsForQt5.callPackage ../applications/networking/browsers/falkon { };
 
   quodlibet = callPackage ../applications/audio/quodlibet {
-    withGstPlugins = true;
-    gst-plugins-bad = null;
+    keybinder3 = null;
+    libmodplug = null;
+    kakasi = null;
+    libappindicator-gtk3 = null;
+  };
+
+  quodlibet-without-gst-plugins = quodlibet.override {
+    withGstPlugins = false;
+    tag = "-without-gst-plugins";
+  };
+
+  quodlibet-xine = quodlibet.override { xineBackend = true; tag = "-xine"; };
+
+  quodlibet-full = callPackage ../applications/audio/quodlibet {
+    inherit (gnome2) gtksourceview;
+    withDbusPython = true;
+    withPyInotify = true;
+    withMusicBrainzNgs = true;
+    withPahoMqtt = true;
+    keybinder3 = keybinder3;
+    libmodplug = libmodplug;
+    kakasi = kakasi;
+    webkitgtk = webkitgtk24x-gtk3;
+    libappindicator-gtk3 = libappindicator-gtk3;
+    tag = "-full";
   };
 
-  falkon = libsForQt5.callPackage ../applications/networking/browsers/falkon { };
+  quodlibet-xine-full = quodlibet-full.override { xineBackend = true; tag = "-xine-full"; };
 
   qutebrowser = libsForQt5.callPackage ../applications/networking/browsers/qutebrowser {
     inherit (python3Packages) buildPythonApplication pyqt5 jinja2 pygments pyyaml pypeg2 cssutils pyopengl attrs;
···
 
   stella = callPackage ../misc/emulators/stella { };
 
-  statsd = callPackage ../tools/networking/statsd {
-    nodejs = nodejs-4_x;
-  };
+  statsd = nodePackages.statsd;
 
   linuxstopmotion = callPackage ../applications/video/linuxstopmotion { };
 
···
 
   tint2 = callPackage ../applications/misc/tint2 { };
 
+  tixati = callPackage ../applications/networking/p2p/tixati { };
+
   tkcvs = callPackage ../applications/version-management/tkcvs { };
 
   tla = callPackage ../applications/version-management/arch { };
···
 
   sdlmame = callPackage ../games/sdlmame { };
 
+  service-wrapper = callPackage ../os-specific/linux/service-wrapper { };
+
   sgtpuzzles = callPackage (callPackage ../games/sgt-puzzles) { };
 
   sienna = callPackage ../games/sienna { love = love_0_10; };
···
 
   ultrastar-manager = libsForQt5.callPackage ../tools/misc/ultrastar-manager { };
 
-  ultrastardx = callPackage ../games/ultrastardx/default.nix { };
+  ultrastardx = callPackage ../games/ultrastardx/default.nix {
+    ffmpeg = ffmpeg_2;
+  };
 
   unnethack = callPackage ../games/unnethack { };
 
···
     coqPackages = self;
 
     autosubst = callPackage ../development/coq-modules/autosubst {};
+    bignums = callPackage ../development/coq-modules/bignums {};
     coq-ext-lib = callPackage ../development/coq-modules/coq-ext-lib {};
     coquelicot = callPackage ../development/coq-modules/coquelicot {};
     dpdgraph = callPackage ../development/coq-modules/dpdgraph {};
···
   xmagnify = callPackage ../tools/X11/xmagnify { };
 
   xosd = callPackage ../misc/xosd { };
+
+  xosview2 = callPackage ../tools/X11/xosview2 { };
 
   xpad = callPackage ../applications/misc/xpad {
     inherit (gnome3) gtksourceview;

pkgs/top-level/haskell-packages.nix

···
       sphinx = pkgs.python3Packages.sphinx;
       selfPkgs = packages.ghc821;
     };
+    ghc822 = callPackage ../development/compilers/ghc/8.2.2.nix rec {
+      bootPkgs = packages.ghc802;
+      inherit (bootPkgs) hscolour alex happy;
+      inherit buildPlatform targetPlatform;
+      sphinx = pkgs.python3Packages.sphinx;
+      selfPkgs = packages.ghc822;
+    };
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix rec {
       bootPkgs = packages.ghc802;
       inherit (bootPkgs) alex happy;
···
     };
     ghc821 = callPackage ../development/haskell-modules {
       ghc = compiler.ghc821;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };
+    };
+    ghc822 = callPackage ../development/haskell-modules {
+      ghc = compiler.ghc822;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };
     };
     ghcHEAD = callPackage ../development/haskell-modules {

pkgs/top-level/ocaml-packages.nix

···
     janePackage = callPackage ../development/ocaml-modules/janestreet/janePackage.nix {};
 
     janeStreet = import ../development/ocaml-modules/janestreet {
-      inherit lib janePackage ocaml ocamlbuild ctypes cryptokit magic-mime;
+      inherit lib janePackage ocaml ocamlbuild ctypes cryptokit magic-mime num;
       inherit ocaml-migrate-parsetree octavius ounit ppx_deriving re zarith;
       inherit (pkgs) stdenv openssl;
     };

pkgs/top-level/python-packages.nix

···
 
   aenum = callPackage ../development/python-modules/aenum { };
 
+  affinity = callPackage ../development/python-modules/affinity { };
+
   agate = callPackage ../development/python-modules/agate { };
 
   agate-dbf = callPackage ../development/python-modules/agate-dbf { };
···
   # version of nixpart.
   nixpart0 = callPackage ../tools/filesystems/nixpart/0.4 { };
 
-  nltk = callPackage ../development/python-modules/nltk.nix { };
+  nltk = callPackage ../development/python-modules/nltk { };
 
   ntlm-auth = callPackage ../development/python-modules/ntlm-auth { };
 
···
 
   Pmw = callPackage ../development/python-modules/Pmw { };
 
-  pyaes = callPackage ../development/python-modules/pyaes.nix { };
+  pyaes = callPackage ../development/python-modules/pyaes { };
 
   pyatspi = if isPy3k then callPackage ../development/python-modules/pyatspi { } else throw "pyatspi not supported for interpreter ${python.executable}";
 
···
   PyChromecast = callPackage ../development/python-modules/pychromecast { };
 
   pyexiv2 = if (!isPy3k) then callPackage ../development/python-modules/pyexiv2 {} else throw "pyexiv2 not supported for interpreter ${python.executable}";
+
+  py3exiv2 = callPackage ../development/python-modules/py3exiv2 { };
 
   pygame = callPackage ../development/python-modules/pygame { };
 
···
 
   cram = callPackage ../development/python-modules/cram { };
 
-  csscompressor = callPackage ../development/python-modules/csscompressor.nix {};
+  csscompressor = callPackage ../development/python-modules/csscompressor {};
 
   csvkit =  callPackage ../development/python-modules/csvkit { };
 
···
     };
   };
 
-  bcrypt = callPackage ../development/python-modules/bcrypt.nix { };
+  bcrypt = callPackage ../development/python-modules/bcrypt { };
 
   cffi = callPackage ../development/python-modules/cffi { };
 
···
     };
   };
 
-  pytest-pep257 = callPackage ../development/python-modules/pytest-pep257.nix { };
+  pytest-pep257 = callPackage ../development/python-modules/pytest-pep257 { };
 
   pytest-raisesregexp = buildPythonPackage rec {
     name = "pytest-raisesregexp-${version}";
···
 
   dns = callPackage ../development/python-modules/dns { };
 
-  docker = callPackage ../development/python-modules/docker.nix {};
+  docker = callPackage ../development/python-modules/docker {};
 
   dockerpty = buildPythonPackage rec {
     name = "dockerpty-0.4.1";
···
     };
   };
 
-  ds4drv = callPackage ../development/python-modules/ds4drv.nix {
+  ds4drv = callPackage ../development/python-modules/ds4drv {
     inherit (pkgs) fetchFromGitHub bluez;
   };
 
···
     propagatedBuildInputs = with self; [ paramiko pycrypto ];
     buildInputs = with self; [ fudge_9 nose ];
   };
+
+  faulthandler = if ! isPy3k
+    then callPackage ../development/python-modules/faulthandler {}
+    else throw "faulthandler is built into ${python.executable}";
 
   fedpkg = callPackage ../development/python-modules/fedpkg { };
 
···
   });
 
 
-  htmlmin = callPackage ../development/python-modules/htmlmin.nix {};
+  htmlmin = callPackage ../development/python-modules/htmlmin {};
 
   httpauth = buildPythonPackage rec {
     version = "0.3";
···
 
   django_extensions = callPackage ../development/python-modules/django-extensions { };
 
-  django_guardian = callPackage ../development/python-modules/django_guardian.nix { };
+  django_guardian = callPackage ../development/python-modules/django_guardian { };
 
   django-ipware = callPackage ../development/python-modules/django-ipware { };
 
···
 
   django_tagging = callPackage ../development/python-modules/django_tagging { };
 
-  django_tagging_0_4_3 = self.django_tagging.overrideAttrs (attrs: rec {
+  django_tagging_0_4_3 = if
+       self.django != self.django_1_8
+  then throw "django_tagging_0_4_3 should be build with django_1_8"
+  else (callPackage ../development/python-modules/django_tagging {}).overrideAttrs (attrs: rec {
     name = "django-tagging-0.4.3";
 
     src = pkgs.fetchurl {
       url = "mirror://pypi/d/django-tagging/${name}.tar.gz";
       sha256 = "0617azpmp6jpg3d88v2ir97qrc9aqcs2s9gyvv9bgf2cp55khxhs";
     };
-    propagatedBuildInputs = with self; [ django_1_8 ];
+    propagatedBuildInputs = with self; [ django ];
   });
 
   django_classytags = buildPythonPackage rec {
···
     };
   };
 
-  dulwich = callPackage ../development/python-modules/dulwich.nix {
+  dulwich = callPackage ../development/python-modules/dulwich {
     inherit (pkgs) git glibcLocales;
   };
 
···
     };
   };
 
-  docker_compose = callPackage ../development/python-modules/docker_compose.nix {};
+  docker_compose = callPackage ../development/python-modules/docker_compose {};
 
   fdroidserver = buildPythonPackage rec {
     version = "2016-05-31";
···
 
   flask-cors = callPackage ../development/python-modules/flask-cors { };
 
-  flask_elastic = callPackage ../development/python-modules/flask-elastic.nix { };
+  flask_elastic = callPackage ../development/python-modules/flask-elastic { };
 
-  flask_login = callPackage ../development/python-modules/flask-login.nix { };
+  flask_login = callPackage ../development/python-modules/flask-login { };
 
-  flask_ldap_login = callPackage ../development/python-modules/flask-ldap-login.nix { };
+  flask_ldap_login = callPackage ../development/python-modules/flask-ldap-login { };
 
   flask_mail = callPackage ../development/python-modules/flask-mail { };
 
···
 
   flask_migrate = callPackage ../development/python-modules/flask-migrate { };
 
-  flask_oauthlib = callPackage ../development/python-modules/flask-oauthlib.nix { };
+  flask_oauthlib = callPackage ../development/python-modules/flask-oauthlib { };
 
   flask_principal = buildPythonPackage rec {
     name = "Flask-Principal-${version}";
···
     };
   };
 
-  flask_testing = callPackage ../development/python-modules/flask-testing.nix { };
+  flask_testing = callPackage ../development/python-modules/flask-testing { };
 
-  flask_wtf = callPackage ../development/python-modules/flask-wtf.nix { };
+  flask_wtf = callPackage ../development/python-modules/flask-wtf { };
 
   wtforms = buildPythonPackage rec {
     version = "2.1";
···
 
   gflags = callPackage ../development/python-modules/gflags { };
 
-  ghdiff = callPackage ../development/python-modules/ghdiff.nix { };
+  ghdiff = callPackage ../development/python-modules/ghdiff { };
 
   gipc = buildPythonPackage rec {
     name = "gipc-0.5.0";
···
 
   rebulk = callPackage ../development/python-modules/rebulk { };
 
-  gunicorn = callPackage ../development/python-modules/gunicorn.nix { };
+  gunicorn = callPackage ../development/python-modules/gunicorn { };
 
   hawkauthlib = buildPythonPackage rec {
     name = "hawkauthlib-${version}";
···
     propagatedBuildInputs = with self; [ requests ];
   };
 
-  hypothesis = callPackage ../development/python-modules/hypothesis.nix { };
+  hypothesis = callPackage ../development/python-modules/hypothesis { };
 
   colored = buildPythonPackage rec {
     name = "colored-${version}";
···
     };
   };
 
-  jabberbot = callPackage ../development/python-modules/jabberbot.nix {};
+  jabberbot = callPackage ../development/python-modules/jabberbot {};
 
   jedi = callPackage ../development/python-modules/jedi { };
 
···
     };
   };
 
-  pep257 = callPackage ../development/python-modules/pep257.nix { };
+  pep257 = callPackage ../development/python-modules/pep257 { };
 
   percol = buildPythonPackage rec {
     name = "percol-${version}";
···
 
   });
 
-  protobuf = callPackage ../development/python-modules/protobuf.nix {
+  protobuf = callPackage ../development/python-modules/protobuf {
     disabled = isPyPy;
     doCheck = !isPy3k;
     protobuf = pkgs.protobuf;
   };
 
-  protobuf3_1 = callPackage ../development/python-modules/protobuf.nix {
+  protobuf3_1 = callPackage ../development/python-modules/protobuf {
     disabled = isPyPy;
     doCheck = !isPy3k;
     protobuf = pkgs.protobuf3_1;
···
     };
   };
 
+  pyobjc = if stdenv.isDarwin
+    then callPackage ../development/python-modules/pyobjc {}
+    else throw "pyobjc can only be built on Mac OS";
+
   pyodbc = callPackage ../development/python-modules/pyodbc { };
 
   pyocr = callPackage ../development/python-modules/pyocr { };
···
     buildInputs = with self; [ pyasn1 pycrypto ];
   };
 
-  pyudev = callPackage ../development/python-modules/pyudev.nix {
+  pyudev = callPackage ../development/python-modules/pyudev {
     inherit (pkgs) fetchurl systemd;
   };
 
···
     };
   });
 
-  ldap = callPackage ../development/python-modules/ldap.nix {
+  ldap = callPackage ../development/python-modules/ldap {
     inherit (pkgs) openldap cyrus_sasl openssl;
   };
 
···
     doCheck = false;
   };
 
-  rackspace-novaclient = callPackage ../development/python-modules/rackspace-novaclient.nix { };
+  rackspace-novaclient = callPackage ../development/python-modules/rackspace-novaclient { };
 
-  pyrax = callPackage ../development/python-modules/pyrax.nix {
+  pyrax = callPackage ../development/python-modules/pyrax {
     glibcLocales = pkgs.glibcLocales;
   };
 
···
 
   requests_ntlm = callPackage ../development/python-modules/requests_ntlm { };
 
-  requests_oauthlib = callPackage ../development/python-modules/requests-oauthlib.nix { };
+  requests_oauthlib = callPackage ../development/python-modules/requests-oauthlib { };
 
   requests-toolbelt = callPackage ../development/python-modules/requests-toolbelt { };
   requests_toolbelt = self.requests-toolbelt; # Old attr, 2017-09-26
···
   };
 
 
-  six = buildPythonPackage rec {
-    name = "six-1.10.0";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/s/six/${name}.tar.gz";
-      sha256 = "0snmb8xffb3vsma0z67i0h0w2g2dy0p3gsgh9gi4i0kgc5l8spqh";
-    };
-
-    buildInputs = with self; [ pytest ];
-
-    checkPhase = ''
-      py.test test_six.py
-    '';
-
-    meta = {
-      description = "A Python 2 and 3 compatibility library";
-      homepage = http://pypi.python.org/pypi/six/;
-    };
-  };
+  six = callPackage ../development/python-modules/six { };
 
 
   skype4py = buildPythonPackage (rec {
···
     };
   };
 
-  graphite_web = buildPythonPackage rec {
+  graphite_web = if
+          self.django != self.django_1_8
+       || self.django_tagging != self.django_tagging_0_4_3
+  then throw "graphite_web should be build with django_1_8 and django_tagging_0_4_3"
+  else buildPythonPackage rec {
     name = "graphite-web-${version}";
     disabled = isPy3k;
     version = graphiteVersion;
···
     };
 
     propagatedBuildInputs = with self; [
-      django_1_8 django_tagging_0_4_3 whisper pycairo cairocffi
+      django django_tagging whisper pycairo cairocffi
       ldap memcached pytz urllib3 scandir
     ];
 
···
     };
   };
 
-  markdown2 = callPackage ../development/python-modules/markdown2.nix { };
+  markdown2 = callPackage ../development/python-modules/markdown2 { };
 
   evernote = buildPythonPackage rec {
     name = "evernote-${version}";