webdiff 1.2.0__tar.gz → 1.3.0__tar.gz

{webdiff-1.2.0 → webdiff-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webdiff
-Version: 1.2.0
+Version: 1.3.0
 Summary: Two-column web-based git difftool
 Home-page: https://github.com/danvk/webdiff/
 License: Apache-2.0
@@ -18,10 +18,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Version Control
-Requires-Dist: PyGithub (==2.3.0)
+Requires-Dist: PyGithub (>=2.3.0,<3.0.0)
+Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
 Requires-Dist: binaryornot
 Requires-Dist: pillow
-Requires-Dist: unidiff (==0.7.4)
+Requires-Dist: unidiff (>=0.7.4,<0.8.0)
 Project-URL: Repository, https://github.com/danvk/webdiff/
 Description-Content-Type: text/markdown
 
@@ -55,6 +56,10 @@ Features include:
 
     pip install webdiff
 
+or using [pipx]:
+
+    pipx install webdiff
+
 or, if you prefer [Homebrew]:
 
     brew install danvk/webdiff/webdiff
@@ -135,8 +140,7 @@ Options are:
     poetry install
     cd ts
     yarn
-    # see https://github.com/webpack/webpack/issues/14532
-    NODE_OPTIONS=--openssl-legacy-provider webpack
+    yarn build
 
 Then from the root directory:
 
@@ -168,7 +172,7 @@ To iterate on the PyPI package, run:
 
     pip3 uninstall webdiff
     poetry build
-    pip3 install dist/webdiff-?.?.?.tar.gz
+    pip3 install dist/webdiff-(latest).tar.gz
 
 To publish to pypitest:
 
@@ -179,6 +183,8 @@ And to the real pypi:
 
     poetry publish
 
+You can publish pre-release versions to pypi by adding "bN" to the version number.
+
 See [pypirc][] and [poetry][] docs for details on setting up tokens for pypi.
 
 Publication checklist. Do these from _outside_ the webdiff directory:
@@ -208,7 +214,10 @@ When you run `git webdiff (args)`, it runs:
 
 This tells `git` to set up two directories and invoke `webdiff leftdir rightdir`.
 
-There's one complication involving symlinks. `git difftool -d` may fill one of the sides (typically the right) with symlinks. This is faster than copying files, but unfortunately `git diff --no-index` does not resolve these symlinks. To make this work, if a directory contains symlinks, webdiff makes a copy of it before diffing. For file diffs, it resolves the symlink before passing it to `git diff --no-index`. The upshot is that you can run `git webdiff`, edit a file, reload the browser window and see the changes.
+There are two wrinkles here:
+
+- `git difftool -d` may fill one of the sides (typically the right) with symlinks. This is faster than copying files, but unfortunately `git diff --no-index` does not resolve these symlinks. To make this work, if a directory contains symlinks, webdiff makes a copy of it before diffing. For file diffs, it resolves the symlink before passing it to `git diff --no-index`. The upshot is that you can run `git webdiff`, edit a file, reload the browser window and see the changes.
+- `git difftool` cleans up its temporary directories when the main webdiff process terminates. Since webdiff detaches to give you back your terminal, it has to make another copy of the directories (this time without resolving symlinks) to make sure they're still there for the child process.
 
 [pypirc]: https://packaging.python.org/specifications/pypirc/
 [Homebrew]: https://brew.sh/
@@ -216,4 +225,5 @@ There's one complication involving symlinks. `git difftool -d` may fill one of t
 [git config]: https://git-scm.com/docs/git-config
 [themes]: http://example.com
 [poetry]: https://python-poetry.org/docs/repositories/#publishable-repositories
+[pipx]: https://pipx.pypa.io/stable/
 

{webdiff-1.2.0 → webdiff-1.3.0}/README.md

@@ -28,6 +28,10 @@ Features include:
 
     pip install webdiff
 
+or using [pipx]:
+
+    pipx install webdiff
+
 or, if you prefer [Homebrew]:
 
     brew install danvk/webdiff/webdiff
@@ -108,8 +112,7 @@ Options are:
     poetry install
     cd ts
     yarn
-    # see https://github.com/webpack/webpack/issues/14532
-    NODE_OPTIONS=--openssl-legacy-provider webpack
+    yarn build
 
 Then from the root directory:
 
@@ -141,7 +144,7 @@ To iterate on the PyPI package, run:
 
     pip3 uninstall webdiff
     poetry build
-    pip3 install dist/webdiff-?.?.?.tar.gz
+    pip3 install dist/webdiff-(latest).tar.gz
 
 To publish to pypitest:
 
@@ -152,6 +155,8 @@ And to the real pypi:
 
     poetry publish
 
+You can publish pre-release versions to pypi by adding "bN" to the version number.
+
 See [pypirc][] and [poetry][] docs for details on setting up tokens for pypi.
 
 Publication checklist. Do these from _outside_ the webdiff directory:
@@ -181,7 +186,10 @@ When you run `git webdiff (args)`, it runs:
 
 This tells `git` to set up two directories and invoke `webdiff leftdir rightdir`.
 
-There's one complication involving symlinks. `git difftool -d` may fill one of the sides (typically the right) with symlinks. This is faster than copying files, but unfortunately `git diff --no-index` does not resolve these symlinks. To make this work, if a directory contains symlinks, webdiff makes a copy of it before diffing. For file diffs, it resolves the symlink before passing it to `git diff --no-index`. The upshot is that you can run `git webdiff`, edit a file, reload the browser window and see the changes.
+There are two wrinkles here:
+
+- `git difftool -d` may fill one of the sides (typically the right) with symlinks. This is faster than copying files, but unfortunately `git diff --no-index` does not resolve these symlinks. To make this work, if a directory contains symlinks, webdiff makes a copy of it before diffing. For file diffs, it resolves the symlink before passing it to `git diff --no-index`. The upshot is that you can run `git webdiff`, edit a file, reload the browser window and see the changes.
+- `git difftool` cleans up its temporary directories when the main webdiff process terminates. Since webdiff detaches to give you back your terminal, it has to make another copy of the directories (this time without resolving symlinks) to make sure they're still there for the child process.
 
 [pypirc]: https://packaging.python.org/specifications/pypirc/
 [Homebrew]: https://brew.sh/
@@ -189,3 +197,4 @@ There's one complication involving symlinks. `git difftool -d` may fill one of t
 [git config]: https://git-scm.com/docs/git-config
 [themes]: http://example.com
 [poetry]: https://python-poetry.org/docs/repositories/#publishable-repositories
+[pipx]: https://pipx.pypa.io/stable/

{webdiff-1.2.0 → webdiff-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "webdiff"
-version = "1.2.0"
+version = "1.3.0"
 description = "Two-column web-based git difftool"
 license = "Apache-2.0"
 readme = "README.md"
@@ -28,12 +28,13 @@ include = ["webdiff/static/js/file_diff.js"]
 python = "^3.10"
 binaryornot = "*"
 pillow = "*"
-PyGithub = "2.3.0"
-unidiff = "==0.7.4"
+PyGithub = "^2.3.0"
+unidiff = "^0.7.4"
+aiohttp = "^3.9.5"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.1.3"
-ruff = "^0.4.6"
+ruff = "0.7"
 
 [tool.poetry.scripts]
 webdiff = "webdiff.app:run"

webdiff-1.3.0/webdiff/app.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python
+"""Web-based file differ.
+
+For usage, see README.md.
+"""
+
+import dataclasses
+import importlib.metadata
+import json
+import logging
+import mimetypes
+import os
+import platform
+import signal
+import socket
+import subprocess
+import sys
+import threading
+import time
+import webbrowser
+
+import aiohttp
+import aiohttp.web_request
+from aiohttp import web
+from binaryornot.check import is_binary
+
+from webdiff import argparser, diff, options, util
+from webdiff.dirdiff import make_resolved_dir
+
+VERSION = importlib.metadata.version('webdiff')
+
+
+def determine_path():
+    """Borrowed from wxglade.py"""
+    try:
+        root = __file__
+        if os.path.islink(root):
+            root = os.path.realpath(root)
+        return os.path.dirname(os.path.abspath(root))
+    except Exception as e:
+        print(f"I'm sorry, but something is wrong. Error: {e}")
+        print('There is no __file__ variable. Please contact the author.')
+        sys.exit()
+
+
+GIT_CONFIG = {}
+DIFF = None
+PORT = None
+HOSTNAME = 'localhost'
+DEBUG = os.environ.get('DEBUG')
+DEBUG_DETACH = os.environ.get('DEBUG_DETACH')
+WEBDIFF_DIR = determine_path()
+
+if DEBUG:
+    handler = logging.StreamHandler()
+    handler.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    handler.setFormatter(formatter)
+
+    for logname in ['']:
+        log = logging.getLogger(logname)
+        log.setLevel(logging.DEBUG)
+        log.addHandler(handler)
+    logging.getLogger('github').setLevel(logging.ERROR)
+    logging.getLogger('binaryornot').setLevel(logging.ERROR)
+
+
+async def handle_index(request: aiohttp.web_request.Request):
+    idx = int(request.match_info.get('idx', '0'))
+    pairs = diff.get_thin_list(DIFF)
+    with open(os.path.join(WEBDIFF_DIR, 'templates/file_diff.html'), 'r') as file:
+        html = file.read()
+        html = html.replace(
+            '{{data}}',
+            json.dumps(
+                {
+                    'idx': idx,
+                    'has_magick': util.is_imagemagick_available(),
+                    'pairs': pairs,
+                    'git_config': GIT_CONFIG,
+                },
+                indent=2,
+            ),
+        )
+        return web.Response(body=html, content_type='text/html', charset='utf-8')
+
+
+async def handle_thick(request: aiohttp.web_request.Request):
+    idx = int(request.match_info.get('idx'))
+    return web.json_response(diff.get_thick_dict(DIFF[idx]))
+
+
+async def handle_get_contents(request: aiohttp.web_request.Request):
+    side = request.match_info['side']
+    form_data = await request.post()
+    path = form_data.get('path', '')
+    if not path:
+        return web.json_response({'error': 'incomplete'}, status=400)
+    should_normalize = form_data.get('normalize_json')
+
+    idx = diff.find_diff_index(DIFF, side, path)
+    if idx is None:
+        return web.json_response({'error': 'not found'}, status=400)
+
+    d = DIFF[idx]
+    abs_path = d.a_path if side == 'a' else d.b_path
+
+    try:
+        if is_binary(abs_path):
+            size = os.path.getsize(abs_path)
+            return web.Response(text=f'Binary file ({size} bytes)')
+        else:
+            if should_normalize:
+                abs_path = util.normalize_json(abs_path)
+            return web.FileResponse(abs_path, headers={'Content-Type': 'text/plain'})
+    except Exception as e:
+        return web.json_response({'error': str(e)}, status=500)
+
+
+async def handle_diff_ops(request: aiohttp.web_request.Request):
+    idx = int(request.match_info.get('idx'))
+    payload = await request.json()
+    options = payload.get('options') or []
+    should_normalize = payload.get('normalize_json')
+    logging.debug([*payload.keys()])
+    logging.debug({**payload})
+    extra_args = GIT_CONFIG['webdiff']['extraFileDiffArgs']
+    if extra_args:
+        options += extra_args.split(' ')
+    diff_ops = [
+        dataclasses.asdict(op)
+        for op in diff.get_diff_ops(DIFF[idx], options, normalize_json=should_normalize)
+    ]
+    return web.json_response(diff_ops, status=200)
+
+
+async def handle_theme(request: aiohttp.web_request.Request):
+    theme = GIT_CONFIG['webdiff']['theme']
+    theme_dir = os.path.dirname(theme)
+    theme_file = os.path.basename(theme)
+    theme_path = os.path.join(
+        WEBDIFF_DIR, 'static/css/themes', theme_dir, theme_file + '.css'
+    )
+    return web.FileResponse(theme_path)
+
+
+async def handle_favicon(request):
+    return web.FileResponse(os.path.join(WEBDIFF_DIR, 'static/img/favicon.ico'))
+
+
+async def handle_get_image(request: aiohttp.web_request.Request):
+    side = request.match_info.get('side')
+    path = request.match_info.get('path')
+    mime_type, _ = mimetypes.guess_type(path)
+    if not mime_type or not mime_type.startswith('image/'):
+        return web.json_response({'error': 'wrong type'}, status=400)
+
+    idx = diff.find_diff_index(DIFF, side, path)
+    if idx is None:
+        return web.json_response({'error': 'not found'}, status=400)
+
+    d = DIFF[idx]
+    abs_path = d.a_path if side == 'a' else d.b_path
+    return web.FileResponse(abs_path, headers={'Content-Type': mime_type})
+
+
+async def handle_pdiff(request: aiohttp.web_request.Request):
+    idx = int(request.match_info.get('idx'))
+    d = DIFF[idx]
+    try:
+        _, pdiff_image = util.generate_pdiff_image(d.a_path, d.b_path)
+        dilated_image_path = util.generate_dilated_pdiff_image(pdiff_image)
+        return web.FileResponse(dilated_image_path)
+    except util.ImageMagickNotAvailableError:
+        return web.Response(status=501, text='ImageMagick is not available')
+    except util.ImageMagickError as e:
+        return web.Response(status=501, text=f'ImageMagick error {e}')
+
+
+async def handle_pdiff_bbox(request: aiohttp.web_request.Request):
+    idx = int(request.match_info.get('idx'))
+    d = DIFF[idx]
+    try:
+        _, pdiff_image = util.generate_pdiff_image(d.a_path, d.b_path)
+        bbox = util.get_pdiff_bbox(pdiff_image)
+        return web.json_response(bbox, status=200)
+    except util.ImageMagickNotAvailableError:
+        return web.json_response('ImageMagick is not available', status=501)
+    except util.ImageMagickError as e:
+        return web.json_response(f'ImageMagick error {e}', status=501)
+
+
+async def websocket_handler(request: aiohttp.web_request.Request):
+    ws = web.WebSocketResponse()
+    await ws.prepare(request)
+
+    async for msg in ws:
+        if msg.type == aiohttp.WSMsgType.TEXT:
+            await ws.send_str(msg.data + '/answer')
+        elif msg.type == aiohttp.WSMsgType.ERROR:
+            print('ws connection closed with exception %s' % ws.exception())
+
+    maybe_shutdown()
+    return ws
+
+
+@web.middleware
+async def request_time_middleware(request, handler):
+    note_request_time()
+    response = await handler(request)
+    return response
+
+
+app = web.Application(middlewares=[request_time_middleware])
+app.add_routes(
+    [
+        web.get('/', handle_index),
+        web.get(r'/{idx:\d+}', handle_index),
+        web.get('/favicon.ico', handle_favicon),
+        web.get('/theme.css', handle_theme),
+        web.static('/static', os.path.join(WEBDIFF_DIR, 'static')),
+        web.get(r'/thick/{idx:\d+}', handle_thick),
+        web.post(r'/{side:a|b}/get_contents', handle_get_contents),
+        web.post(r'/diff/{idx:\d+}', handle_diff_ops),
+        # Image diffs
+        web.get(r'/{side:a|b}/image/{path:.*}', handle_get_image),
+        web.get(r'/pdiff/{idx:\d+}', handle_pdiff),
+        web.get(r'/pdiffbbox/{idx:\d+}', handle_pdiff_bbox),
+        # Websocket for detecting when the tab is closed
+        web.get('/ws', websocket_handler),
+    ]
+)
+
+
+def note_request_time():
+    global LAST_REQUEST_MS
+    LAST_REQUEST_MS = time.time() * 1000
+
+
+def open_browser():
+    global PORT
+    global HOSTNAME
+    global GIT_CONFIG
+    if not os.environ.get('WEBDIFF_NO_OPEN') and GIT_CONFIG['webdiff']['openBrowser']:
+        webbrowser.open_new_tab('http://%s:%s' % (HOSTNAME, PORT))
+
+
+def usage_and_die():
+    sys.stderr.write(argparser.USAGE)
+    sys.exit(1)
+
+
+def random_port():
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.bind(('localhost', 0))
+    port = sock.getsockname()[1]
+    sock.close()
+    return port
+
+
+def pick_a_port(args, webdiff_config):
+    if 'port' in args:
+        return args['port']
+
+    env_port = os.environ.get('WEBDIFF_PORT')
+    if env_port:
+        return int(env_port)
+
+    # gitconfig
+    if webdiff_config['port'] != -1:
+        return webdiff_config['port']
+
+    return random_port()
+
+
+def run_http():
+    threading.Timer(0.1, open_browser).start()
+    web.run_app(app, host=HOSTNAME, port=PORT, print=print if DEBUG else None)
+    logging.debug('http server shut down')
+
+
+def maybe_shutdown():
+    """Wait a second for new requests, then shut down the server."""
+    last_ms = LAST_REQUEST_MS
+
+    def shutdown():
+        if LAST_REQUEST_MS <= last_ms:  # subsequent requests abort shutdown
+            logging.debug('Shutting down...')
+            signal.raise_signal(signal.SIGINT)
+        else:
+            logging.debug('Received subsequent request; shutdown aborted.')
+
+    logging.debug(
+        'Received request to shut down; waiting 500ms for subsequent requests...'
+    )
+    threading.Timer(0.5, shutdown).start()
+
+
+def run():
+    global DIFF, PORT, HOSTNAME, GIT_CONFIG
+    try:
+        parsed_args = argparser.parse(sys.argv[1:], VERSION)
+    except argparser.UsageError as e:
+        sys.stderr.write('Error: %s\n\n' % e)
+        usage_and_die()
+
+    GIT_CONFIG = options.get_config()
+    WEBDIFF_CONFIG = GIT_CONFIG['webdiff']
+    DIFF = argparser.diff_for_args(parsed_args, WEBDIFF_CONFIG)
+
+    if DEBUG:
+        sys.stderr.write('Invoked as: %s\n' % sys.argv)
+        sys.stderr.write('Args: %s\n' % parsed_args)
+        sys.stderr.write('Diff: %s\n' % DIFF)
+        sys.stderr.write('GitConfig: %s\n' % GIT_CONFIG)
+
+    PORT = pick_a_port(parsed_args, WEBDIFF_CONFIG)
+    HOSTNAME = (
+        parsed_args.get('host')
+        or os.environ.get('WEBDIFF_HOST')
+        or WEBDIFF_CONFIG['host']
+    )
+    if HOSTNAME == '<hostname>':
+        _hostname = platform.node()
+        # platform.node will return empty string if it can't find the hostname
+        if not _hostname:
+            sys.stderr.write('Warning: hostname could not be determined\n')
+        else:
+            HOSTNAME = _hostname
+
+    run_in_process = os.environ.get('WEBDIFF_RUN_IN_PROCESS') or (
+        DEBUG and not DEBUG_DETACH
+    )
+
+    if not os.environ.get('WEBDIFF_LOGGED_MESSAGE'):
+        # Printing this in the main process gives you your prompt back more cleanly.
+        print(
+            """Serving diffs on http://%s:%s
+Close the browser tab when you're done to terminate the process."""
+            % (HOSTNAME, PORT)
+        )
+        os.environ['WEBDIFF_LOGGED_MESSAGE'] = '1'
+
+    if run_in_process:
+        run_http()
+    else:
+        os.environ['WEBDIFF_RUN_IN_PROCESS'] = '1'
+        os.environ['WEBDIFF_PORT'] = str(PORT)
+        if os.environ.get('WEBDIFF_FROM_GIT_DIFFTOOL'):
+            # git difftool will clean up these directories when we detach.
+            # To make them accessible to the child process, we make a (shallow) copy.
+            assert 'dirs' in parsed_args
+            dir_a, dir_b = parsed_args['dirs']
+            copied_dir_a = make_resolved_dir(dir_a)
+            copied_dir_b = make_resolved_dir(dir_b)
+            os.environ['WEBDIFF_DIR_A'] = copied_dir_a
+            os.environ['WEBDIFF_DIR_B'] = copied_dir_b
+            logging.debug(f'Copied {dir_a} -> {copied_dir_a} before detaching')
+            logging.debug(f'Copied {dir_b} -> {copied_dir_b} before detaching')
+        subprocess.Popen((sys.executable, *sys.argv))
+
+
+if __name__ == '__main__':
+    run()

{webdiff-1.2.0 → webdiff-1.3.0}/webdiff/argparser.py

@@ -4,9 +4,7 @@ import argparse
 import os
 import re
 
-from webdiff import dirdiff
-from webdiff import githubdiff
-from webdiff import github_fetcher
+from webdiff import dirdiff, github_fetcher, githubdiff
 from webdiff.localfilediff import LocalFileDiff
 
 
@@ -81,6 +79,12 @@ def parse(args, version=None):
 
     else:
         a, b = args.dirs
+        if os.environ.get('WEBDIFF_DIR_A') and os.environ.get('WEBDIFF_DIR_B'):
+            # This happens when you run "git webdiff" and we have to make a copy of
+            # the temp directories before we detach and git difftool cleans them up.
+            a = os.environ.get('WEBDIFF_DIR_A')
+            b = os.environ.get('WEBDIFF_DIR_B')
+
         for x in (a, b):
             if not os.path.exists(x):
                 raise UsageError('"%s" does not exist' % x)

{webdiff-1.2.0 → webdiff-1.3.0}/webdiff/diff.py

@@ -29,17 +29,30 @@ def get_thin_dict(diff):
       - change type (add, delete, move, change)
       - (in the future) diffstats
     """
-    return {'a': diff.a, 'b': diff.b, 'type': diff.type, 'num_add': diff.num_add, 'num_delete': diff.num_delete}
+    return {
+        'a': diff.a,
+        'b': diff.b,
+        'type': diff.type,
+        'num_add': diff.num_add,
+        'num_delete': diff.num_delete,
+    }
 
 
 def fast_num_lines(path: str) -> int:
     # See https://stackoverflow.com/q/9629179/388951 for the idea to use a Unix command.
     # Unfortunately `wc -l` ignores the last line if there is no trailing newline. So
     # instead, see https://stackoverflow.com/a/38870057/388951
-    return int(subprocess.check_output(['grep', '-c', '', path]))
+    try:
+        return int(subprocess.check_output(['grep', '-c', '', path]))
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 1:
+            return 0  # grep -c returns an error code if there are no matches
+        raise
 
 
-def get_diff_ops(diff: LocalFileDiff, git_diff_args=None) -> List[Code]:
+def get_diff_ops(
+    diff: LocalFileDiff, git_diff_args=None, normalize_json=False
+) -> List[Code]:
     """Run git diff on the file pair and convert the results to a sequence of codes.
 
     git_diff_args is passed directly to git diff. It can be something like ['-w'] or
@@ -48,6 +61,10 @@ def get_diff_ops(diff: LocalFileDiff, git_diff_args=None) -> List[Code]:
     # git diff --no-index doesn't follow symlinks. So we help it a bit.
     a_path = os.path.realpath(diff.a_path) if diff.a_path else ''
     b_path = os.path.realpath(diff.b_path) if diff.b_path else ''
+    if normalize_json:
+        a_path = a_path and util.normalize_json(a_path)
+        b_path = b_path and util.normalize_json(b_path)
+
     if a_path and b_path:
         num_lines = fast_num_lines(b_path)
         args = (

{webdiff-1.2.0 → webdiff-1.3.0}/webdiff/dirdiff.py

@@ -1,7 +1,7 @@
 """Compute the diff between two directories on local disk."""
 
-import os
 import logging
+import os
 import shutil
 import subprocess
 import tempfile
@@ -27,7 +27,7 @@ def contains_symlinks(dir: str):
     return False
 
 
-def make_resolved_dir(dir: str) -> str:
+def make_resolved_dir(dir: str, follow_symlinks=False) -> str:
     # TODO: clean up this directory
     temp_dir = tempfile.mkdtemp(prefix='webdiff')
     for root, dirs, files in os.walk(dir):
@@ -38,7 +38,7 @@ def make_resolved_dir(dir: str) -> str:
             src_file = os.path.join(root, file_name)
             rel = os.path.relpath(src_file, dir)
             dst_file = os.path.join(temp_dir, rel)
-            shutil.copy(src_file, dst_file, follow_symlinks=True)
+            shutil.copy(src_file, dst_file, follow_symlinks=follow_symlinks)
     return temp_dir
 
 
@@ -49,11 +49,11 @@ def gitdiff(a_dir: str, b_dir: str, webdiff_config):
         cmd += ' ' + extra_args
     a_dir_nosym = a_dir
     if contains_symlinks(a_dir):
-        a_dir_nosym = make_resolved_dir(a_dir)
+        a_dir_nosym = make_resolved_dir(a_dir, follow_symlinks=True)
         logging.debug(f'Inlined symlinks in left directory {a_dir} -> {a_dir_nosym}')
     b_dir_nosym = b_dir
     if contains_symlinks(b_dir):
-        b_dir_nosym = make_resolved_dir(b_dir)
+        b_dir_nosym = make_resolved_dir(b_dir, follow_symlinks=True)
         logging.debug(f'Inlined symlinks in right directory {b_dir} -> {b_dir_nosym}')
     args = cmd.split(' ') + [a_dir_nosym, b_dir_nosym]
     logging.debug('Running git command: %s', args)

{webdiff-1.2.0 → webdiff-1.3.0}/webdiff/github_fetcher.py

@@ -6,11 +6,11 @@ This will create symlinks or clone git repos as needed.
 # Use this PR for testing to see all four types of change at once:
 # https://github.com/danvk/test-repo/pull/2/
 
-from collections import OrderedDict
 import os
 import re
 import subprocess
 import sys
+from collections import OrderedDict
 
 from github import Github, UnknownObjectException
 
@@ -138,7 +138,7 @@ def _get_github_remotes():
 
 # e.g. 'origin	git@github.com:danvk/expandable-image-grid.git (push)'
 ssh_push_re = re.compile(
-    '(?P<name>[^\s]+)\s+((?P<user>[^@]+)@)?(?P<host>[^:]+)(?::(?P<path>[^\s]+))?\s\(push\)'
+    r'(?P<name>[^\s]+)\s+((?P<user>[^@]+)@)?(?P<host>[^:]+)(?::(?P<path>[^\s]+))?\s\(push\)'
 )
 
 # e.g. 'origin	https://github.com/danvk/git-helpers.git (push)'

{webdiff-1.2.0 → webdiff-1.3.0}/webdiff/gitwebdiff.py

@@ -21,6 +21,7 @@ def run(argv=sys.argv):
             if not os.environ.get('DEBUG')
             else os.path.join(os.path.curdir, 'test.sh')
         )
+        os.environ['WEBDIFF_FROM_GIT_DIFFTOOL'] = '1'
         subprocess.call(f'git difftool -d -x {cmd}'.split(' ') + argv[1:])
     except KeyboardInterrupt:
         # Don't raise an exception to the user when sigint is received