Rename to ydiff (version 1.1)

CHANGES.rst

 Change log
 ==========
 
+Version 1.1 (2018-06-05)
+
+  - Rename from ``cdiff`` to ``ydiff`` to avoid binary name conflict on major
+    distributions, ``CDIFF_OPTIONS`` still works but will be deprepated soon
+  - New option ``--wrap`` to wrap long lines in side-by-side view
+
 Version 1.0 (2016-12-31)
 
   - Use environment variable ``CDIFF_OPTIONS`` to hold default options

LICENSE

 Software License Agreement (BSD-3 License)
 
-Copyright (c) 2013, Matthew Wang <mattwyl(@)gmail(.)com>
+Copyright (c) 2013-2018, Matt Wang <mattwyl(@)gmail(.)com>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
 
     1. Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.
-    
+
     2. Redistributions in binary form must reproduce the above copyright notice,
        this list of conditions and the following disclaimer in the documentation
        and/or other materials provided with the distribution.
 
-    3. Neither the name of cdiff nor the names of its contributors may be used
+    3. Neither the name of ydiff nor the names of its contributors may be used
        to endorse or promote products derived from this software without
        specific prior written permission.
 

Makefile

 	test test3 cov cov3 html reg reg3 profile profile3
 
 dogfood:
-	./cdiff.py
-	git diff | ./cdiff.py -s
+	./ydiff.py
+	git diff | ./ydiff.py -s
 
 lint:
 	pep8 --ignore=E203 *.py tests/*.py
 test3: lint doc-check cov3 reg3
 
 cov:
-	coverage run tests/test_cdiff.py
+	coverage run tests/test_ydiff.py
 	coverage report --show-missing
 
 cov3:
-	python3 `which coverage` run tests/test_cdiff.py
+	python3 `which coverage` run tests/test_ydiff.py
 	python3 `which coverage` report --show-missing
 
 html:
 
 clean:
 	rm -f MANIFEST profile*.tmp* .coverage
-	rm -rf build/ cdiff.egg-info/ dist/ __pycache__/ htmlcov/
+	rm -rf build/ ydiff.egg-info/ dist/ __pycache__/ htmlcov/
 
 build:
 	./setup.py build sdist
 
-dist-test:
-	./setup.py build sdist register upload -r $(TESTPYPI)
+dist-test: clean build
+	twine upload --repository-url https://test.pypi.org/legacy/ dist/*
 	rm -f ~/.pypirc
 
-dist:
-	./setup.py build sdist register upload -r $(PYPI)
+dist: clean build
+	twine upload dist/*
 	rm -f ~/.pypirc
 
 # vim:set noet ts=8 sw=8:

README.rst

-Cdiff
+Ydiff
 =====
 
-.. image:: https://travis-ci.org/ymattw/cdiff.png?branch=master
-   :target: https://travis-ci.org/ymattw/cdiff
+.. image:: https://travis-ci.org/ymattw/ydiff.png?branch=master
+   :target: https://travis-ci.org/ymattw/ydiff
    :alt: Build status
 
 Term based tool to view *colored*, *incremental* diff in a *Git/Mercurial/Svn*
-workspace or from stdin, with *side by side* and *auto pager* support. Requires
-python (>= 2.5.0) and ``less``.
+workspace or from stdin, with *side by side* (similar to ``diff -y``) and *auto
+pager* support. Requires python (>= 2.5.0) and ``less``.
 
-.. image:: https://raw.github.com/ymattw/cdiff/gh-pages/img/default.png
+.. image:: https://raw.github.com/ymattw/ydiff/gh-pages/img/default.png
    :alt: default
    :align: center
 
-.. image:: https://raw.github.com/ymattw/cdiff/gh-pages/img/side-by-side.png
+.. image:: https://raw.github.com/ymattw/ydiff/gh-pages/img/side-by-side.png
    :alt: side by side
    :align: center
    :width: 900 px
 Install with pip
 ~~~~~~~~~~~~~~~~
 
-Cdiff is already listed on `PyPI`_, you can install with ``pip`` if you have
+Ydiff is already listed on `PyPI`_, you can install with ``pip`` if you have
 the tool.
 
-.. _PyPI: http://pypi.python.org/pypi/cdiff
+.. _PyPI: http://pypi.python.org/pypi/ydiff
 
 .. code-block:: bash
 
-    pip install --upgrade cdiff
+    pip install --upgrade ydiff
 
 Install with setup.py
 ~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: bash
 
-    git clone https://github.com/ymattw/cdiff.git
-    cd cdiff
+    git clone https://github.com/ymattw/ydiff.git
+    cd ydiff
     ./setup.py install
 
 Install with Homebrew
 .. _`@bfontaine`: https://github.com/bfontaine
 .. _`@hivehand`: https://github.com/hivehand
 .. _`@nijikon`: https://github.com/nijikon
-.. _`Formula`: https://github.com/Homebrew/homebrew-core/blob/master/Formula/cdiff.rb
+.. _`Formula`: https://github.com/Homebrew/homebrew-core/blob/master/Formula/ydiff.rb
 
 .. code-block:: bash
 
-    brew install cdiff
+    brew install ydiff
 
 Download directly
 ~~~~~~~~~~~~~~~~~
 
-Just save `cdiff.py`_ to whatever directory which is in your ``$PATH``, for
+Just save `ydiff.py`_ to whatever directory which is in your ``$PATH``, for
 example, ``$HOME/bin`` is in my ``$PATH``, so I save the script there and name
-as ``cdiff``.
+as ``ydiff``.
 
-.. _`cdiff.py`: https://raw.github.com/ymattw/cdiff/master/cdiff.py
+.. _`ydiff.py`: https://raw.github.com/ymattw/ydiff/master/ydiff.py
 
 .. code-block:: bash
 
-    curl -ksSL https://raw.github.com/ymattw/cdiff/master/cdiff.py > ~/bin/cdiff
-    chmod +x ~/bin/cdiff
+    curl -ksSL https://raw.github.com/ymattw/ydiff/master/ydiff.py > ~/bin/ydiff
+    chmod +x ~/bin/ydiff
 
 Usage
 -----
 
-Type ``cdiff -h`` to show usage::
+Type ``ydiff -h`` to show usage::
 
-    $ cdiff -h
-    Usage: cdiff [options] [file|dir ...]
+    $ ydiff -h
+    Usage: ydiff [options] [file|dir ...]
 
     View colored, incremental diff in a workspace or from stdin, with side by side
     and auto pager support
 
       Note:
         Option parser will stop on first unknown option and pass them down to
-        underneath revision control. Environment variable CDIFF_OPTIONS may be
+        underneath revision control. Environment variable YDIFF_OPTIONS may be
         used to specify default options that will be placed at the beginning
         of the argument list.
 
 .. code-block:: bash
 
     cd proj-workspace
-    cdiff                         # view colored incremental diff
-    cdiff -s                      # view side by side, use default text width 80
-    cdiff -s -w 90                # use text width 90 other than default 80
-    cdiff -s -w 0                 # auto set text width based on terminal size
-    cdiff -s -w 0 --wrap          # same as before, but also wrap long lines
-    cdiff -s file1 dir2           # view modification of given files/dirs only
-    cdiff -s -w90 --wrap -- -U10  # pass '-U10' to underneath revision diff tool
-    cdiff -s -w90 --wrap -U10     # '--' is optional as it's unknown to cdiff
-    cdiff -s --cached             # show git staged diff (git diff --cached)
-    cdiff -s -r1234               # show svn diff to revision 1234
+    ydiff                         # view colored incremental diff
+    ydiff -s                      # view side by side, use default text width 80
+    ydiff -s -w 90                # use text width 90 other than default 80
+    ydiff -s -w 0                 # auto set text width based on terminal size
+    ydiff -s -w 0 --wrap          # same as before, but also wrap long lines
+    ydiff -s file1 dir2           # view modification of given files/dirs only
+    ydiff -s -w90 --wrap -- -U10  # pass '-U10' to underneath revision diff tool
+    ydiff -s -w90 --wrap -U10     # '--' is optional as it's unknown to ydiff
+    ydiff -s --cached             # show git staged diff (git diff --cached)
+    ydiff -s -r1234               # show svn diff to revision 1234
 
 Read log with changes in a *Git/Mercurial/Svn* workspace (output from e.g.
 ``git log -p``, ``svn log --diff``), note *--diff* option is new in svn 1.7.0:
 .. code-block:: bash
 
     cd proj-workspace
-    cdiff -l                    # read log along with changes
-    cdiff -ls                   # equivalent to cdiff -l -s, view side by side
-    cdiff -ls -w90 --wrap       # set text width 90 and enable wrapping as well
-    cdiff -ls file1 dir2        # see log with changes of given files/dirs only
+    ydiff -l                    # read log along with changes
+    ydiff -ls                   # equivalent to ydiff -l -s, view side by side
+    ydiff -ls -w90 --wrap       # set text width 90 and enable wrapping as well
+    ydiff -ls file1 dir2        # see log with changes of given files/dirs only
 
-Environment variable ``CDIFF_OPTIONS`` may be used to specify default options
+Environment variable ``YDIFF_OPTIONS`` may be used to specify default options
 that will be placed at the beginning of the argument list, for example:
 
 .. code-block:: bash
 
-    export CDIFF_OPTIONS='-s -w0 --wrap'
-    cdiff foo                   # equivalent to "cdiff -s -w0 --wrap foo"
+    export YDIFF_OPTIONS='-s -w0 --wrap'
+    ydiff foo                   # equivalent to "ydiff -s -w0 --wrap foo"
 
-If you feel more comfortable with a command such as ``git cdiff`` to trigger
-the cdiff command, you may symlink the executable to one named ``git-cdiff``
+If you feel more comfortable with a command such as ``git ydiff`` to trigger
+the ydiff command, you may symlink the executable to one named ``git-ydiff``
 as follows:
 
 .. code-block:: bash
 
-    cdiff_dir=$(dirname $(which cdiff))
-    ln -s "${cdiff_dir}/cdiff" "${cdiff_dir}/git-cdiff"
+    ydiff_dir=$(dirname $(which ydiff))
+    ln -s "${ydiff_dir}/ydiff" "${ydiff_dir}/git-ydiff"
 
 Pipe in a diff:
 
 .. code-block:: bash
 
-    git log -p -2 | cdiff       # view git log with changes of last 2 commits
-    git show 15bfa | cdiff -s   # view a given git commit, side by side
-    svn diff -r1234 | cdiff -s  # view svn diff comparing to given revision
-    diff -u file1 file2 | cdiff # view diff between two files (note the '-u')
-    diff -ur dir1 dir2 | cdiff  # view diff between two dirs
+    git log -p -2 | ydiff       # view git log with changes of last 2 commits
+    git show 15bfa | ydiff -s   # view a given git commit, side by side
+    svn diff -r1234 | ydiff -s  # view svn diff comparing to given revision
+    diff -u file1 file2 | ydiff # view diff between two files (note the '-u')
+    diff -ur dir1 dir2 | ydiff  # view diff between two dirs
 
     # View diff in a GitHub pull request, side by side
-    curl https://github.com/ymattw/cdiff/pull/11.diff | cdiff -s
+    curl https://github.com/ymattw/ydiff/pull/11.diff | ydiff -s
 
     # View a patch file in unified or context format, the latter depends on
     # command `filterdiff` from package `patchutils` which is available in
     # major Linux distros and MacPorts.
     #
-    cdiff -s < foo.patch
+    ydiff -s < foo.patch
 
 Redirect output to another patch file is safe:
 
 .. code-block:: bash
 
-    svn diff -r PREV | cdiff -s > my.patch
+    svn diff -r PREV | ydiff -s > my.patch
 
 Notes
 -----
 
-Cdiff has following known issues:
+Ydiff has following known issues:
 
 - Does not recognize `normal` diff, and depends on ``filterdiff`` (patchutils)
   to read `context` diff
 be installed with ``pip install coverage``).  Also watch out `travis build`_
 after push, make sure it passes as well.
 
-.. _`travis build`: https://travis-ci.org/ymattw/cdiff/pull_requests
+.. _`travis build`: https://travis-ci.org/ymattw/ydiff/pull_requests
 
 See also
 --------
 
 I have another tool `coderev`_ which generates side-by-side diff pages for code
 review from two given files or directories, I found it's not easy to extend to
-support git so invented `cdiff`.  Idea of ansi color markup is also from
+support git so invented `ydiff`.  Idea of ansi color markup is also from
 project `colordiff`_.
 
 .. _coderev: https://github.com/ymattw/coderev

setup.py

 from __future__ import with_statement
 import sys
 from distutils.core import setup
-from cdiff import META_INFO as _meta
+from ydiff import META_INFO as _meta
 
 if sys.hexversion < 0x02050000:
     raise SystemExit("*** Requires python >= 2.5.0")
     long_description += changes.read()
 
 setup(
-    name='cdiff',
+    name='ydiff',
     version=_meta['version'],
     author=_meta['author'],
-    author_email=_meta['email'],
+    author_email=_meta['email'].replace('(', '').replace(')', ''),
     license=_meta['license'],
     description=_meta['description'],
     long_description=long_description,
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 3',
     ],
-    py_modules=['cdiff'],
-    scripts=['cdiff'],
+    py_modules=['ydiff'],
+    scripts=['ydiff'],
 )
 
 # vim:set et sts=4 sw=4 tw=79:

tests/README

 # To generate expected output, chdir to a subdir and use following command, then
 # review with `less -R`
 #
-../../cdiff.py -c always < in.diff > out.normal
-../../cdiff.py -c always -s < in.diff > out.side-by-side
-../../cdiff.py -c always -s < in.diff -w70 > out.w70
-../../cdiff.py -c always -s < in.diff -w70 --wrap > out.w70.wrap
+../../ydiff.py -c always < in.diff > out.normal
+../../ydiff.py -c always -s < in.diff > out.side-by-side
+../../ydiff.py -c always -s < in.diff -w70 > out.w70
+../../ydiff.py -c always -s < in.diff -w70 --wrap > out.w70.wrap

tests/profile.sh

 OUTPUT=${1:?"output file required"}
 
 SELF_DIR=$(cd $(dirname $0) && pwd) || exit 1
-CDIFF_PY=$SELF_DIR/../cdiff.py
+YDIFF_PY=$SELF_DIR/../ydiff.py
 
 # To test with py3k: PYTHON=python3 make test
 PYTHON=${PYTHON:-python}
 STATS="stats.$$.tmp"
 
 for i in {1..100}; do cat "tests/svn/in.diff"; done \
-    | $PYTHON -m cProfile -o $STATS $CDIFF_PY -c always -s -w 60 \
+    | $PYTHON -m cProfile -o $STATS $YDIFF_PY -c always -s -w 60 \
     > /dev/null
 
 $PYTHON -c "import pstats;  p = pstats.Stats('$STATS'); \
-    p.strip_dirs().sort_stats('time').print_stats('cdiff')" \
+    p.strip_dirs().sort_stats('time').print_stats('ydiff')" \
     | tee $OUTPUT
 
 rm -f $STATS

tests/regression.sh

 TOP_DIR=$(cd $(dirname $0)/.. && pwd) || exit 1
 cd $TOP_DIR || exit 1
 
-CDIFF=./cdiff
+YDIFF=./ydiff
 
 # To test with py3k: PYTHON=python3 make test
 PYTHON=${PYTHON:-python}
 {
     local input=${1:?}
     local expected_out=${2:?}
-    local cdiff_opt=${3:-""}
+    local ydiff_opt=${3:-""}
     local cmd
 
-    cmd=$(printf "%-7s $CDIFF %-24s < %-30s " $PYTHON "$cdiff_opt" "$input")
+    cmd=$(printf "%-7s $YDIFF %-24s < %-30s " $PYTHON "$ydiff_opt" "$input")
     printf "$cmd"
     if eval $cmd 2>/dev/null | cmp --silent $expected_out -; then
         pass

tests/test_cdiff.py → tests/test_ydiff.py

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""Unit test for cdiff"""
+"""Unit test for ydiff"""
 
 import sys
 import unittest
 import os
 
 sys.path.insert(0, '')
-import cdiff  # nopep8
+import ydiff  # nopep8
 
 
 class Sequential(object):
 class PatchStreamTest(unittest.TestCase):
 
     def test_is_empty(self):
-        stream = cdiff.PatchStream(Sequential([]))
+        stream = ydiff.PatchStream(Sequential([]))
         self.assertTrue(stream.is_empty())
 
-        stream = cdiff.PatchStream(Sequential(['hello', 'world']))
+        stream = ydiff.PatchStream(Sequential(['hello', 'world']))
         self.assertFalse(stream.is_empty())
 
     def test_read_stream_header(self):
-        stream = cdiff.PatchStream(Sequential([]))
+        stream = ydiff.PatchStream(Sequential([]))
         self.assertEqual(stream.read_stream_header(1), [])
 
         items = ['hello', 'world', 'again']
 
-        stream = cdiff.PatchStream(Sequential(items))
+        stream = ydiff.PatchStream(Sequential(items))
         self.assertEqual(stream.read_stream_header(2), items[:2])
 
-        stream = cdiff.PatchStream(Sequential(items))
+        stream = ydiff.PatchStream(Sequential(items))
         self.assertEqual(stream.read_stream_header(4), items[:])
 
     def test_iter_after_read_stream_header(self):
         items = ['hello', 'world', 'again', 'and', 'again']
-        stream = cdiff.PatchStream(Sequential(items))
+        stream = ydiff.PatchStream(Sequential(items))
 
         _ = stream.read_stream_header(2)
         out = list(stream)
 
     def test_normal(self):
         utext = 'hello'.encode('utf-8')
-        self.assertEqual('hello', cdiff.decode(utext))
+        self.assertEqual('hello', ydiff.decode(utext))
 
     def test_latin_1(self):
         text = '\x80\x02q\x01(U'
             decoded_text = text.decode('latin-1')
         else:
             decoded_text = text
-        self.assertEqual(decoded_text, cdiff.decode(text))
+        self.assertEqual(decoded_text, ydiff.decode(text))
 
 
 class HunkTest(unittest.TestCase):
 
     def test_get_old_text(self):
-        hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@', (1, 2), (1, 2))
+        hunk = ydiff.Hunk([], '@@ -1,2 +1,2 @@', (1, 2), (1, 2))
         hunk.append(('-', 'foo\n'))
         hunk.append(('+', 'bar\n'))
         hunk.append((' ', 'common\n'))
         self.assertEqual(hunk._get_old_text(), ['foo\n', 'common\n'])
 
     def test_get_new_text(self):
-        hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@', (1, 2), (1, 2))
+        hunk = ydiff.Hunk([], '@@ -1,2 +1,2 @@', (1, 2), (1, 2))
         hunk.append(('-', 'foo\n'))
         hunk.append(('+', 'bar\n'))
         hunk.append((' ', 'common\n'))
             + spaced
         """
 
-        hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,5 +1,5 @@\n',
+        hunk = ydiff.Hunk(['hunk header\n'], '@@ -1,5 +1,5 @@\n',
                           (1, 5), (1, 5))
         hunk.append(('-', 'hhello\n'))
         hunk.append(('+', 'helloo\n'))
         hunk.append(('-', '	tabbed\n'))
         hunk.append(('+', 'again\n'))
         hunk.append(('+', ' spaced\n'))
-        diff = cdiff.UnifiedDiff(
+        diff = ydiff.UnifiedDiff(
             ['header\n'], '--- old\n', '+++ new\n', [hunk])
         return diff
 
     def test_markup_traditional_hunk_header(self):
-        hunk = cdiff.Hunk(['hunk header\n'], '@@ -0 +0 @@\n', (0, 0), (0, 0))
-        diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
-        marker = cdiff.DiffMarker()
+        hunk = ydiff.Hunk(['hunk header\n'], '@@ -0 +0 @@\n', (0, 0), (0, 0))
+        diff = ydiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
+        marker = ydiff.DiffMarker()
 
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
         self.assertEqual(out[3], '\x1b[1;34m@@ -0 +0 @@\n\x1b[0m')
 
     def test_markup_traditional_old_changed(self):
-        hunk = cdiff.Hunk([], '@@ -1 +0,0 @@\n', (1, 0), (0, 0))
+        hunk = ydiff.Hunk([], '@@ -1 +0,0 @@\n', (1, 0), (0, 0))
         hunk.append(('-', 'spam\n'))
-        diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
-        marker = cdiff.DiffMarker()
+        diff = ydiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
+        marker = ydiff.DiffMarker()
 
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
         self.assertEqual(out[3], '\x1b[1;31m-spam\n\x1b[0m')
 
     def test_markup_traditional_new_changed(self):
-        hunk = cdiff.Hunk([], '@@ -0,0 +1 @@\n', (0, 0), (1, 0))
+        hunk = ydiff.Hunk([], '@@ -0,0 +1 @@\n', (0, 0), (1, 0))
         hunk.append(('+', 'spam\n'))
-        diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
-        marker = cdiff.DiffMarker()
+        diff = ydiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
+        marker = ydiff.DiffMarker()
 
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
         self.assertEqual(out[3], '\x1b[32m+spam\n\x1b[0m')
 
     def test_markup_traditional_both_changed(self):
-        hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@\n', (1, 2), (1, 2))
+        hunk = ydiff.Hunk([], '@@ -1,2 +1,2 @@\n', (1, 2), (1, 2))
         hunk.append(('-', 'hella\n'))
         hunk.append(('+', 'hello\n'))
         hunk.append((' ', 'common\n'))
-        diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
-        marker = cdiff.DiffMarker()
+        diff = ydiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
+        marker = ydiff.DiffMarker()
 
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 6)
 
     def test_markup_side_by_side_padded(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker(side_by_side=True, width=7)
+        marker = ydiff.DiffMarker(side_by_side=True, width=7)
 
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
     # This test is not valid anymore
     def __test_markup_side_by_side_neg_width(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker(side_by_side=True, width=-1)
+        marker = ydiff.DiffMarker(side_by_side=True, width=-1)
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
 
     def test_markup_side_by_side_off_by_one(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker(side_by_side=True, width=6)
+        marker = ydiff.DiffMarker(side_by_side=True, width=6)
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
 
     def test_markup_side_by_side_wrapped(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker(side_by_side=True, width=5)
+        marker = ydiff.DiffMarker(side_by_side=True, width=5)
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
 
     def test_markup_side_by_side_tabbed(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker(side_by_side=True, width=8, tab_width=2)
+        marker = ydiff.DiffMarker(side_by_side=True, width=8, tab_width=2)
         out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
 
 class UnifiedDiffTest(unittest.TestCase):
 
-    diff = cdiff.UnifiedDiff(None, None, None, None)
+    diff = ydiff.UnifiedDiff(None, None, None, None)
 
     def test_is_hunk_meta_normal(self):
         self.assertTrue(self.diff.is_hunk_meta('@@ -1 +1 @@'))
 @@ -1,2 +1,2 @@
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertEqual(parser._type, 'unified')
 
     def test_type_detect_context(self):
   This part of the
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertEqual(parser._type, 'context')
 
     def test_type_detect_neg(self):
 
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertEqual(parser._type, 'unified')
 
     def test_parse_invalid_hunk_meta(self):
 @@ -a,a +0 @@
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertRaises(RuntimeError, list, parser.get_diff_generator())
 
     def test_parse_dangling_header(self):
 spam
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 2)
 --- c
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertRaises(AssertionError, list, parser.get_diff_generator())
 
     def test_parse_missing_hunk_meta(self):
 +++ d
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 2)
 @@ -1,2 +1,2 @@
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         self.assertRaises(AssertionError, list, parser.get_diff_generator())
 
     def test_parse_only_in_dir(self):
  common
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 3)
 Only in foo: foo
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 2)
  common
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 3)
  common
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
 
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 3)
 +Id
 """
         items = patch.splitlines(True)
-        stream = cdiff.PatchStream(Sequential(items))
-        parser = cdiff.DiffParser(stream)
+        stream = ydiff.PatchStream(Sequential(items))
+        parser = ydiff.DiffParser(stream)
         out = list(parser.get_diff_generator())
         self.assertEqual(len(out), 1)
         self.assertEqual(len(out[0]._hunks), 2)
 
     def setUp(self):
         self._cwd = os.getcwd()
-        self._ws = tempfile.mkdtemp(prefix='test_cdiff')
-        self._non_ws = tempfile.mkdtemp(prefix='test_cdiff')
+        self._ws = tempfile.mkdtemp(prefix='test_ydiff')
+        self._non_ws = tempfile.mkdtemp(prefix='test_ydiff')
         cmd = ('cd %s; git init; git config user.name me; '
                'git config user.email me@example.org') % self._ws
         subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
         subprocess.call(cmd, stdout=subprocess.PIPE)
 
     def test_preset_options(self):
-        os.environ['CDIFF_OPTIONS'] = '--help'
-        self.assertRaises(SystemExit, cdiff.main)
-        os.environ.pop('CDIFF_OPTIONS', None)
+        os.environ['YDIFF_OPTIONS'] = '--help'
+        self.assertRaises(SystemExit, ydiff.main)
+        os.environ.pop('YDIFF_OPTIONS', None)
 
     def test_read_diff(self):
         sys.argv = sys.argv[:1]
         self._change_file('read_diff')
 
         os.chdir(self._ws)
-        ret = cdiff.main()
+        ret = ydiff.main()
         os.chdir(self._cwd)
         self.assertEqual(ret, 0)
 
         self._commit_file()
 
         os.chdir(self._ws)
-        ret = cdiff.main()
+        ret = ydiff.main()
         os.chdir(self._cwd)
         self.assertEqual(ret, 0)
 
     def _test_read_diff_neg(self):
         sys.argv = sys.argv[:1]
         os.chdir(self._non_ws)
-        ret = cdiff.main()
+        ret = ydiff.main()
         os.chdir(self._cwd)
         self.assertNotEqual(ret, 0)
 
     def _test_read_log_neg(self):
         sys.argv = [sys.argv[0], '--log']
         os.chdir(self._non_ws)
-        ret = cdiff.main()
+        ret = ydiff.main()
         os.chdir(self._cwd)
         self.assertNotEqual(ret, 0)
 

cdiff → ydiff

 # -*- coding: utf-8 -*-
 
 import sys
-import cdiff
+import ydiff
 
-sys.exit(cdiff.main())
+sys.exit(ydiff.main())
 
 # vim:set et sts=4 sw=4 tw=79:

cdiff.py → ydiff.py

 import difflib
 
 META_INFO = {
-    'version'     : '1.0',
+    'version'     : '1.1',
     'license'     : 'BSD-3',
     'author'      : 'Matthew Wang',
     'email'       : 'mattwyl(@)gmail(.)com',
-    'url'         : 'https://github.com/ymattw/cdiff',
+    'url'         : 'https://github.com/ymattw/ydiff',
     'keywords'    : 'colored incremental side-by-side diff',
     'description' : ('View colored, incremental diff in a workspace or from '
                      'stdin, with side by side and auto pager support')
                 break
         else:
             # `filterdiff` translates unknown diff to nothing, fall through to
-            # unified diff give cdiff a chance to show everything as headers
+            # unified diff give ydiff a chance to show everything as headers
             #
             sys.stderr.write("*** unknown format, fall through to 'unified'\n")
             self._type = 'unified'
     ended), most likely python bug 12607 (http://bugs.python.org/issue12607)
     which was fixed in python 2.7.3.
 
-    See issue #30 (https://github.com/ymattw/cdiff/issues/30) for more
+    See issue #30 (https://github.com/ymattw/ydiff/issues/30) for more
     information.
     """
     pager_cmd = ['less']
         except UnicodeDecodeError:
             pass
 
-    return '*** cdiff: undecodable bytes ***\n'
+    return '*** ydiff: undecodable bytes ***\n'
 
 
 def terminal_size():
     option_group = OptionGroup(
         parser, 'Note', ('Option parser will stop on first unknown option '
                          'and pass them down to underneath revision control. '
-                         'Environment variable CDIFF_OPTIONS may be used to '
+                         'Environment variable YDIFF_OPTIONS may be used to '
                          'specify default options that will be placed at the '
                          'beginning of the argument list.'))
     parser.add_option_group(option_group)
 
-    # Place possible options defined in CDIFF_OPTIONS at the beginning of argv
-    cdiff_opts = [x for x in os.getenv('CDIFF_OPTIONS', '').split(' ') if x]
-    opts, args = parser.parse_args(cdiff_opts + sys.argv[1:])
+    # Place possible options defined in YDIFF_OPTIONS at the beginning of argv
+    ydiff_opts = [x for x in os.getenv('YDIFF_OPTIONS', '').split(' ') if x]
+
+    # TODO: Deprecate CDIFF_OPTIONS. Fall back to it and warn (for now).
+    if not ydiff_opts:
+        cdiff_opts = [x for x in os.getenv('CDIFF_OPTIONS', '').split(' ')
+                      if x]
+        if cdiff_opts:
+            sys.stderr.write('*** CDIFF_OPTIONS will be depreated soon, '
+                             'please use YDIFF_OPTIONS instead\n')
+            ydiff_opts = cdiff_opts
+
+    opts, args = parser.parse_args(ydiff_opts + sys.argv[1:])
 
     if opts.log:
         diff_hdl = revision_control_log(args)