src-1.26/control0000664000175000017500000000132513465361223012010 0ustar esresr# This is not a real Debian control file # It's project metadata for the shipper tool Package: src Description: Simple Revision Control is RCS/SCCS reloaded with a modern UI, designed to manage single-file solo projects kept more than one to a directory. Use it for FAQs, ~/bin directories, config files, and the like. Features integer sequential revision numbers, a command set that will seem familiar to Subversion/Git/Mercurial users, and no binary blobs anywhere. Homepage: http://www.catb.org/~esr/src XBS-Repository-URL: https://gitlab.com/esr/src XBS-HTML-Target: index.html XBS-Logo: src-logo.png #XBS-Project-Tags: RCS, SCCS, version control XBS-VC-Tag-Template: %(version)s XBS-Validate: make check src-1.26/COPYING0000664000175000017500000000243613400032526011432 0ustar esresr BSD LICENSE Copyright (c) 2015, Eric S. Raymond All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 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. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. src-1.26/FAQ.adoc0000664000175000017500000002241713427142223011644 0ustar esresr= SRC FAQ = version 1.7 [[why]] == Why SRC instead of $VCS? == Most version control systems today are multi-user, multi-file, and multi-branch oriented. These are all good features and properties to have, but they neglect the occasional need to maintain simple single-file documents, such as HOWTOs and FAQs, much like the very file you are reading now. There is even a good use-case for small programs and scripts. Do you presently keep your `~/bin` contents under version control? If not, consider using SRC for them. [[another-vcs]] == $VCS already does single-file version control, why another one? == It is true, other VCSes already fulfill this simple criterion, SCCS and RCS being some of the earliest examples dating back to the 1970s and 1980s. While SCCS died off due to its proprietary nature, https://www.gnu.org/software/rcs[RCS] has kept a niche for itself precisely for single-file projects. In fact, SRC is built on top of RCS, rather than reimplementing all of the gritty master file details. The idea that spawned the development of SRC was that it would have these five properties: 1. Only deals with single files. Use for HOWTOs, memoranda, scripts, etc. 2. Allows multiple histories to live in the same directory without entanglement. 3. Has a human-readable master-file representation - no binary blobs. 4. Modern CLI user-interface. Commands familiar to Subversion, Hg, Git users. 5. Integer sequential revision numbers a la Subversion. Notably, RCS itself fails on the latter two criteria. Designed both as an early attempt at VCS and for multi-user environments, the commands are awkward to deal with and it requires complicated processes of locking and unlocking files in order to edit and commit them. None of this is appropriate anymore. Modern DVCSes with a non-locking model have proven more effective even for multi-user projects, let alone single-user ones that will never have contention issues. Other projects to mold Mercurial and Git for a single-file purpose will at the _very_ least fail criteria #3 and #5, and often #4 as well. [[dvcs-obsoletion]] == Does SRC mean that $DVCS is obsolete? == Absolutely not! SRC and DVCSes serve entirely opposite needs. SRC’s strength is precisely when there is neither need nor desire for collaboration or publishing features, when there is only a single file and a single author for a file. In fact, if your script grows into a full project in its own right, SRC has a `src fast-export` command that can be used to jump-start a DVCS repository with the entire existing history intact. SRC might make certain uses of DVCS obsolete, such as keeping individual documents tucked away in their own directories so that the DVCS (which usually has a special repository directory named like `.hg` or `.git`) can operate. Scripts to impose a single-file concept on top of these systems do not go <> with respect to the reasons SRC exists. [[self-hosting]] == Is SRC used to develop itself? == No. That would be silly. SRC is a real software project, with several files that do, and should, have joint history. It has a public Git repository. SRC has real users (that is, other than the author) since day two after it was announced, but not for projects like itself. [[bare-rcs]] == I still use plain RCS for single files. Why move to SRC? == Because process friction matters, even to hackers as ancient as you and the author of SRC. Bare RCS's interface is pretty awful; a competently-designed UI can reduce that friction considerably. Try it and see. If you use RCS through Emacs's VC mode, you already have a pretty good wrapper around it...which, as it happens, the author of SRC also wrote. SRC has a couple of advantages over VC-RCS - running lockless, better scriptability, and ditching RCS's ugly revision numbering are the main ones. SRC is now a fully-supported VC-mode system in Emacs, so you can run SRC through Emacs and get the lockless operation and Subversion-style revision numbers. [[beginners-vcs]] == Is SRC a good system on which to learn about version control? == *YES*! SRC is explicitly designed to have the bare-bones features and commands of a modern version control system. Keep in mind that SRC’s strength is single-file documents and projects. If you have loose scripts and documents not presently under any version control, SRC is a good candidate for playing around with them. If instead you have a large multi-file project, ease yourself into using a DVCS with simple commands, possibly even using SRC’s command set as a guideline for which ones to learn first. You will appreciate having actual changesets that span multiple files in this use case. http://mercurial.selenic.com/[Mercurial] and http://git-scm.com/[Git] are the most common, which means they are also easy to find help for. [[keywords]] == Does SRC have keyword expansion? == No. When SRC commits a file with RCS on the backend, it uses `-kb` which explicitly disables all kind of expansion, and also allows arbitrary binary files to be stored. The SCCS backend always checks out files with -e, implying -k and no keyword expansion. Keyword expansion has, in general, not been well-accepted in the VCS world, most modern VCSes do not support it at all, and the author of SRC thinks it was a terrible idea. Do not even suggest this feature, it will not be implemented. [[missing-features]] == Does SRC have $FEATURE? == If you don’t see it in the `src help` listing, probably not. You are certainly free to suggest features, but SRC is developed with extreme conservatism as to what features to implement or not. Remember, single-file, single-user, private VCS. Before requesting a feature, ask yourself whether it makes SRC more complicated, whether it really helps a single author or developer, and whether it really makes sense to deploy SRC for your use-case instead of a DVCS. These can all be hard questions, and if you are in doubt, you may go forth with your request, others may share their own opinions. SRC shines in its simplicity. Any individual feature is not necessarily against this, but too many can easily creep over into ``too complicated'' territory. [[network]] == How well does SRC handle files over the network? == The answer is either "`completely fine`" or "`not at all`", depending on what is being asked. :-) SRC makes no special provisions, it operates in the current working directory whether that is local storage, NFS, CIFS, sshfs, or any other kind of networking file system. As long as the directory tree is mounted on your system, SRC should be able to handle it. [[status-inconsistency]] == Why doesn’t src status display show the same letters as $VCS? == Ah, yes, everybody's favorite bikeshedding topic. Consistency with other version control systems is an important way to reduce any kind of surprises while using SRC. Unfortunately, the single-letter codes used for statuses are not identical between VCSes and often conflict with each other over specific meanings. For example, *D* means 'deleted' in Subversion and Git, but Mercurial uses *R* for that same meaning. Git uses *R* to mean 'renamed', while Subversion uses it to mean 'replaced'. It is an unfortunate state of affairs. The development philosophy behind SRC is to keep it as un-innovative and unsurprising as possible, but since multiple VCSes in widespread use have not converged on the same meanings for single-letter status codes, SRC needs to settle on its own definitions that may differ from what you are used to. [[SCCS]] == Why did you bother with SCCS support? == Because some hacks that are useless or marginal are way too funny not to do anyway. This one was *hilarious*...if you have a hacker's sense of humor. If you don't, never mind. [[not-a-joke]] == Um. This is all a joke, right? == No, though the author admits he did laugh a lot while roughing out the original design. Resurrect RCS? Wrap it in a decent UI? _Really?_ There's a significant amount of ha-ha-only-serious here. Laugh, but treat SRC as a lesson in several things. Unix minimalism. The virtue of re-use, even of technology as old as RCS. The effectiveness of a carefully crafted UI. The value of a conservative design with no surprises and no undue cleverness. [[reporting-bugs]] == How should I report bugs in SRC? == This isn't really a FAQ, as nobody has asked it frequently enough; SRC is simple, carefully-tested code and bugs in it have been rare. Still... The first thing to do is pull the tip version from the project repository and verify that it still exhibits the bug. If it doesn't, you need read no further. When you have a bug persists with the repository tip version, the author needs three things: 1. An exact description of how you tickled the bug, which should at least include the SRC command or sequence of commands that produced it. 2. A copy of the repository file(s) over which the bug was triggered. 3. The output of "src version". Points for style if you send a tarball that unpacks into a directory containing relevant workfiles, their .src/RCS/SCCS subdirectory, a file of SRC commands to reproduce the bug (named 'tickleme' or 'fooup' or something distinctive), and a README listing the "src version" output and circumstances. If you can supply all this information, expect bug resolution to be very rapid. [[ack]] == Acknowledgments == Most of this FAQ was originally written by Mike Swanson, aka chungy. src-1.26/INSTALL0000664000175000017500000000203413401464424011431 0ustar esresr= Installing SRC = Have "python" available as a Python 2.7 or 3.x interpreter, x >= 3. Put src somewhere on your $PATH. Have RCS or SCCS or both installed on your system. The RCS this was written against is GNU 5.9.4 under Linux. OS X 5.9.4 has slightly different behavior but works. Amazon Linux running 5.7 also gives good results. The GNU version of SCCS, CSSC or "Compatibly Stupid Source Control", will do; the SunOS and Schilling versions remove some minor limitations. Installing the documentation requires asciidoc. If you want to use the "visualize" command, you will need to install the graphviz package to get dot(1). There's a 'make install' production you can use that also installs the manual page. It will require root permissions. Doing 'make check' performs a comprehensive test of the software. You must have both RCS and SCCS installed for this to work. You must also have a Git user configuration with user.name and user.email set; this is required for the fast-export test. The FAQ has a section on how to report bugs. src-1.26/Makefile0000664000175000017500000000327713426611316012053 0ustar esresr# # makefile for src # prefix?=/usr/local mandir?=/share/man target=$(DESTDIR)$(prefix) VERS=$(shell ./src version | sed -n -e "/src: /s///p") SOURCES = README INSTALL COPYING NEWS TODO src srctest src.adoc FAQ.adoc Makefile control all: src.1 check: pylint make pylint ./srctest -b rcs -p python2 ./srctest -b sccs -p python2 ./srctest -b rcs -p python3 ./srctest -b sccs -p python3 .SUFFIXES: .html .adoc .1 # Requires asciidoc and xsltproc/docbook stylesheets. .adoc.1: a2x --doctype manpage --format manpage $< .adoc.html: a2x --doctype manpage --format xhtml -D . $< rm -f docbook-xsl.css FAQ.html: FAQ.adoc asciidoc -a toc FAQ.adoc clean: rm -f *~ *.1 *.html *.tar.gz MANIFEST rm -fr .rs* typescript test/typescript src-$(VERS).tar.gz: $(SOURCES) src.1 @ls $(SOURCES) src.1 | sed s:^:src-$(VERS)/: >MANIFEST @(cd ..; ln -s src src-$(VERS)) (cd ..; tar -czf src/src-$(VERS).tar.gz `cat src/MANIFEST`) @(cd ..; rm src-$(VERS)) COMMON_PYLINT = --rcfile=/dev/null --reports=n \ --msg-template="{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}" \ --dummy-variables-rgx='^_' PYLINTOPTS = "C0103,C0123,C0301,C0302,C0325,C0326,C0330,C0410,C1001,C0111,R0101,R0902,R0903,R0904,R0201,R0912,R0913,R0914,R0915,R1705,W0110,W0141,W0142,W0232,W0311,W0312,W0603,W0511,W0613,E1101,E1103" pylint: @pylint $(COMMON_PYLINT) --disable=$(PYLINTOPTS) src version: @echo $(VERS) dist: src-$(VERS).tar.gz release: src-$(VERS).tar.gz src.html FAQ.html shipper version=$(VERS) | sh -e -x refresh: src.html FAQ.html shipper -N -w version=$(VERS) | sh -e -x install: all install -d "$(target)/bin" install -d "$(target)$(mandir)/man1" install src "$(target)/bin" install -m644 src.1 "$(target)$(mandir)/man1" src-1.26/NEWS0000664000175000017500000001645513466062040011112 0ustar esresr= src project news = 1.26: 2019-05-12:: Change name of "lift" command to "srcify". Proper inline documentation for srcify. Repair make check; do setup to perform validation before shipping. 1.25: 2019-05-10:: New "lift" command for changing RCS and SCCS directories to be SRC-managed. 1.24: 2019-02-07:: More fast-export bug fixes - make multifile export work properly. 1.23: 2019-02-06:: Repair a serious bug in src fast-export 1.22: 2018-12-06:: Correct behavior verified with OS X (which provides RCS 5.9.4). Correct behavior verified with Amazon Linux (which provides RCS 5.7). Correct behavior verified under OpenBSD, which has its own RCS port. The SCCS back end now supports tagging. To avoid errors, src will bail out if both .src and RCS directories exist. 1.21: 2018-11-27:: Now tested with Schilling fork of SCCS. One minor bugfix in SCCS back end. 1.20: 2018-10-28:: Add platform to "src version" output to make bug reports easier to generate. Signal-harden backend command execution. 1.19: 2018-10-27:: Filenames containing embedded spaces are handled properly. The '--' token is interpreted correctly in cat commands. 1.18: 2018-03-17:: Fix out-of-order 'revno' assignment when commits share same date. 'list' & 'log' suppress RFC 822 headers inserted by 'fast-import'. 'log' gained '-v' verbosity levels to show imported RFC 822 headers. 'list' & 'log' show author date if in RFC 822 headers rather than committer. Improved 'fast-import/export' round-trip fidelity using RFC 822 headers. 1.17: 2017-11-14:: Show diff of changes to be committed when editing/amending commit comment. 'src commit' no longer opens editor when file has not been changed. 'src diff' and 'src log' accept '-b' & '-w' to ignore whitespace changes. 'git log -p 1' shows "big bang" creation diff (previously no diff for r1). Commands now operate on all managed files (as documented) when none given. Colored output no longer crashes under Python 3. 'src log -' is alias for '-l ' a la 'git log -'; ditto 'src list'. 1.16: 2017-11-05:: Output of src diff & src log are colorized a la git when issuing to terminal. 'src log' now accepts '-p' to emit patches a la 'git log -p'. 1.15: 2017-10-30:: Fixes for fast-import, fast-export, and exec-bit propagation. 1.14: 2017-10-17:: Slightly improved boilerplate commit message. Fix for a minor command-parsing bug. 1.13: 2017-03-26:: Improvement to tempfile handling; avoid wiring in /tmp. 1.12: 2017-01-24:: Pylint cleanup, minor documentation fixes, and Python 3 port tweaks. 1.11: 2016-02-23:: Now handles binary repository data cleanly under Python 3. Version command reports versions for the underlying Python and back end. 1.10: 2016-02-18:: Code now runs under either Python 2 or Python 3. Restore (undocumented) add command for Emacs VC compatibility. 1.9: 2016-02-15:: Fix status-computation bug introduced in 1.8. SCCS parsing can no longer be fooled by comment lines resembing delta headers. 1.8: 2016-02-14:: Stamp files are no longer used; all SRC state is carried in the master itself. 1.7: 2016-02-10:: New 'visualize' command makes a DOT/graphviz visualization of repo structure. It is now possible to range-restrict a tag or branch listing. 1.6: 2016-02-08:: Improved prs log parsing in SCCS back end allows blank lines in comments. SCCS regression tests now really work (previously a false positive). 1.5: 2016-02-07:: Bugfixes for SCCS support. It now has its own regression test. Documentation and FAQ update for the new back end. 1.4: 2016-02-05:: Basic SCCS support - no branches or tags, limited diffs. The diff command no longer leaks native commit IDs onto the screen. In fast-export, properly sanitize RCS branch names illegal for git. 1.3: 2016-02-04:: Make SRC able to drive RCS v5.7 (previously needed v5.8 or later). If you change nothing in the template commit during edit, commit is canceled. 1.2: 2016-01-29:: Documentation improvements based on user feedback. 1.1: 2016-01-27:: Avoid upchucking on status A files if we happen to go through a modify check. Add regression test for commit-comment editing. Force binary I/O - a step towards Python 3 porting. 1.0: 2016-01-26:: Now hosted on gitlab. Fix for Tom Willemse's multi-file commit bug. 0.19: 2015-04-02:: A pylint audit caught two unbound variables in odd cases. 0.18: 2014-12-23:: Reversed range expressons are now supported. In list and log, explicit ranges are no longer reversed. 0.17: 2014-12-19:: Undocumented 'add' command abolished; Emacs VC will use 'commit -a' instead. 0.16: 2014-12-18:: Allow -- as an argument ender in src diff. Changes to a workfile's x bits are propagated to its master on checkin. 0.15: 2014-12-08:: Deal gracefully with directories passed as arguments. 0.14: 2014-11-29:: Fixed bugs affecting argument parsing in the presence of numeric filenames. 0.13: 2014-11-24:: Fixed bug that caused spurious modified status after commit. 0.12: 2014-11-21:: Log command shows the branch in the header line for each revision. List and log command now have an -l option to play nice with Emacs VC. 0.11: 2014-11-19:: File-not-modified status character changed to '=' to match Mercurial. Fixed-width cutlines and list -f option support Emacs VC mode. 0.10: 2014-11-19:: Modified check is now done by content, not modification date. 0.9: 2014-11-16:: SRC is now feature-complete as planned. Branch deletion is implemented and tested. 'src rename' now renames tags and branches - no longer an alias for 'move'. In tag and branch, a 'create' or '-c' modifier is now required to make tags. 0.8: 2014-11-14:: A branch label names the tip revision of its branch. src log and src list skip ignored and unregistered files in arguments. The embedded help has been enriched and now features multiple topics. ! works to negate patterns in ignore files. src status -a forces status display of all files, including I and ?. 0.7: 2014-11-13:: Bugfix release: fix initial file commit. There was a bug in my tests... 0.6: 2014-11-12:: Useful boilerplate in commit and amend message buffers. Tag names for revisions work; so does tag renaming. Branch-sensitive traversal with .. is working. Fixed yet another fast-export bug. 0.5: 2014-11-11:: Removed src add. The first src commit to a file adds it. Branching is mostly working - branch delete isn't implemented, Tag and branch names to identify revisions don't work yet. 'U' (unmodified) becomes '.' in src status listings. src fast-export was broken in 0.4, it's fixed now. Added src version. 0.4: 2014-11-10:: Improvements to src fast-import. src commit now has an -e option to force editing after -m or -f. There is now a "src amend". 0.3: 2014-11-09:: There is now a "src status" command, and .srcignore affects it. src fast-import is implemented (by callout to rcs-fast-import). 0.2: 2014-11-08:: There is a public repository on Gitorious All the initially projected commands except branch are implemented. The bug that caused failures with vi has been fixed. ".." is a legal range separator as well as "-". There is a regression-test suite, and more documentation. 0.1: 2014-11-07:: Initial proof-of-concept release. src-1.26/README0000664000175000017500000000161513400032526011255 0ustar esresr Simple Revision Control The venerable RCS (Revision Control System) has survived into the era of distributed version control because it fills a niche: sometimes you only *want* to track changes in single files at a time - for example, if you have a directory full of documents with separate histories. SRC (Simple Revision Control) is RCS, reloaded. It remains determinedly file-oriented and doesn't even track the committer of a change (because that's always you), but incorporates the design and user-interface lessons of modern version-control systems. It features sequential revision numbers, lockless operation, embedded command help, and a command set that will seem familiar to users of Subversion, Mercurial, and Git. See INSTALL for the (very simple) installation instructions. Run 'make check' for the regression test. Eric S. Raymond November 2014 src-1.26/src0000775000175000017500000035223413466062077011140 0ustar esresr#!/usr/bin/env python # # SRC - simple revision control. # # Things to know before hacking this: # # All the code outside the RCS and SCCS classes (and the RevisionMixin # helper) is intended to be generic to any file-oriented VCS. # # SRC and RCS/SCCS have different goals in managing locks. RCS/SCCS # wants to keep the workfile read-only except when it's explicitly # checked out, SRC wants to leave it writeable all the time. Thus, # the checkin sequence is "release lock; check in; assert lock". If # this seems confusing, it's because in RCS/SCCS terminology, locked is # writeable and unlocked is read-only. # # Despite appearances, this code does not actually use RCS locks (and # sets locking to non-strict). That just happens to be a handy way to # record which revision the user last checked out, which is significant # for future checkouts and for branching. # # With sufficient cleverness it would be possible to go in a different # direction - leave the master unlocked at all times except during # during the commit sequence, intervening with a chmod to turn off # write protection on the workfile when RCS/SCCS would normally turn # it on. I had this as a to-do for a long time but have abandoned the # concept; fighting RCS/SCCS's notion of when the workfile ought to be # write-locked seems too likely to lead to weird bugs in unexpected # situations. # # In an ideal world, we'd get rid of A status. The SCCS back end doesn't # have it, because the only way to register new content is by "sccs add" # on an already existing file and that creates a new SCCS master with # the content checked in as the first commit. RCS ci works that way as # well. On the other hand, if you use rcs -i foo it creates a master foo,v # but does *not* stuff it with the content of any corresponding foo. This # is what A status means. # # This code uses magic tags with a 0 in the second-to-last slot to # designate branches. It's the same format as CVS sticky tags, for # the same reason. They need to be distinguishable from regular tags # pointing at revisions, and this way the code to transform the sticky # tag into the branch name is as simple as possible. # # Top of the list of things that people will bikeshed about is the # letter codes returned by 'src status'. Different VCSes have # conflicting ideas about this. The universal ones are 'A' = Added, # 'M' = Modified, and '?' = Untracked. Here's a table of the ones # in dispute. Entries with '-' mean the VCS does not have a closely # corresponding status. # # git hg svn src # Unmodified ' ' '=' ' ' '=' # Renamed 'R' - - - # Deleted 'D' 'R' 'D' - # Copied 'C' - - - # Ignored '!' 'I' 'I' 'I' # Updated/unmerged 'U' - - - # Missing - '!' '!' '!' # Locked - - 'L' 'L' # # (hg used to use 'C' as the code for unmodified status.) # # This is a bit oversimplified; it is meant not as a technical # comparison but rather to illustrate how bad the letter collisions are. # SRC follows the majority except for absolutely *not* using a space as # a status code; this makes the reports too hard to machine-parse. # # SPDX-License-Identifier: BSD-2-Clause # This code runs under both Python 2 and Python 3. # Preserve this property! from __future__ import print_function import sys, os, subprocess, datetime, time, calendar, stat, glob import shutil, difflib, cgi, json, io, re, signal import tempfile, email.utils try: import curses except ImportError: pass version="1.26" CENTURY = "20" # A Y2.1K problem, but only for SCCS. # General notes on Python 2/3 compatibility: # # SRC uses the following strategy to allow it to run on both Python 2 # and Python 3: # # * Use binary I/O to read/write data from/to files and subprocesses; # where the exact bytes are important (such as in checking for # modified files), use the binary data directly. # # * Use latin-1 encoding to transform binary data to/from Unicode when # necessary for operations where Python 3 expects Unicode; this will # ensure that bytes 0x80..0xff are passed through and not clobbered. # The polystr and polybytes functions are used to do this so that when # running on Python 2, the byte string data is used unchanged. # # * Construct custom stdin, stdout, and stderr streams when running # on Python 3 that force ASCII encoding, and wrap them around the # underlying binary buffers (in Python 2, the streams are binary and # are used unchanged); this ensures that the same transformation is # done on data from/to the standard streams, as is done on binary data # from/to files and subprocesses; the make_std_wrapper function does # this. Without this change, 0x80..0xff written to stdout will be # garbled in unpredictable ways. master_encoding = 'latin-1' if str is bytes: # Python 2 polystr = str polybytes = bytes else: # Python 3 def polystr(obj): "Polymorphic string factory function" # This is something of a hack: on Python 2, bytes is an alias # for str, so this ends up just giving a str back for all # inputs; but on Python 3, if fed a byte string, it decodes it # to Unicode using the specified master encoding, which should # be either 'ascii' if you're sure all data being handled will # be ASCII data, or 'latin-1' otherwise; this ensures that the # original bytes can be recovered by re-encoding. if isinstance(obj, str): return obj if not isinstance(obj, bytes): return str(obj) return str(obj, encoding=master_encoding) def polybytes(s): "Polymorphic string encoding function" # This is the reverse of the above hack; on Python 2 it returns # all strings unchanged, but on Python 3 it encodes Unicode # strings back to bytes using the specified master encoding. if isinstance(s, bytes): return s if not isinstance(s, str): return bytes(s) return bytes(s, encoding=master_encoding) def make_std_wrapper(stream): "Standard input/output wrapper factory function" # This ensures that the encoding of standard output and standard # error on Python 3 matches the master encoding we use to turn # bytes to Unicode in polystr above. return io.TextIOWrapper(stream.buffer, encoding=master_encoding, newline="\n") sys.stdin = make_std_wrapper(sys.stdin) sys.stdout = make_std_wrapper(sys.stdout) sys.stderr = make_std_wrapper(sys.stderr) # Note: Avoid using unbolded blue (poor luminance contrast with black # terminal-emulator background) or bolded yellow (poor contrast with # white background.) RESET = BOLD = '' CBLACK = CBLUE = CGREEN = CCYAN = CRED = CMAGENTA = CYELLOW = CWHITE = '' def init_colors(): curses.setupterm() global RESET, BOLD RESET = polystr(curses.tigetstr('sgr0')) or '' BOLD = polystr(curses.tigetstr('bold')) or '' colors = {'setaf': [0, 4, 2, 6, 1, 5, 3, 7], # ANSI colors 'setf': [0, 1, 2, 3, 4, 5, 6, 7]} # legacy colors for (k, v) in colors.items(): x = curses.tigetstr(k) if x: for (i, c) in enumerate(['black', 'blue', 'green', 'cyan', 'red', 'magenta', 'yellow', 'white']): globals()['C' + c.upper()] = polystr(curses.tparm(x, v[i])) break if 'curses' in sys.modules and sys.stdout.isatty(): try: init_colors() except (curses.error, AttributeError): pass def rfc3339(t): "RFC3339 string from Unix time." return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(t)) def announce(msg): sys.stdout.write("src: " + msg + "\n") def croak(msg): sys.stdout.flush() sys.stderr.write("src: " + msg + "\n") sys.exit(1) debug = 0 DEBUG_COMMANDS = 1 # Show commands as they are executed DEBUG_SEQUENCE = 2 # Sequence debugging DEBUG_PARSE = 3 # Debug logfile parse quiet = False # option -q: run more quietly pseudotime = False # option -T: artificial clock for regression testing class popen_or_die: "Read or write from a subordinate process." def __init__(self, command, legend="", mode="r"): assert mode in ("r", "w", "rb", "wb") self.command = command self.legend = legend self.mode = mode # Pipe to the correct streams depending on the chosen mode self.stdin = (subprocess.PIPE if mode == "w" else None) self.stdout = (subprocess.PIPE if mode == "r" else None) self.stderr = (subprocess.STDOUT if mode == "r" else None) if self.legend: self.legend = " " + self.legend self.fp = None def __enter__(self): if debug >= DEBUG_COMMANDS: if self.mode == "r": sys.stderr.write("%s: reading from '%s'%s\n" % (rfc3339(time.time()), self.command, self.legend)) else: sys.stderr.write("%s: writing to '%s'%s\n" % (rfc3339(time.time()), self.command, self.legend)) try: # The I/O streams for the subprocess are always bytes; this # is what we want for some operations, but we will need # to decode to Unicode for others to work in Python 3, as # explained in the general notes. self.fp = subprocess.Popen(self.command, shell=True, stdin=self.stdin, stdout=self.stdout, stderr=self.stderr) # The Python documentation recommends using communicate() to # avoid deadlocks, but this doesn't allow fine control over # reading the data; since we are not trying to both read # from and write to the same process, this should be OK. return self.fp.stdout if self.mode == "r" else self.fp.stdin except (OSError, IOError) as oe: croak("execution of %s%s failed: %s" \ % (self.command, self.legend, oe)) def __exit__(self, extype, value, traceback_unused): if extype: if debug > 0: raise extype(value) croak("fatal exception in popen_or_die.") if self.fp.stdout is not None: # This avoids a deadlock in wait() below if the OS pipe # buffer was filled because we didn't read all of the data # before exiting the context mgr (shouldn't happen but this # makes sure). self.fp.stdout.read() self.fp.wait() if self.fp.returncode != 0: croak("%s%s returned error." % (self.command, self.legend)) return False def screenwidth(): "Return the current width of the terminal window." width = 73 if "COLUMNS" in os.environ: return int(os.environ["COLUMNS"]) if sys.stdin.isatty(): with popen_or_die('stty size') as tp: # stty returns 0,0 inside Emacs width = int(tp.read().split()[1]) or width return width WIDTH = screenwidth() - 1 def is_history(arg): "Are we looking at a history file?" for vcsb in backends: if vcsb.is_history(arg): return True return False def modified(workfile, history=None): "Has the workfile been modified since it was checked out?" # Alas, we can't rely on modification times; it was tried, and # os.utime() is flaky from Python - sometimes has no effect. Where # the bug is - Python, glibc, kernel - is unknown. Even if we # could, it's nice to catch the case where an edit was undone. # # If no revisions, bail out if not backend.has_revisions(workfile): return False if history is None: history = History(workfile) with backend.lifter(workfile): with backend.cat(workfile, history.current().native) as bstream: base_content = bstream.read() # this data will be binary with open(workfile, "rb") as fp: workfile_content = fp.read() # This comparison uses the binary data for maximum accuracy return base_content != workfile_content def do_or_die(dcmd, legend="", mute=True, missing=None): "Either execute a command or die." if legend: legend = " " + legend if debug == 0 and mute: muteme = " >/dev/null 2>&1" else: muteme = "" if debug >= DEBUG_COMMANDS: sys.stderr.write("executing '%s'%s\n" % (dcmd, legend)) try: retcode = subprocess.call("(" + dcmd + ")" + muteme, shell=True) if retcode < 0: croak("%s was terminated by signal %d." % (repr(dcmd), -retcode)) elif retcode != 0: errmsg = "%s returned %d." % (repr(dcmd), retcode) if retcode == 127: if missing is None: missing = backend.__class__.__name__ errmsg += "\nYou probably need to install %s." % missing croak(errmsg) except (OSError, IOError) as e: croak("execution of %s%s failed: %s" % (repr(dcmd), legend, e)) def capture_or_die(command): "Run a specified command, capturing the output." if debug >= DEBUG_COMMANDS: sys.stderr.write("%s: capturing %s\n" % (rfc3339(time.time()), command)) try: # This will return binary data content = subprocess.check_output(command, shell=True) except (subprocess.CalledProcessError, OSError) as oe: croak("execution of %s failed: %s" % (repr(command), oe)) if debug >= DEBUG_COMMANDS: sys.stderr.write(polystr(content)) return content class HistoryEntry: "Capture the state of a native revision item in the log." def __init__(self, history): self.history = history self.revno = None self.native = None # magic cookie only interpreted by back end self.headers = None self.log = "" self.date = None self.parent = None # Another HistoryEntry self.child = None # Another HistoryEntry self.branches = set([]) self.branch = None def selected(self): return self == self.history.current() def getdate(self, who): if self.headers and not pseudotime: return self.headers.get(who + "-date") or self.date return self.date def unixtime(self, who): date = self.getdate(who) try: t = calendar.timegm(time.strptime(date, "%Y-%m-%dT%H:%M:%SZ")) offset = 0 if self.headers and not pseudotime: offset = self.headers.get(who + "-date-offset") or 0 return t, offset except (TypeError, ValueError): croak("garbled date %s" % date) def __str__(self): return "<%s = %s>" % (self.revno, self.native) def registered(workfile): "Is this a workfile for a registered history?" return os.path.exists(backend.history(workfile)) class History: "Encapsulate a revision list and some methods on it" def __init__(self, name): self.name = name self.revlist = [] self.symbols = {} self.branch = "trunk" self.lockrevs = [] self.description = "" self.annotations = {} if not registered(self.name): croak("%s is not registered" % self.name) self.by_revno_d = {} self.by_native_d = {} self.branches = set([]) backend.parse(self) self.lift_headers() self.normalize_header_dates() def build_indices(self): for item in self.revlist: self.by_revno_d[item.revno] = item self.by_native_d[item.native] = item for item in self.revlist: item.parent = self.by_native_d.get(backend.pred(item.native)) item.child = self.by_native_d.get(backend.succ(item.native)) if item.parent and item.parent.child != item: item.parent.branches.add(item) #sys.stderr.write("Symbols: %s\n" % self.symbols) #for item in self.revlist: # sys.stderr.write("Item %s\n" % item) #sys.stderr.write("By revision: %s\n" % self.by_revno_d.keys()) if self.revlist: for (name, rev) in list(self.symbols.items()): if backend.isbranch(rev): base = backend.branch_to_base(rev, self) tip = backend.branch_to_tip(rev, self) while True: self.by_native_d[base].branch = name if base == tip: break base = backend.succ(base) # Digest JSON from the description field if not self.description.strip(): self.annotations = {} else: try: # The JSON loader returns Unicode, so this is one place # where internal data will be Unicode even in Python 2; # since ASCII data will be inter-converted between byte # string and Unicode whenever needed in Python 2, this # is not an issue. self.annotations = json.loads(self.description.strip()) except ValueError as _e: croak("legacy data %s in description field" % self.description) def lift_headers(self): valid = ('author', 'author-date', 'committer', 'committer-date', 'mark', 'parents') for item in self.revlist: headers = {} i = 0 while True: n = item.log.find('\n', i) if n < 0: break header = item.log[i:n].split(':', 1) if len(header) != 2: break key = header[0].lower() if key not in valid: break headers[key] = header[1].strip() i = n + 1 # eat blank line between headers and body while i < len(item.log) and item.log[i] == '\n': i += 1 item.log = item.log[i:] if headers: item.headers = headers def normalize_header_dates(self): for item in self.revlist: if item.headers: for k in tuple(item.headers): if k.endswith("-date"): d = email.utils.parsedate_tz(item.headers[k]) if d: u = email.utils.mktime_tz(d) u = datetime.datetime.utcfromtimestamp(u) item.headers[k] = u.isoformat() + "Z" item.headers[k + "-offset"] = d[9] if d[9] else 0 def __len__(self): return len(self.revlist) def current(self): "Return the revision currently checked out." # Yes, this looks weird. The idea is: Try to return the locked # revision. If that blows up, try to return the tip revision of # the current branch. If that blows up, return None. try: return self.by_native_d[self.lockrevs[0]] except (IndexError, KeyError): try: return self.by_native_d[backend.branch_to_tip(self.symbols[self.branch], self)] except (IndexError, KeyError): return None def current_branch(self, backwards=False): "Return a list of items that are descendants or ancestors of current." if debug >= DEBUG_SEQUENCE: sys.stdout.write(("current_branch(%s)" % self.current())) selection = [] p = self.current() if p is not None: selection = [p] while True: if p.parent is None: break else: p = p.parent selection = [p] + selection s = self.current() while True: s = s.child if s is None: break selection.append(s) if backwards: selection.reverse() return selection def tip(self, rev=None): "Return the tip revision of the branch of the given native revision." if rev is None: rev = self.current().native s = self.by_native_d[rev] while True: if s.child is None: return s else: s = s.child def native_to_revno(self, revision): "Map a native ID to a revno" item = self.by_native_d.get(revision) return item and item.revno def by_revno(self, revno): "Map a revno to a revision item." try: return self.by_revno_d[revno] except KeyError: if revno == 0: # This case comes up if we try to select the tip # revision of a history without revisions. croak("{0} has no revisions".format(self.name)) else: croak("{0} has no revno {1}".format(self.name, revno)) def revno_to_native(self, revno): "Map a revno to a native ID" return self.by_revno(revno).native def set_annotations(self): "Write auxilary symbols as JSON." backend.write_description(json.dumps(self.annotations), self) help_topics = { "topics": """ The following help topics are available: intro -- Basic concepts: commits, tags, branches. The form of commands. revisions -- How to specify ranges of commits to operate on. commands -- a summary of the commands. commit -- the commit command: how to commit changes to a file. amend -- the amend command: editing stored change comments. checkout -- the checkout command: retrieving historical versions of files. cat -- the cat command: dumping revisions to standard output. status -- the status command: more details and unusual status codes. log -- the log command: dump commit log information to standard output. list -- the list command: dump commit summaries to standard output. diff -- the diff command: dump revision differences to standard output. fast-export -- the fast-export command: export history to other systems. fast-import -- the fast-import command: import history from other systems. srcify -- the srcify command: change manaagement from SCCS/RCS to src. ignores -- .srcignore files and their uses. The 'help', 'rename', 'ls', 'move', 'copy', 'visualize', and 'version' commands are completely described in the command summary. """, "intro": """ SRC Introduction SRC (or src) is designed for version control on single-file projects. A SRC history is a sequence of commits numbered in strict time order starting from 1. Each holds a modification to the file, a comment, and the date-time of the commit. The sequence also has a branch structure. By default there is just one branch named 'trunk'. You can start a new named branch at any commit. Branches can later be renamed or deleted. Because of branching, parent and child commits do not necessarily have consecutive numbers. Commits will always be be added to the tip of the current branch. You can change the current branch by either checking out a revision that is on that branch, or using a 'src branch' command to explicitly change the current branch. You can assign tags (names) to point to commits. They too can be renamed later or deleted. The general form of a SRC command is src verb [switches] [revision-spec] [files...] That is, a command verb is followed by optional switches, which are (sometimes) optionally followed by a range of commits to operate on, which is optionally followed by a list of files to operate on. Usually you will specify either a revision range or multiple files, but not both. The token '--' tells the command-line interpreter that subcommands, switches, and revision-specs are done - everything after it is a filename, even if it looks like a subcommand or revision number. If you do not specify any files, SRC will operate sequentially on each individual file in the current directory with a history. A good help topics to read after this one would be 'revisions'. """, "revisions": """ SRC Revisions A 'revision' is a 1-origin integer, or a tag name designating an integer revision, or a branch name designating the tip revision of its branch, or '@' meaning the currently fetched revision. Revision numbers always increase in commit-date order. A revision range is a single revision, or a pair of revisions 'M-N' (all revisions numerically from M to N) or 'M..N' (all revisions that are branch ancestors of N and branch successors of M). If N is less than M, the range is generated as if N >= M then reversed. If SRC complains that your revision spec looks like a nonexistent filename, you can prefix it with '@' (this is always allowed). Some commands (help, commit, status, delete/rename commands for tags and branches, ls, move, copy, fast-import, release, version) don't take a revision spec at all and will abort if you give one. Some commands (amend, checkout, cat, tag and branch creation) optionally take a singleton revision spec. Some commands (log, list, diff, fast-export) accept a range or a singleton. Unless otherwise noted under individual commands, the default revision is the tip revision on the current branch. A good topic to read next would be 'commands'. """, "commands": """ SRC Commands Summary src help [command] Displays help for commands. src commit [-|-m 'string'|-f 'file'|-e] ['file'...] Enters a commit for specified files, separately to each one. A history is created for the file if it does not already exist. With '-', take comment text from stdin; with '-m' use the following string as the comment; with '-f' take from a file. With '-e', edit even after '-', '-f' or '-m'. 'ci' is a synonym for 'commit'. src amend [-|-m 'string'|-f 'file'|-e] ['revision'] ['file'...] Amends the stored comment for a specified revision, defaulting to the latest revision on the current branch. Flags are as for commit. src checkout ['revision'] ['file'...] Refresh the working copies of the file(s) from their history files. 'co' is a synonym for 'checkout'. src cat ['revision'] ['file'...] Send the specified revisions of the files to standard output. src status [-a] ['file'...] '=' = unmodified, 'M' = modified, '!' = missing, '?' = not tracked, 'I' = ignored, 'A' = added, 'L' = locked (recover with 'src checkout'). Find more details under 'help status'. 'st' is a synonym for 'status'. src tag [list|-l|create|-c|delete|del|-d] ['name'] ['revision'] ['file'...] List tags, create tags, or delete tags. Create/delete takes a singleton revision, defaulting to the current branch tip. List defaults to all revisions. src branch [list|-l|create|-c|delete|del|-d] ['name'] ['file'...] List, create, or delete branches. When listing, the active branch is first in the list. The default branch is 'trunk'. Create/delete takes a singleton revision, defaulting to the current branch tip. List defaults to all revisions, including 0 (the trunk root phantom revision). src rename ['tag'|'branch'] ['oldname'] ['newname'] ['file'...] Rename a tag or branch. Refuses to step on an existing symbol or rename a nonexistent one. 'rn' is a synonym for 'rename'. src list [(-|-l )] [-f 'fmt'] ['revision-range'] ['file'...] Sends summary information about the specified commits to standard output. The summary line tagged with '*' is the state that the file would return to on checkout without a revision-spec. See 'help list' for information about custom formats. Use '-' or '-l ', where is a number, to limit the listing length. Default range is the current branch, reversed. src log [-v] [(-|-l )] [(-p|-u|-c) [-b|-w]] ['revision-range'] ['file'...] Sends log information about the specified commits to standard output. Use '-' or '-l ', where is a number, to limit the listing length. Default range is the current branch, reversed. Use '--patch', '-p' or '-u' to also send a unified format diff listing to standard output for each revision against its immediate ancestor revision; '-c' emits a context diff instead. When generating a diff, '-b' ignores changes in the amount of whitespace, and '-w' ignores all whitespace. Histories imported via 'fast-import' (when not using its '-p' option) have RFC-822-style headers inserted into the log comment to preserve metadata not otherwise representable in SRC, such as distinct author and committer identifications and dates. These headers are normally suppressed by 'log', however, '-v' shows a summarized view of important headers; '-v -v' shows all headers as-is. src diff [(-u|-c) [-b|-w]] ['revision-range'] ['file'...] Sends a diff listing to standard output. With no revision spec, diffs the working copy against the last version checked in. With one revno, diffs the working copy against that stored revision; with a range, diff between the beginning and end of the range. 'di' is a synonym for 'diff'. src ls List all registered files. src visualize Emit a DOT visualization of repository structures. To use this, install the graphviz package and pipe the output to something like 'dot -Tpng | display -'. 'vis' is a synonym for 'visualize'. src move 'old' 'new' Rename a workfile and its history. Refuses to step on existing workfiles or histories. 'mv' is a synonym for 'move'. src copy 'old' 'new' Copy a workfile and its history. Refuses to step on existing files or histories. 'cp' is a synonym for 'copy'. src fast-export ['revision-range'] ['file'...] Export one or more projects to standard output as a Git fast-import stream. For a history originally imported from elsewhere, author and committer identification is gleaned from the RFC-822-style headers inserted into the commit comment by 'fast-import' (if its '-p' option was not used). Otherwise, this information is copied from your Git configuration. The default range is all commits. src fast-import [-p] ['file'...] Parse a git-fast-import stream from standard input. The modifications for each individual file become separate SRC histories. Mark, committer and author data, and mark cross- references to parent commits, are preserved in RFC-822-style headers on log comments unless the '-p' (plain) option is given, in which case this metadata is discarded. Give arguments to restrict the files imported. src release ['file'...] Release locks on files. This is never necessary in a normal workflow, which will be repeated edit-commit cycles, but it may be handy if you have to interoperate with other tools that expect RCS masters to be in their normal (unlocked/unwritable) state. src srcify Move a directory from being RCS- or SCCS-managed to being SRC-managed. That is: if the current directory contains an RCS directory, rename it to .src (but leave any SCCS directory in place). Then check out all masters for editing that are not already checked out. src version Report the versions of SRC, the underlying Python, and the back end. The omission of 'src remove' is a deliberate speed bump. """, "status": """ src status [-a] ['file'...] The status command shows you the version-control status of files. It is designed to be useful for both humans and software front ends such as Emacs VC mode. The status codes, in roughly most common to rarest, are: = - Unmodified. File is the same as the latest stored revision. M - Modified. File has been changed since the latest stored revision. ? - Not tracked. SRC does not keep a history for this file. I - ignored. This file matches the patterns in '.srcignore'. ! - Missing. There is a history for this file but the workfile is missing. A - The file has been registered into SRC but has no commits. L - The file is locked/writable. Modification status is by content (using a SHA1 hash) rather than the filesystem's last-modified date. Thus, if you make changes to a work file in your editor, then undo them, the file's status returns to '='. You can usually recover a file from 'A', 'L', and '!' status with 'src checkout'. 'A' and 'L' statuses should only occur if you have used RCS directly on a file, or if you have called 'src commit' with the deliberately undocumented '-a' option meant for Emacs VC's use. If you give 'src status' no filename arguments, it surveys all files in the current directory but untracked and ignored files are not listed. If you give it filename arguments, status is listed for all of them. The '-a' option forces status listing of all files. This differs from 'src status *' because the latter will not see dotfiles and thus not list the status of them. """, "commit":""" src commit [-|-m 'string'|-f 'file'| -e] ['file'...] The commit command is how you add revisions to your file history. It always adds the contents of the workfile as a revision to the tip of the current branch. You also use commit on files that have not been registered to start an SRC history for them. When you commit, you must specify a change comment to go with the revision. There are several ways to do this. The '-m' option to the command takes the following string argument as the comment. The '-' option takes the comment text from standard input. The '-f' option takes the comment from a named file. If you use none of these, or if you use one of them and the '-e' option, SRC will start an editor in which you can compose the comment. Text specified via '-m', '-f', or '-' becomes the initial contents of the comment. SRC respects the EDITOR variable and calls it on a temporary file to create your comment. Th file will have a footer including its name and revision which will be discarded when you finish editing. If you leave the comment empty (except for the generated footer) or consisting only of whitespace, the commit will be aborted. The commit will also be aborted if your editor returns a failure status. If you commit to multiple files at once, separate changes will be registered for each one, and you may get a separate edit session for each (if you have not set the comment text with options, or have forced editing with '-e'). This is a major difference from other VCSes, which are usually designed to create changesets common to multiple files. 'ci' is a synonym for 'commit'. """, "amend" : """ src amend [-|-m 'string'|-f 'file'| -e] ['revision'] ['file'...] Use this command to amend (modify) the change comment in a saved revision. The commit date is not changed. Takes a singleton revision number, tag, or branch, defaulting to the latest revision on the current branch. The edit flags and EDITOR variable are interpreted are as for commit. The only difference is that existing change comment is appended to any text you specify with switches as the initial comment passed to your editor. 'am' is a synonym for 'amend' """, "checkout":""" src checkout ['revision'] ['file'...] Refresh the working copies of the file(s) from their history files. Takes a single revision number, tag, or branch name. The default if you give none is the tip revision of the current branch. This command is how you discard the contents of a modified workfile. You can also use it to revert the workfile to match a previous stored revision. Doing do may, as a side effect, change your current branch. 'co' is a synonym for 'checkout'. """, "cat" : """ src cat ['revision'] ['file'...] Send the specified revision of each file to standard output. This is not normally very useful with more than one file argument, but SRC does not prevent that. Takes a single revision number, tag, or branch name. The default if you give none is the tip revision of the current branch. This command is mainly intended for use in scripts. """, "tag" : """ src tag [list|-l|create|-c|delete|del|-d] ['name'] ['revision'] ['file'...] List tags (with '-l'), create tags (with '-c'), or delete tags (with '-d'). Takes at most a singleton revision; the default is the current branch tip. Tag creation and deletion require a following name argument. Tag creation will not step on an existing tag name, and a nonexistent branch cannot be deleted. """, "branch" : """ src branch [list|-l|create|-c|delete|del|-d] ['name'] ['file'...] List branches (with '-l'), create branches (with '-c'), or delete branches (with '-d'). In the list produced by '-', the active branch is first in the list. Branch creation and deletion require a following name argument. Branch creation will not step on an existing branch name, and a nonexistent branch cannot be deleted. """, "log" : """ src log [-v] [(-|-l )] [(-p|-u|-c) [-b|-w]] ['revision-range'] ['file'...] Sends log information about the specified commits of each file to standard output. The log information includes the revision number, the date, and the log comment. With no revision, dumps a log of the entire current branch. The '--patch', '-p' or '-u' option additionally sends a unified format diff listing to standard output for each revision against its immediate ancestor revision; '-c' emits a context diff instead. When generating a diff, '-b' ignores changes in the amount of whitespace, and '-w' ignores all whitespace. The '-' or '-l ' option, where is a number, can be used to limit the listing length. Histories imported via 'fast-import' (when not using its '-p' option) have RFC-822-style headers inserted into the log comment to preserve metadata not otherwise representable in SRC, such as distinct author and committer identifications and dates. These headers are normally suppressed by 'log', however, '-v' shows a summarized view of important headers; '-v -v' shows all headers as-is. """, "list" : """ src list [(-|-l )] [-f 'fmt'] ['revision-range'] ['file'...] Sends summary information about the specified commits of each file to standard output. The summary information includes the revision number, the date, and the first line of the log comment. This command is provided assuming you will use the good practice of beginning each commit with a self-contained summary line. With no revision, dumps a log of the entire current branch. The '-f' option allows you to set a custom format string. Available substitutions are: {0} - the file name {1} - the revision number {2} - the mark '*' if this is the currently checked out revision, else '-'. {3} - the date in RFC3339 format {4} - the summary line The '-' or '-l ' option, where is a number, can be used to limit the listing length. 'li' is a synonym for 'list'. """, "diff" : """ src diff [(-u|-c) [-b|-w]] ['revision-range'] ['file'...] Sends a diff listing to standard output. With no revision spec, diffs the working copy against the last version checked in. With one revno, diffs the working copy against that stored revision; with a range, diff between the beginning and end of the range. The actual difference generation is done with diff(1). The default diff format is '-u' (unified), but if you specify a '-c' option after the verb a context diff will be emitted. '-b' ignores changes in the amount of whitespace, and '-w' ignores all whitespace. 'di' is a synonym for 'diff'. """, "fast-export" : """ src fast-export ['revision-range'] ['file'...] Export one or more projects to standard output as a git fast-import stream. This can be consumed by 'git fast-import' to create a Git repository containing the project history. It is possible (though probably not very useful) to fast-export a limited range of commits, producing an incremental dump. In this case branch joins are done with the magic ^0 suffix. Fast-exporting multiple files produces a single stream with a joint history. For a history originally imported from elsewhere, author and committer identification is gleaned from the RFC-822-style headers inserted into the commit comment by 'fast-import' (if its '-p' option was not used). Otherwise, this information is copied from your Git configuration. The default range is all commits. """, "srcify" : """ src srcify Change the current directory with an RCS or SCCS subdirectory to be managed by src instead. Any RCS directory is renamed .src. Then all files with histories are checked out for editing. """, "fast-import" : """ src fast-import [-p] ['file'...] Parse a git-fast-import stream from standard input. The modifications for each individual file become separate SRC histories. Give arguments to restrict the files imported. The import is actually done with the rcs-fast-import(1) tool, which must be on your $PATH for this command to work. Some gitspace metadata cannot be represented in the SRC/RCS model of version control. Mark, committer and author data, and mark cross-references to parent commits. These are preserved in RFC-822-style headers on log comments unless the '-p' (plain) option is given, in which case this metadata is discarded. """, "ignores" : """ Making SRC Ignore Certain Files You can have a file named '.srcignore' containing the names of files that SRC should ignore, or more commonly patterns describing files to ignore. When SRC is told to ignore a file, it won't show up in 'src status' listings unless the '-a' (all) flag is used or you give it as an explicit argument. It will also be ignored when commands that expect a list of registered files see it (which could easily happen when you use shell wildcards in SRC commands). Other version-control systems have these too. The classic example of how to do this is using the pattern '*.o' to ignore C object files. But if you need to do that, you should probably be using a multi-file VCS with changesets, not this one. Patterns that might be useful with single-file projects include '*~' to ignore editor backup files, or '*.html' if you're writing documents that render to HTML but aren't sourced in it. The repo subdirectory - normally '.src' - is always ignored, but '.srcignore' itself is not automatically ignored. SRC's pattern syntax is that of Unix glob(3), with initial '!' treated as a negation operator. This is forward-compatible to Git's ignore syntax. * matches any string of characters. ? matches any single character. [] brackets a character class; it matches any character in the class. So, for example, [0123456789] would match any decimal digit. [!] brackets a negated character class; [!0123456789] would match any character not a decimal digit. """, } def help_method(*args): "Summarize src commands, or (with argument) show help for a single command." if not args: sys.stdout.write(help_topics['topics']) for arg in args: if arg in args: if arg in help_topics: sys.stdout.write(help_topics[arg]) else: croak("%s is not a known help topic.\n%s" % (arg, help_topics['topics'])) def parse_as_revspec(token): "Does this look like something that should be parsed as a revision spec?" if "/" in token: return False elif ".." in token: return True elif token.count("-") == 1 and '.' not in token: return True elif token.isdigit(): return True elif token.startswith("@"): # Escape clause for tags that look like files return True else: return False ignorable = None def ignore(filename): "Should the specified file be ignored?" global ignorable if ignorable is None: ignorable = set([]) ignorable = set() if os.path.exists(".srcignore"): with open(".srcignore", "rb") as fp: for line in fp: # Use polystr to ensure internal data is Unicode in Python 3 line = polystr(line) if line.startswith("#") or not line.strip(): continue elif line.startswith("!"): ignorable -= set(glob.glob(line[1:].strip())) else: ignorable |= set(glob.glob(line.strip())) return (filename == repodir) or (filename in ignorable) class CommandContext: "Consume a revision specification or range from an argument list" def __init__(self, cmd, args, require_empty=False, default_to=None, parse_revspec=True): if not os.path.exists(repodir): croak("repository subdirectory %s does not exist" % repodir) self.start = self.end = None self.seq = None self.branchwise = None if type(args) == type(()): args = list(args) self.args = list(args) self.default_to = default_to self.lo = self.start self.hi = self.end revspec = None if self.args: if self.args[0] == "--": self.args.pop(0) elif parse_revspec and parse_as_revspec(args[0]): revspec = self.args.pop(0) if revspec.startswith("@"): revspec = revspec[1:] try: if "-" in revspec or ".." in revspec: self.branchwise = ".." in revspec try: (self.start, self.end) = revspec.split("-") except ValueError: try: (self.start, self.end) = revspec.split("..") except ValueError: croak("internal error - argument parser is confused") try: self.start = int(self.start) except ValueError: pass try: self.end = int(self.end) except ValueError: pass else: try: self.end = self.start = int(revspec) except ValueError: self.end = self.start = revspec except ValueError: croak("malformed revision spec: %s" % revspec) if require_empty and not self.is_empty(): croak("%s doesn't take a revision spec" % cmd) if not self.args: try: masters = [fn for fn in os.listdir(repodir) if is_history(fn)] masters.sort() except OSError: croak("repo directory %s does not exist" % repodir) if masters: self.args += [backend.workfile(master) for master in masters] else: croak("%s requires at least one file argument" % cmd) def is_empty(self): "Is the spec empty?" return self.start is None def is_singleton(self): "Is the spec a singleton?" return self.start is not None and self.start == self.end def is_range(self): "Is the spec a range?" return self.start is not None and self.start != self.end def select_all(self, metadata): "Set the range to all revisions." self.lo = 1 self.hi = len(metadata) self.seq = [metadata.by_revno(i) for i in range(self.lo, self.hi+1)] def select_tip(self, metadata): "Set the range to the tip revision." self.lo = len(metadata) self.hi = None self.seq = [metadata.by_revno(self.lo)] def __contains__(self, i): "Does the spec contain the given revno?" if self.seq is None: croak("revision spec hasn't been resolved") return i in self.seq def resolve(self, metadata): "Resolve a revision spec that may contain tags into revnos." if debug >= DEBUG_SEQUENCE: sys.stderr.write("Entering resolve with start=%s, end=%s\n" % (self.start, self.end)) if self.is_empty(): if self.default_to == "branch": self.seq = metadata.current_branch(backwards=False) elif self.default_to == "branch_reversed": self.seq = metadata.current_branch(backwards=True) else: self.seq = [] return self.seq def subresolve(token): part = token if type(part) == type(0): return part if token == '': # User specified @ current = metadata.current() if current is None: croak("in {0}, no current revision".format(metadata.name)) return current.revno if part not in metadata.symbols: croak("in {0}, can't resolve symbol {1}".format(metadata.name,token)) else: part = metadata.symbols[part] if backend.isbranch(part): part = backend.branch_to_tip(part, metadata) return metadata.native_to_revno(part) self.lo = subresolve(self.start) self.hi = subresolve(self.end) mreversed = (self.lo > self.hi) if mreversed: swapme = self.hi self.hi = self.lo self.lo = swapme if self.hi > len(metadata): croak("{0} has no {1} revision".format(metadata.name, self.hi)) if not self.branchwise: self.seq = [metadata.by_revno(i) for i in range(self.lo, self.hi+1)] else: self.seq = [] e = metadata.by_revno(self.hi) while True: self.seq.append(e) if e.revno == self.lo: break if e.parent is None: croak("%s is not an ancestor of %s" % (self.lo, self.hi)) else: e = e.parent if debug >= DEBUG_SEQUENCE: sys.stderr.write("selection: %s, branchwise is %s\n" % ([x.revno for x in self.seq], "on" if self.branchwise else "off")) for item in metadata.revlist: sys.stdout.write("%s\t%s\t%s\n" % (item.revno, item.date, item.native)) # Because in the branchwise case the sequence is generated in reverse if self.branchwise: self.seq.reverse() # Range might have been reversed if mreversed: self.seq.reverse() return self.seq class CommentContext: COMMENT_CUTLINE = """\ ............................................................................. """ COMMENT_EXPLANATION = """\ The cut line and things below it will not become part of the comment text. """ def __init__(self, legend, args): "Attempt to collect a comment from command line args." self.leader = "" self.comment = None self.force_edit = False self.parse_revspec = True if args: if args[0] == '--': self.parse_revspec = False args.pop(0) elif args[0] == "-": self.leader = sys.stdin.read() args.pop(0) elif args[0] == "-e": self.force_edit = True elif args[0] == "-m": args.pop(0) try: self.leader = args[0] args.pop(0) except IndexError: croak("%s -m requires a following string" % legend) elif args[0].startswith("-m"): self.leader = args[2:] args.pop(0) elif args[0] == "-f": args.pop(0) try: # Read filesystem data as binary for robustness, but # decode to Unicode for internal use with open(args[0], "rb") as fp: self.leader = polystr(fp.read()) args.pop(0) except IndexError: croak("%s -f requires a following filename argument" % legend) except OSError: croak("couldn't open %s." % args[1]) elif args[0].startswith("-"): croak("unexpected %s option" % args[0]) def edit(self, content="", trailer="", diff=None): "Interactively edit a comment if required, then prepare for handoff." if self.leader and not self.force_edit: self.comment = self.leader else: orig_content = content if self.leader: content = self.leader + content if trailer or diff: content += "\n" + CommentContext.COMMENT_CUTLINE + CommentContext.COMMENT_EXPLANATION + trailer editor = os.getenv("EDITOR") or "emacsclient" try: # Use polybytes to ensure that binary data is written # on Python 3 with tempfile.NamedTemporaryFile(prefix = "src", suffix = "tmp", delete = False) as fp: commentfile = fp.name fp.write(polybytes(content)) if diff: fp.write(b"\nChanges to be committed:\n") for s in diff: fp.write(polybytes(s)) fp.write(b"\n") do_or_die(editor + " " + commentfile, mute=False) # Use polystr to ensure that incoming data is decoded # to Unicode on Python 3 with open(commentfile, "rb") as fp: self.comment = polystr(fp.read()) os.unlink(commentfile) except IOError: croak("edit aborted.") where = self.comment.find(CommentContext.COMMENT_CUTLINE) if where != -1: self.comment = self.comment[:where] self.comment = self.comment.strip() if self.comment == orig_content.strip() or not self.comment: return False # Can be removed if we ever parse RCS/SCCS files directly for badnews in backend.delimiters: if badnews in self.comment: croak("malformed comment") if not self.comment.endswith("\n"): self.comment += "\n" return True def content(self): "Return the edited comment." return self.comment def external_diff(file0, s0, file1, s1, unified=True, ignore_ws=None): "Compute diff using external program." def writetmp(s): with tempfile.NamedTemporaryFile(prefix = "src", suffix = "tmp", delete = False) as fp: fp.write(polybytes(s)) return fp.name if unified: opts, tok0, tok1 = '-u', '-', '+' else: opts, tok0, tok1 = '-c', '*', '-' if ignore_ws: opts += ' ' + ignore_ws tmp0 = writetmp(s0) tmp1 = writetmp(s1) with popen_or_die('diff %s "%s" "%s" || :' % (opts, tmp0, tmp1)) as fp: diff = polystr(fp.read()) os.unlink(tmp0) os.unlink(tmp1) diff = re.sub(r"(?m)^([%s]{3} ).+$" % tok0, r"\1" + file0, diff, 1) diff = re.sub(r"(?m)^([%s]{3} ).+$" % tok1, r"\1" + file1, diff, 1) return diff.split('\n') def compute_diff(metadata, lo, hi, differ, ignore_ws=None): """Compute diff between two revs of a file. If 'lo' is None, then this is a "creation event" in which 'hi' materializes fully formed from nothing. If 'hi' is None, then diff 'lo' against the working file. File must already have been "lifted".""" name = metadata.name if lo is None: file0 = '/dev/null' old_content = '' else: file0 = name + ' (r' + str(lo) + ')' with backend.cat(name, metadata.revno_to_native(lo)) as fp: old_content = fp.read() # this data will be binary if hi is None: file1 = name + ' (workfile)' with open(name, "rb") as fp: new_content = fp.read() else: file1 = name + ' (r' + str(hi) + ')' with backend.cat(name, metadata.revno_to_native(hi)) as fp: new_content = fp.read() # this data will be binary # Don't list identical files (comparison uses binary data # for maximum accuracy). if old_content == new_content: return () # All operations here will need Unicode in Python 3 if ignore_ws: return external_diff(file0, old_content, file1, new_content, differ == difflib.unified_diff, ignore_ws) lines0 = polystr(old_content).split('\n') lines1 = polystr(new_content).split('\n') return differ(lines0, lines1, fromfile=file0, tofile=file1, lineterm="") def colorize_unified(s): for x in colorize_unified.colors: if s.startswith(x[0]): return x[1] + s + RESET return s colorize_unified.colors = (('+++ ', BOLD), ('--- ', BOLD), ('@@ ', CCYAN), ('+', CGREEN), ('-', CRED)) def print_diff(metadata, lo, hi, differ, ignore_ws=None): "Dump diff between revisions to standard output." if differ == difflib.unified_diff: colorizer = colorize_unified else: colorizer = lambda x: x with backend.lifter(metadata.name): for line in compute_diff(metadata, lo, hi, differ, ignore_ws): sys.stdout.write(colorizer(line) + "\n") def exec_copy(source, target): if os.path.exists(target): oldtargetmode = newtargetmode = os.stat(target).st_mode sourcemode = os.stat(source).st_mode for bitmask in (stat.S_IXUSR, stat.S_IXGRP, stat.S_IXOTH): if bitmask & sourcemode: newtargetmode |= bitmask else: newtargetmode &=~ bitmask if newtargetmode != oldtargetmode: os.chmod(target, newtargetmode) def checkout_method(*args): "Refresh the working copy from the history file." ctx = CommandContext("checkout", args) if ctx.is_range(): croak("checkout needs an empty or singleton revision spec") for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.select_tip(metadata) revision = "" elif ctx.lo > len(metadata): croak("%s has only %d revisions" % (arg, len(metadata))) else: revision = metadata.revno_to_native(ctx.lo) with backend.lifter(arg): backend.checkout(arg, revision) if not quiet and len(args) > 1: announce("%s <- %d" % (arg, ctx.lo)) def commit_method(*args): "Commit changes to files." if not os.path.exists(repodir): try: os.mkdir(repodir) except OSError: croak(" %s creation failed, check directory permissions." % repodir) args = list(args) register_only = False parse_revspec = True differ = difflib.unified_diff while args: if args[0] == '--': args.pop(0) parse_revspec = False break elif args[0] == '-a': # The Emacs VC-mode support for SRC was written early, # before 1.0, when I hadn't quite figured out what the # most efficient method for file registration would be. # VC-mode wants to have a registration as well as a # checkin method. This is no longer needed for normal SRC # operation, but it's better to leave this in place than # risk causing hassles for people running old Enacs versions. register_only = True parse_revspec = False args.pop(0) else: break if not register_only: comment = CommentContext("commit", args) ctx = CommandContext("commit", args, require_empty=True, parse_revspec=parse_revspec and comment.parse_revspec) for arg in ctx.args: if not os.path.exists(arg): croak("I see no '%s' here." % arg) if os.path.isdir(arg): croak("cannot commit directory '%s'" % arg) for arg in ctx.args: if not registered(arg): trailer = "Committing initial revision of {0}.\n".format(arg) revcount = 0 metadata = None diff = compute_diff(type('', (), {'name':arg}), None, None, differ) elif register_only: croak("attempt to re-add a registered file failed") else: metadata = History(arg) ctx.resolve(metadata) if metadata and ctx.is_empty(): ctx.select_tip(metadata) revcount = len(metadata) trailer = "Committing {0} revision {1}.\n".format(arg, revcount+1) with backend.lifter(arg): diff = compute_diff(metadata, ctx.lo, None, differ) if not register_only and not diff: announce("in %s, no changes to commit" % arg) continue if not register_only and not comment.edit('', trailer, diff): announce("in %s, commit cancelled" % arg) else: if not registered(arg): backend.register(arg) if not register_only: with backend.lifter(arg): # If the user changed the executable bit while # modifying the workfile, propagate this change to # the master. Without this hack, the sequence (1) # Commit workfile (2) Make workfile executable, (3) # checkin workfile fails to work as expected because # the VCS doesn't propagate the changed executable # bit to the master, leading to misbehavior on the # next checkout. exec_copy(arg, backend.history(arg)) backend.checkin(arg, comment.content()) if metadata is None: metadata = History(arg) modified(arg, metadata) if not quiet and len(args) > 1: announce("%s -> %d" % (arg, revcount)) def add_method(*args): "For Emacs VC compatibility." commit_method("-a", *args) def amend_method(*args): "Amend comments in stored revisions." if not os.path.exists(repodir): croak("repository subdirectory %s does not exist" % repodir) args = list(args) differ = difflib.unified_diff comment = CommentContext("amend", args) ctx = CommandContext("amend", args, parse_revspec=comment.parse_revspec) if ctx.is_range(): croak("amend cannot take a range") for arg in ctx.args: if not os.path.exists(arg): croak("I see no '%s' here." % arg) elif not registered(arg): croak("%s is not registered." % arg) for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.lo = metadata.tip().revno trailer ="Amending {0} revision {1}.\n".format(arg, ctx.lo) item = metadata.by_revno(ctx.lo) parent = item.parent.revno if item.parent else None with backend.lifter(arg): diff = compute_diff(metadata, parent, ctx.lo, differ) if not comment.edit(metadata.by_revno(ctx.lo).log, trailer, diff): announce("in %s, amend cancelled" % arg) else: with backend.lifter(arg): backend.amend(arg, metadata.revno_to_native(ctx.lo), comment.content()) if not quiet and len(args) > 1: announce("%s : %d" % (arg, ctx.lo)) def list_method(*args): "Generate a summary listing of commits, one line per commit." args = list(args) custom = None limit = None parse_revspec = True while args and args[0].startswith("-"): if args[0] == '--': parse_revspec = False args.pop(0) break elif args[0] == "-f": args.pop(0) try: custom = args[0] args.pop(0) except IndexError: croak("list -f requires a following string") elif args[0].startswith("-f"): custom = args[0][2:] args.pop(0) elif args[0] == "-l": args.pop(0) try: limit = args[0] args.pop(0) limit = int(limit) except IndexError: croak("list -l requires a following integer") except ValueError: croak("%s is not an integer" % limit) elif args[0][1:].isdigit(): limit = int(args.pop(0)[1:]) # it's all digits, so no ValueError else: croak("unexpected %s option" % args[0]) ctx = CommandContext("list", args, default_to="branch_reversed", parse_revspec=parse_revspec) for arg in ctx.args: if ignore(arg) or os.path.isdir(arg) or not registered(arg): continue if custom is None: sys.stdout.write("= %s %s\n" % (arg, ((WIDTH - len(arg) - 3) * "="))) for item in ctx.resolve(History(arg)): # Must allow enough room for revno and date if item.selected(): mark = "*" else: mark = "-" summary = item.log.split('\n')[0] if custom is None: summary = summary[:WIDTH - 34] sys.stdout.write("%-4d %s %s %s\n" \ % (item.revno, mark, item.getdate('author'), summary)) else: sys.stdout.write(custom.format(arg, item.revno, mark, item.getdate('author'), summary)) if limit is not None: limit -= 1 if limit <= 0: break def log_method(*args): "Report revision logs" limit = None args = list(args) parse_revspec = True differ = None ignore_ws = None verbose = 0 while args and args[0].startswith("-"): if args[0] == '--': parse_revspec = False args.pop(0) break elif args[0] == "-l": args.pop(0) try: limit = args[0] args.pop(0) limit = int(limit) except IndexError: croak("list -l requires a following integer") except ValueError: croak("%s is not an integer" % limit) elif args[0][1:].isdigit(): limit = int(args.pop(0)[1:]) # it's all digits, so no ValueError elif args[0] in ('--patch', '-p', '-u'): differ = difflib.unified_diff args.pop(0) elif args[0] == '-c': differ = difflib.context_diff args.pop(0) elif args[0] in ('-b', '-w'): ignore_ws = args.pop(0) elif args[0] == '-v': verbose += 1 args.pop(0) else: croak("unexpected %s option" % args[0]) ctx = CommandContext("log", args, default_to="branch_reversed", parse_revspec=parse_revspec) for arg in ctx.args: if ignore(arg) or os.path.isdir(arg) or not registered(arg): continue sys.stdout.write("= %s %s\n" % (arg, ((WIDTH - len(arg) - 3) * "="))) metadata = History(arg) for item in ctx.resolve(metadata): sys.stdout.write("%s%-4d%s | %s%s%s | %s%s%s\n" \ % (BOLD + CCYAN, item.revno, RESET, CYELLOW, item.getdate('author'), RESET, BOLD + CGREEN, item.branch, RESET)) if verbose and item.headers: headers = item.headers if verbose == 1: headers = {} for k in ('author', 'committer'): if k in item.headers: v = item.headers[k] if k + "-date" in item.headers: v += " " + item.headers[k + "-date"] headers[k] = v for k in sorted(headers.keys()): sys.stdout.write("%s%s%s: %s\n" % (BOLD, k.title(), RESET, headers[k])) sys.stdout.write("\n") sys.stdout.write("%s" % item.log) if differ: if item.parent: parent = item.parent.revno pdesc = 'r%d/%s' % (parent, arg) else: parent = None pdesc = '/dev/null' sys.stdout.write("\n%sdiff %s r%s/%s%s\n" % (BOLD, pdesc, item.revno, arg, RESET)) print_diff(metadata, parent, item.revno, differ, ignore_ws) sys.stdout.write(("-" * WIDTH) + "\n") if limit is not None: limit -= 1 if limit <= 0: break def status_method(*args): "Get status of some or all files." try: managed = [fn for fn in os.listdir(repodir) if is_history(fn)] except OSError: croak("repo directory %s does not exist" % repodir) args = list(args) allflag = False if args: if args[0] == '--': args.pop(0) elif args[0] == '-a': allflag = True args.pop(0) if args: candidates = args else: candidates = [f for f in os.listdir(".") if f != repodir] pairs = [] for fn in candidates: if ignore(fn): if allflag or fn in args: pairs.append((fn, "I")) continue masterbase = os.path.basename(backend.history(fn)) if masterbase not in managed: if allflag or fn in args: if not os.access(fn, os.R_OK): croak("%s does not exist or is unreadable." % fn) else: pairs.append((fn, "?")) elif not os.path.exists(fn): pairs.append((fn, "!")) elif modified(fn): pairs.append((fn, "M")) elif not os.access(fn, os.W_OK): pairs.append((fn, "L")) elif not backend.has_revisions(fn): pairs.append((fn, "A")) else: pairs.append((fn, "=")) if not args: for m in managed: if backend.workfile(m) not in candidates: pairs.append((m, "!")) pairs.sort() for (fn, status) in pairs: sys.stdout.write(status + "\t" + fn + "\n") def cat_method(*args): "Dump revision content to standard output." ctx = CommandContext("cat", args) if ctx.is_range(): croak("cat refuses to cough up a hairball") elif ctx.args[0] == '--': ctx.args.pop(0) for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.select_tip(metadata) with backend.lifter(arg): for item in ctx.seq: with backend.cat(arg, item.native) as fp: # Use polystr to ensure that sys.stdout gets Unicode # in Python 3. sys.stdout.write(polystr(fp.read())) def diff_method(*args): "Dump diffs between revisions to standard output." if type(args) == type(()): args = list(args) differ = difflib.unified_diff ignore_ws = None while args and args[0] != '--' and args[0].startswith("-"): if args[0] == '-u': differ = difflib.unified_diff args.pop(0) elif args[0] == '-c': differ = difflib.context_diff args.pop(0) elif args[0] in ('-b', '-w'): ignore_ws = args.pop(0) else: croak("unexpected %s option" % args[0]) ctx = CommandContext("diff", args) for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.select_tip(metadata) print_diff(metadata, ctx.lo, ctx.hi, differ, ignore_ws) def tag_helper(args, legend, validation_hook, delete_method, set_method): "Dispatch to handlers for tag and branch manipulation." if not os.path.exists(repodir): croak("repository subdirectory %s does not exist" % repodir) args = list(args) if not args: args = ["list"] + args if args[0] == '--': args.pop(0) else: if args[0] in ("-d", "del", "delete"): args.pop(0) if not args: croak("%s deletion requires a name argument" % legend) name = args.pop(0) ctx = CommandContext(legend, args) if not ctx.is_empty(): croak("can't accept a revision-spec when deleting a %s." % legend) for arg in ctx.args: metadata = History(arg) if name not in metadata.symbols: croak("in %s, %s is not a symbol" % (arg, name)) elif backend.isbranch(metadata.symbols[name]) != (legend == "branch"): croak("in %s, %s is not a %s" % (arg, name, legend)) else: with backend.lifter(arg): delete_method(name, metadata) if not quiet and len(args) > 1: announce("in %s, %s %s removed" % (arg, legend, name)) return if args[0] in ("-l", "list"): args.pop(0) ctx = CommandContext(legend + " listing", args, require_empty=True) for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): prepend = [0] ctx.select_all(metadata) else: prepend = [] revisions = prepend + [item.revno for item in ctx.seq] sys.stdout.write("= %s %s\n" \ % (arg, ((WIDTH - len(arg) - 5) * "="))) keys = list(metadata.symbols.keys()) if metadata.branch in keys: keys.remove(metadata.branch) keys.sort() keys = [metadata.branch] + keys for key in keys: value = metadata.symbols[key] if legend == "branch": # Note! This code relies on # backend.branch_to_parent() returning an empty # string when called on a trunk revision. displaystr = backend.branch_to_parent(value) if not displaystr: display = 0 else: display = metadata.native_to_revno(displaystr) else: display = metadata.native_to_revno(value) if display in revisions and backend.isbranch(value) == (legend == "branch"): sys.stdout.write("%4s\t%s\n" % (display,key)) return if args[0] in ("-c", "create"): args.pop(0) if not args: croak("%s setting requires a name argument" % legend) name = args.pop(0) ctx = CommandContext(legend, args) if ctx.is_range(): croak("can't accept a range when setting a %s" % legend) for arg in ctx.args: metadata = History(arg) revision = validation_hook(ctx, metadata, name) with backend.lifter(arg): set_method(name, revision, metadata) if not quiet and len(args) > 1: announce("in %s, %s %s = %s" % (arg, legend, name, ctx.start)) return else: croak("%s requires a list, create, or delete modifier" % legend) def tag_method(*args): "Inspect, create, and delete tags." def tag_set_validate(ctx, metadata, name): ctx.resolve(metadata) if name in metadata.symbols: croak("tag %s already set." % name) if ctx.is_empty(): ctx.select_tip(metadata) return metadata.revno_to_native(ctx.lo) tag_helper(args, "tag", tag_set_validate, backend.delete_tag, backend.set_tag) def branch_method(*args): "Inspect, create, and delete branches." def branch_set_validate(ctx, _metadata, _name): if not ctx.is_empty(): croak("cannot accept a revision after a branch name") tag_helper(args, "branch", branch_set_validate, backend.delete_branch, backend.set_branch) def rename_method(*args): "Rename a branch or tag." args = list(args) if not args or args[0] not in ("tag", "branch"): croak("rename requires a following 'tag' or 'branch'") legend = args.pop(0) if not args: croak("rename requires a source name argument") name = args.pop(0) if not args: croak("rename requires a target name argument") newname = args.pop(0) ctx = CommandContext(legend + " renaming", args, require_empty=True) for arg in ctx.args: metadata = History(arg) if name not in metadata.symbols: croak("in %s, cannot rename nonexistent %s %s" % (arg, legend, name)) if newname in metadata.symbols: croak("in %s, cannot rename to existing %s %s" % (arg, legend, name)) ctx = CommandContext(legend, args) if not ctx.is_empty(): croak("can't accept a revision-spec when renaming a %s." \ % legend) # In the case of a branch, we want to change only the # tag reference. with backend.lifter(arg): backend.set_tag(newname, metadata.symbols[name], metadata) backend.delete_tag(name, metadata) if not quiet and len(args) > 1: announce("in %s, %s -> %s" % (arg, name, newname)) def filecmd(legend, hook, args): CommandContext(legend, args, require_empty=True) if len(args) != 2: croak("%s requires exactly two arguments" % legend) (source, target) = args if not os.path.exists(source): croak("I see no '%s' here." % source) elif os.sep in target and not os.path.exists(os.path.dirname(target)): croak("directory '%s' does not exist." % target) elif not registered(source): croak("%s is not registered" % source) elif registered(target): croak("%s is registered, I won't step on it" % source) elif os.path.exists(target): croak("%s exists, please delete manually if you want it gone" % target) else: hook(source, target) def move_method(*args): "Move a file and its history." filecmd("move", backend.move, args) def copy_method(*args): "Copy a file and its history." filecmd("copy", backend.copy, args) def release_method(*args): "Release locks." ctx = CommandContext("release", args, require_empty=True) for arg in ctx.args: if not os.path.exists(arg): croak("I see no '%s' here." % arg) elif not registered(arg): croak("%s is not registered, skipping" % arg) else: with backend.lifter(arg): backend.release(arg) def srcify_method(*args): "Move an RCS or SCCS directory into SRC management." if args: croak("lift cannot accept arguments") if not os.path.isdir("RCS") and not os.path.isdir("SCCS"): croak("no RCS or SCCS directory") candidates = [f for f in os.listdir(".") if os.path.isfile(f) and not os.path.islink(f)] for fn in candidates: if registered(fn) and (not os.path.exists(fn) or not modified(fn)): with backend.lifter(fn): backend.checkout(fn, "") if os.path.isdir("RCS"): os.rename("RCS", ".src") def ls_method(*args): "List registered files." if args: croak("ls cannot accept arguments") try: masters = [fn for fn in os.listdir(repodir) if is_history(fn)] except OSError: croak("repo directory %s does not exist" % repodir) masters.sort() for master in masters: sys.stdout.write(backend.workfile(master) + "\n") def visualize_method(*args): "Generate (and possibly display) a DOT visualization of repo structure." if not os.path.exists(repodir): croak("repository subdirectory %s does not exist" % repodir) args = list(args) comment = CommentContext("visualize", args) ctx = CommandContext("visualize", args, parse_revspec=comment.parse_revspec) for arg in ctx.args: #if not os.path.exists(arg): # croak("I see no '%s' here." % arg) if not registered(arg): croak("%s is not registered." % arg) for arg in ctx.args: metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.select_all(metadata) sys.stdout.write("digraph {\n") if len(ctx.args) > 1: pref = arg + ":" else: pref = "" for item in ctx.seq: if item.parent: sys.stdout.write('\t%s%d -> %s%d;\n' \ % (pref, item.parent.revno, pref, item.revno)) summary = cgi.escape(item.log.split('\n')[0][:42]) sys.stdout.write('\t%s%s [shape=box,width=5,label=<
%s%s%s
>];\n' \ % (pref, item.revno, pref, item.revno, summary)) if metadata.tip(item.native) == item: sys.stdout.write('\t"%s%s" [shape=oval,width=2];\n' \ % (pref, item.branch)) sys.stdout.write('\t"%s%s" -> "%s%s" [style=dotted];\n' \ % (pref, item.revno, pref, item.branch)) keys = sorted(metadata.symbols.keys()) for name in keys: native = metadata.symbols[name] branch_label = backend.isbranch(native) if branch_label: native = backend.branch_to_tip(native, metadata) revno = metadata.native_to_revno(native) if not branch_label: sys.stdout.write('\t{rank=same; "%s%s"; "%s%s"}\n' \ % (pref, name, pref, revno)) sys.stdout.write('\t"%s%s" -> "%s%s" [style=dotted];\n' \ % (pref, name, pref, revno)) sys.stdout.write("}\n") def fast_export_method(*args): "Dump revision content to standard output." def attribute(item, who, fallback): s = fallback if item.headers and who in item.headers: s = item.headers[who] t, o = item.unixtime(who) return "%s %s %d %s%02d%02d\n" % \ ((who, s, t, "-" if o < 0 else "+") + divmod(abs(o), 3600)) ctx = CommandContext("fast-export", args) mark = 0 if pseudotime: username = "J. Random Hacker" useremail = "jrh@nowhere.man" else: # Use polystr to ensure that data is decoded to Unicode on # Python 3. username = polystr(capture_or_die("git config --get user.name")).strip() useremail = polystr(capture_or_die("git config --get user.email")).strip() attribution = "%s <%s>" % (username, useremail) markmap = {} tips = {} last_commit_mark = 0 for arg in ctx.args: if not registered(arg): croak("%s is not registered" % arg) executable = os.stat(backend.history(arg)).st_mode & stat.S_IXUSR if executable: perms = "100755" else: perms = "100644" metadata = History(arg) ctx.resolve(metadata) if ctx.is_empty(): ctx.select_all(metadata) with backend.lifter(arg): for i in range(ctx.lo, ctx.hi+1): item = metadata.by_revno(i) with backend.cat(arg, item.native) as fp: content = fp.read() # this data will be binary size = len(content) # size will be # of bytes, as desired mark += 1 markmap[item.revno] = mark sys.stdout.write("blob\nmark :%d\ndata %d\n" % (mark, size)) # Use polystr to ensure sys.stdout gets Unicode in Python 3 sys.stdout.write(polystr(content) + "\n") # FIXME: Make this canonical even with tags. # This is tricky; see reposurgeon's rules for branch coloring. branch = item.branch if branch == "trunk": branch = "master" oldbranch = branch for c in "~^\\*?": branch = branch.replace(c, "") if not branch: croak("branch name %s is ill-formed" % oldbranch) elif branch != oldbranch: announce("branch name %s sanitized to %s" % (oldbranch, branch)) if branch not in tips: sys.stdout.write("reset refs/heads/" + branch + "\n") sys.stdout.write("commit refs/heads/%s\n" % branch) sys.stdout.write("mark :%d\n" % (mark + 1)) sys.stdout.write(attribute(item, "author", attribution)) sys.stdout.write(attribute(item, "committer", attribution)) sys.stdout.write("data %s\n%s" % (len(item.log), item.log)) if last_commit_mark: sys.stdout.write("from :%d\n" % last_commit_mark) if len(arg.split()) > 1: arg = '"' + arg + '"' sys.stdout.write("M %s :%d %s\n\n" % (perms, mark, arg)) mark += 1 last_commit_mark = mark markmap[item.revno] = mark tips[branch] = mark for (key, val) in list(metadata.symbols.items()): val = metadata.native_to_revno(val) if val in ctx: sys.stdout.write("reset refs/tags/%s\nfrom :%d\n\n" % (key, markmap[val])) for branch in tips: sys.stdout.write("reset refs/heads/%s\nfrom :%d\n\n" % (branch, tips[branch])) def fast_import_method(*args): "Accept a git fast-import stream on stdin, turn it into file histories." if not isinstance(backend, RCS): croak("fast-import is only supported with the RCS backend") if os.path.exists("RCS"): croak("refusing to unpack into existing RCS directory!") # Force -l to fit SRC's lockless interface. do_or_die(r"rcs-fast-import -l " +" ".join(args), missing="rcs-fast-import") try: os.makedirs(repodir) except OSError: pass for fn in os.listdir("RCS"): corresponding = os.path.join("RCS", os.path.basename(fn)) fn = os.path.join(repodir, os.path.basename(fn)) if os.path.exists(fn): croak("%s exists, aborting leaving RCS in place!" % corresponding) os.rename(corresponding, fn) shutil.rmtree("RCS") def version_method(*args): "Report SRC's version" sys.stdout.write("src: %s\n" % version) (major, minor, micro, _releaselevel, _serial) = sys.version_info sys.stdout.write("python: %s.%s.%s\n" % (major, minor, micro)) sys.stdout.write("%s: %s\n" % (backend.__class__.__name__,backend.version())) sys.stdout.write("platform: %s\n" % sys.platform) if os.path.exists(".git"): sys.stdout.write("revision: %s\n" % capture_or_die("git rev-parse HEAD")) dispatch = { "help": help_method, "commit": commit_method, "ci": commit_method, "add": add_method, "amend": amend_method, "am": amend_method, "list": list_method, "li": list_method, "log": log_method, "checkout": checkout_method, "co": checkout_method, "status": status_method, "st": status_method, "cat": cat_method, "diff": diff_method, "di": diff_method, "tag": tag_method, "branch": branch_method, "rn": rename_method, "rename": rename_method, "ls": ls_method, "move": move_method, "mv": move_method, "copy": copy_method, "cp": copy_method, "visualize": visualize_method, "vis": visualize_method, "fast-export": fast_export_method, "fast-import": fast_import_method, "release": release_method, "srcify": srcify_method, "version": version_method, } class RevisionMixin: "Express common operations on RCS and SCCS revisions." def splitrev(self, rev): "RCS revision to numeric tuple." return [int(d) for d in rev.split(".")] def joinrev(self, rev): "Numeric tuple to RCS revision." return ".".join([str(d) for d in rev]) def pred(self, rev): "Our predecessor. Walks up parent branch." n = self.splitrev(rev) if n[-1] > 1: n[-1] -= 1 rev = self.joinrev(n) else: rev = self.joinrev(n[:-2]) return rev def succ(self, rev): "Our successor." if rev: n = self.splitrev(rev) n[-1] += 1 return self.joinrev(n) else: return "1.1" def isbranch(self, symbol): "Is this a branch symbol?" # RCS convention - this could work for SCCS too, if we simulated # RCS symbols in some way. return "0." in symbol def branch_to_parent(self, revid): "Go from a branch ID sticky tag to the revision it was based on." # Must return an empty string for the fake root sticky tag. return self.joinrev(self.splitrev(revid)[:-2]) def branch_to_base(self, revid, metadata): "Go from a branch ID sticky tag to the first revision of its branch." rev = self.branch_to_parent(revid) if rev: rev += ".1.1" else: rev = "1.1" return rev def branch_to_tip(self, revid, metadata): "Go from a branch ID sticky tag to the tip revision of its branch." rev = self.branch_to_base(revid, metadata) while True: nxt = self.succ(rev) if metadata.native_to_revno(nxt) is None: return rev else: rev = nxt croak("internal error: couldn't find branch tip of %s" % rev) def branch_stickybase(self, name, revision, metadata): "Compute a base and tip revision for a named branch." if name in metadata.symbols: # Must unstickify... base = metadata.symbols[name].split(".") base = base[:-2] + base[-1:] base = ".".join(base) return(None, base) else: def branchfrom(c, p): "Is c a branch child (not direct descendant) of parent p?" c = c.split(".") p = p.split(".") return len(c) == len(p) + 2 and c[len(p):] == p baserev = metadata.current() newsib = len([item for item in metadata.revlist \ if branchfrom(item.native, baserev)]) newsib += 1 base = baserev + "." + str(newsib) sticky = baserev + ".0." + str(newsib) return (sticky, base) def branch_initial(self, branchname, metadata): "Return initial commit of a named branch (the child of the root)." # What we need to do is find the branch tip, then walk back to # just after the first point where it joins another branch, then # do a delete to end of branch from there. base = self.branch_to_tip(metadata.symbols[branchname], metadata) while True: if base is not None and metadata.by_native_d[base].branches: break else: base = self.pred(base) return self.succ(base) class RCS(RevisionMixin): "Encapsulate RCS back end methods." delimiters = ('----------------------------', '=============================================================================') class RCSLifter: "Temporarily lift a master to the working directory." def __init__(self, name): self.name = name self.where = os.getcwd() self.deferred = [] self.previous_handlers = {} if os.path.exists(".src") and os.path.exists("RCS"): croak("both .src and RCS exist - bailing out.") def defer_signal(self, sig_num, stack_frame): self.deferred.append(sig_num) def __enter__(self): # Replace existing signal handlers with deferred handler for sig_num in (signal.SIGHUP, signal.SIGINT, signal.SIGTERM): # signal.signal returns None when no handler has been # set in Python, which is the same as the default # handler (SIG_DFL) being set self.previous_handlers[sig_num] = ( signal.signal(sig_num, self.defer_signal) or signal.SIG_DFL) if os.path.dirname(self.name): os.chdir(os.path.dirname(self.name)) if repodir == ".src" and not os.path.exists("RCS"): os.rename(".src", "RCS") def __exit__(self, extype, value, traceback_unused): os.chdir(self.where) if extype and debug > 0: raise extype(value) if repodir == ".src" and not os.path.exists(".src"): os.rename("RCS", ".src") # Restore handlers for sig_num, handler in self.previous_handlers.items(): signal.signal(sig_num, handler) # Send deferred signals while self.deferred: sig_num = self.deferred.pop(0) os.kill(os.getpid(), sig_num) return True def lifter(self, name): return RCS.RCSLifter(name) def history(self, arg): # The reason this is required is that we might not be within the # lifter context when this function is called. Thus we have to # check both possible locations for the master. for d in (backend.__class__.__name__, repodir): p = os.path.join(os.path.dirname(arg), d, os.path.basename(arg) + ",v") if os.path.exists(p): return p return p # Use repodir as a default for nonexistent targets @staticmethod def is_history(path): return path.endswith(",v") def has_revisions(self, arg): "Does the master for this file have any revisions" # The magic number 105 is the size of an empty RCS file (no # metadata, no revisions) at 76 bytes, plus 29 bytes. We assume # that this size has stayed constant or increased since ancient # times. In fact the size of an RCS file with revisions goes up # more - by the 78 bytes for the final, fixed line of the log # display. This gives us plenty of slack to cope with minor # format differences. # # The motivation here is to make "src status" faster by avoiding # the need for an entire log parse when checking for "A" status. return os.path.getsize(self.history(arg)) > 105 def workfile(self, arg): "Workfile corresponding to an RCS master" return arg[:-2] def register(self, arg): "Register a file" # Key choices here: -b suppresses all keyword expansion, -U sets # non-strict locking (which makes branch appends less painful). do_or_die("rcs -q -U -kb -i '{0}' /dev/null") m = re.search(r"[0-9]+\.[0-9]+\.[0-9]+".encode('ascii'),rawversion) return m and polystr(m.group(0)) def parse(self, metadata): "Get and parse the RCS log output for this file." def sortkey(rev): return rev.date + \ '.'.join('%010d' % int(n) for n in rev.native.split('.')) metadata.symbols["trunk"] = "0.1" with popen_or_die("cd %s >/dev/null; rlog %s 2>/dev/null; cd ..>/dev/null" % (repodir, metadata.name)) as fp: if debug >= DEBUG_PARSE: sys.stderr.write("\t-> init\n") state = "init" for line in fp: # All operations here will need Unicode in Python 3 line = polystr(line) if debug >= DEBUG_PARSE: sys.stderr.write("in: %s\n" % repr(line)) if state == "init": if line.startswith("locks:"): if debug >= DEBUG_PARSE: sys.stderr.write("\t-> locks\n") state = "locks" elif line.startswith("symbolic names:"): if debug >= DEBUG_PARSE: sys.stderr.write("\t-> symbols\n") state = "symbols" elif line.startswith("branch:"): branch = line.split(":")[1].strip() # Undocumented fact about RCS: The branch "1" # is the same as the blank branch. Significant # because you can't reset to the blank branch # using rcs -b, that resets to the dynamically # highest branch. if not branch or branch == "1": metadata.branch = "trunk" elif line.startswith("description:"): state = "description" elif state == "description": if line.startswith("============================"): break elif line.startswith("----------------------------"): if debug >= DEBUG_PARSE: sys.stderr.write("\t-> logheader\n") state = "logheader" metadata.revlist.append(HistoryEntry(metadata)) metadata.description = metadata.description[:-1] else: metadata.description += line elif state == "locks": if not line[0].isspace(): if debug >= DEBUG_PARSE: sys.stderr.write("\t-> init\n") state = "init" else: fields = line.strip().split() metadata.lockrevs.append(fields[1]) elif state == "symbols": if not line[0].isspace(): if debug >= DEBUG_PARSE: sys.stderr.write("\t-> init\n") state = "init" else: fields = line.strip().split() name = fields[0] if name.endswith(":"): name = name[:-1] rev = fields[1] metadata.symbols[name] = rev elif state == "logheader": if line.startswith("revision "): fields = line.split() metadata.revlist[-1].native = fields[1] elif line.startswith("----------------------------"): metadata.revlist.append(HistoryEntry(metadata)) elif line.startswith("date: "): fields = line.split() date = fields[1] + " " + fields[2] if date.endswith(";"): date = date[:-1] date = date.replace("/","-").replace(" ","T") + "Z" metadata.revlist[-1].date = date elif line.startswith("branches:"): continue elif line.startswith("======================="): # This deals with RCS v5.7 issuing a log header # divider just before the terminator, something # v5.8 does not do. if not metadata.revlist[-1].native: metadata.revlist.pop() elif not metadata.revlist[-1].log.endswith("\n"): metadata.revlist[-1].log += "\n" break elif line.strip() == "*** empty log message ***": continue elif metadata.revlist: metadata.revlist[-1].log += line # Now that we have the symbol table... if metadata.branch != "trunk": for (k, v) in list(metadata.symbols.items()): if v == metadata.branch: metadata.branch = k break else: croak("unrecognized branch ID '%s'" % branch) metadata.revlist.sort(key=sortkey) for (i, item) in enumerate(metadata.revlist): if pseudotime: # Artificial date one day after the epoch # to avoid timezone issues. item.date = rfc3339(86400 + i * 60) item.revno = i + 1 metadata.revlist.reverse() if debug >= DEBUG_PARSE: #sys.stdout.write("\t%d revisions\n" % len(metadata.revlist) sys.stdout.write("\tlockrevs: %s\n" % metadata.lockrevs) sys.stdout.write("\tsymbols: %s\n" % metadata.symbols) metadata.build_indices() # SCCS branch numbering (not supported yet) works differently from RCS # branch numbering. Node IDs have at most 4 parts in the form R.B.L.S # (release, level, branch, sequence): # # 1.0 - initial trunk version # 1.1 - next checkin on trunk # 1.1.1.0 - First branch from trunk v1.1 # 1.1.1.1 - Next checkin on that branch # 1.1.2.0 - Second branch from v1.1 # 1.2 - next checkin on trunk. # # The main difference is that in original AT&T SCCS you could not # branch from a branch, only from trunk. This restriction was removed # in at least some later versions, including CSSC and the Schilling # fork. In section 3.5.3 the CSSC manual says # # "When a branch is created from an existing sid, the release and level # numbers are copied, the branch number is set to the lowest unused # value for that release and level, and the sequence number is set to # one. Hence the first branch from version 1.1 will be version 1.1.1.1, # and if a branch is made from that, its sid will be 1.1.2.1." # # Jorg Schilling writes, 2018-11-29: "I cannot speak for RCS, but the # naming conventions used for branches in SCCS are not engraved into # the sources but rather a convention that is encouraged by the way # "get -e -b" works with or without -rSID option. SCCS internally uses # serial numbers and for this reason it is currently limited to 2G # deltas even though the R.B.L.S scheme could allow more. You could # even edit the p.file and control the SID that is used for the next # delget(1) as long as you don't violate basic rules." class SCCS(RevisionMixin): "Encapsulate SCCS back end methods." delimiters = ("-X-X-X-X-X--X-X-X-X-X--X-X-X-X-X-",) class SCCSLifter: "Temporarily lift a master to the working directory." def __init__(self, name): self.name = name self.where = os.getcwd() if not os.path.isdir("SCCS"): croak("no SCCS directory.") self.deferred = [] self.previous_handlers = {} def defer_signal(self, sig_num, stack_frame): self.deferred.append(sig_num) def __enter__(self): # Replace existing signal handlers with deferred handler for sig_num in (signal.SIGHUP, signal.SIGINT, signal.SIGTERM): # signal.signal returns None when no handler has been # set in Python, which is the same as the default # handler (SIG_DFL) being set self.previous_handlers[sig_num] = ( signal.signal(sig_num, self.defer_signal) or signal.SIG_DFL) def __exit__(self, extype, value, traceback_unused): # Restore handlers for sig_num, handler in self.previous_handlers.items(): signal.signal(sig_num, handler) # Send deferred signals while self.deferred: sig_num = self.deferred.pop(0) os.kill(os.getpid(), sig_num) return True def lifter(self, name): return SCCS.SCCSLifter(name) def __sccsfile(self, arg, pref): return os.path.join(os.path.dirname(arg), "SCCS", pref + "." + os.path.basename(arg)) def history(self, arg): return self.__sccsfile(arg, "s") @staticmethod def is_history(path): return path.startswith("s.") def has_revisions(self, arg): "Does the master for this file have any revisions" # It's not possible to create an SCCS file without at least one # revision. return True def workfile(self, arg): "Workfile corresponding to an SCCS master" return arg[2:] def register(self, arg): "Register a file" if not os.path.isdir("SCCS"): os.mkdir("SCCS") def checkin(self, arg, comment): "Check in a commit, with comment." comment = "'" + comment.replace("'", r"'\''") + "'" if os.path.exists(self.history(arg)): cmd = "delta -s -y{1} {0}".format(arg, comment) else: # Yuck - 2>/dev/null is required to banish the message # admin: warning: SCCS/XXXXX: No id keywords. cmd = "admin -fb -i '{0}' -y{1} <'{0}' 2>/dev/null".format(arg, comment) do_or_die("TZ=UTC sccs " + cmd) do_or_die("rm -f {0} && sccs get -e -s '{0}' >/dev/null".format(arg)) def checkout(self, arg, revision): "Check out a revision. Leaves it writeable." do_or_die("rm -f SCCS/p.{0}".format(arg)) if revision: do_or_die("rm -f '{0}' && sccs get -s -e -r{1} '{0}' >/dev/null".format(arg, revision)) else: do_or_die("rm -f '{0}' && sccs get -s -e '{0}' >/dev/null".format(arg)) def amend(self, arg, rev, comment): "Amend a commit comment." comment = "'" + comment.replace("'", r"'\''") + "'" do_or_die("sccs cdc -r{1} -y{2} '{0}'".format(arg, rev, comment)) def cat(self, arg, revision): "Ship the contents of a revision to stdout or a named file." if revision: return popen_or_die("sccs get -s -p -r{1} '{0}' 2>/dev/null".format(arg, revision)) else: return popen_or_die("sccs get -p {0}".format(arg)) def delete_tag(self, tagname, metadata): "Delete a specified tag." if "tags" in metadata.annotations and tagname in metadata.annotations["tags"]: del metadata.annotations["tags"][tagname] metadata.set_annotations() def set_tag(self, tagname, revision, metadata): "Set a specified tag." if "tags" not in metadata.annotations: metadata.annotations["tags"] = {} metadata.annotations["tags"][tagname] = revision.strip() metadata.set_annotations() def delete_branch(self, branchname, metadata): "Delete a specified branch." croak("branches are not supported in the SCCS back end") def set_branch(self, name, revision, metadata): "Set the specified branch to be default, creating it if required." croak("branches are not supported in the SCCS back end") def move(self, source, target): "Move a file and its history." do_or_die("mv '{0}' '{1}' && mv '{2}' '{3}'".format(source, target, self.history(source), self.history(target))) def copy(self, source, target): "Copy a file and its history." do_or_die("cp '{0}' '{1}' && cp '{2}' '{3}'".format(source, target, self.history(source), self.history(target))) def release(self, arg): "Release locks." do_or_die("sccs admin -dla '{0}'".format(arg)) def write_description(self, text, metadata): "Write description field. If text is empty, clear the field." if text: scribblefile = os.path.join(os.path.dirname(metadata.name),"SCCS",".scribble") # Write to filesystem as binary ASCII data for robustness with open(scribblefile, "wb") as wfp: wfp.write(polybytes(text) + b"\n") else: scribblefile = '' do_or_die("sccs admin -t{0} {1} 2>/dev/null".format(scribblefile, metadata.name)) if text: os.remove(scribblefile) def version(self): rawversion = capture_or_die("sccs --version 2>&1") m = re.search(r"[0-9]+\.[0-9]+\.[0-9]+".encode('ascii'), rawversion) return m and polystr(m.group(0)) def parse(self, metadata): "Get and parse the SCCS log output for this file." metadata.symbols["trunk"] = "0.1" with popen_or_die("sccs prs -e -d':FD::Dt:\n:C:{1}' {0} 2>/dev/null".format(metadata.name, SCCS.delimiters[0])) as fp: if debug >= DEBUG_PARSE: sys.stderr.write("\t-> init\n") state = "init" for line in fp: # All operations here will need Unicode in Python 3 line = polystr(line) if debug >= DEBUG_PARSE: sys.stderr.write("in %s: %s\n" % (state, repr(line))) if state == 'init': if line == 'none\n': line = '' metadata.description = line state = 'header' elif state == "header": comment = "" if line.startswith("D "): try: (_, rev, yymmdd, hhmmss) = line.split()[:4] metadata.revlist.append(HistoryEntry(metadata)) metadata.revlist[-1].native = rev yymmdd = CENTURY + yymmdd.replace('/','-') metadata.revlist[-1].date = yymmdd+"T"+hhmmss+"Z" except ValueError: croak("ill-formed delta line") if debug >= DEBUG_PARSE: sys.stderr.write("\t-> header\n") state = "comment" elif state == "comment": if line == SCCS.delimiters[0] + "\n": metadata.revlist[-1].log = comment.rstrip() + "\n" if debug >= DEBUG_PARSE: sys.stderr.write("\t-> init\n") state = "header" else: comment += line metadata.revlist.sort(key=lambda x: x.date) for (i, item) in enumerate(metadata.revlist): if pseudotime: # Artificial date one day after the epoch # to avoid timezone issues. item.date = rfc3339(86400 + i * 60) item.revno = i + 1 metadata.revlist.reverse() try: with open(self.__sccsfile(metadata.name, "p"), "rb") as fp: for line in fp: metadata.lockrevs.append(polystr(line).split()[0]) except IOError: pass metadata.build_indices() if 'tags' in metadata.annotations: metadata.symbols.update(metadata.annotations['tags']) backends = (RCS, SCCS) if __name__ == "__main__": try: commandline = list(sys.argv[1:]) explicit = False repodir = ".src" backend = RCS if not os.path.exists(".src"): for vcs in backends: if os.path.exists(vcs.__name__): repodir = vcs.__name__ backend = vcs break while commandline and commandline[0].startswith("-"): if commandline[0] == '-d': debug += 1 elif commandline[0] == '-q': quiet = True elif commandline[0] == '-T': pseudotime = True elif commandline[0] == '-S': repodir = commandline[1] explicit = True commandline.pop(0) else: croak("unknown option %s before command verb" % commandline[0]) commandline.pop(0) if not commandline: help_method() raise SystemExit(0) # User might want to force the back end for vcs in backends: if commandline[0] == vcs.__name__.lower(): backend = vcs commandline.pop(0) break # Ugly constraint... if backend.__name__ == 'SCCS': repodir = "SCCS" backend = backend() if not commandline: help_method() raise SystemExit(0) if commandline[0] in dispatch: dispatch[commandline[0]](*commandline[1:]) else: croak("no such command as '%s'. Try 'src help'" \ % commandline[0]) except KeyboardInterrupt: pass # The following sets edit modes for GNU EMACS # Local Variables: # mode:python # End: src-1.26/src.10000664000175000017500000004122513466062201011254 0ustar esresr'\" t .\" Title: src .\" Author: [FIXME: author] [see http://docbook.sf.net/el/author] .\" Generator: DocBook XSL Stylesheets v1.79.1 .\" Date: 05/12/2019 .\" Manual: \ \& .\" Source: \ \& .\" Language: English .\" .TH "SRC" "1" "05/12/2019" "\ \&" "\ \&" .\" ----------------------------------------------------------------- .\" * Define some portability stuff .\" ----------------------------------------------------------------- .\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .\" http://bugs.debian.org/507673 .\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html .\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .ie \n(.g .ds Aq \(aq .el .ds Aq ' .\" ----------------------------------------------------------------- .\" * set default formatting .\" ----------------------------------------------------------------- .\" disable hyphenation .nh .\" disable justification (adjust text to left margin only) .ad l .\" ----------------------------------------------------------------- .\" * MAIN CONTENT STARTS HERE * .\" ----------------------------------------------------------------- .SH "NAME" src \- simple revision control .SH "SYNOPSIS" .sp \fBsrc\fR [command] [revision\-spec] [\fIfile\fR\&...] .SH "DESCRIPTION" .sp SRC (or src) is simple revision control, a version\-control system for single\-file projects by solo developers and authors\&. It modernizes the venerable RCS, hence the anagrammatic acronym\&. The design is tuned for use cases like all those little scripts in your "~/bin" directory, or a directory full of single\-file HOWTOs\&. .sp SRC revision histories are single, human\-readable files beneath a hidden "\&.src" subdirectory in the directory where they live\&. There may be multiple histories under one directory; SRC treats them as separate projects, and history files can be moved elsewhere at any time\&. .sp SRC gives you simple, consecutive integer revision numbers\&. It supports tags and branching\&. It does not show committer information, because the committer is always you\&. The command set is intended to look familiar if you have ever used Subversion, Mercurial, or Git\&. .sp SRC is lightweight and fast\&. It uses two small self\-contained executables, with no libraries and no complications\&. .sp SRC interprets the EDITOR variable in the usual way, using it to spawn an editor instance when you perform a commit or amend\&. .sp SRC is fully supported in Emacs VC mode\&. .SH "COMMAND SUMMARY" .sp A "revision" is a 1\-origin integer, or a tag name designating an integer revision, or a branch name designating the tip revision of its branch\&. Revision numbers always increase in commit\-date order\&. .sp A revision range is a single revision, or a pair of revisions "M\-N" (all revisions numerically from M to N) or "M\&.\&.N" (all revisions that are branch ancestors of N and branch successors of M)\&. .sp If SRC complains that your revision spec looks like a nonexistent filename, you can prefix it with "@" (this is always allowed)\&. "@" by itself means the current (checked\-out) revision\&. .sp Unless otherwise noted under individual commands, the default revision is the tip revision on the current branch and the default range is all revisions on the current branch\&. .sp The token "\-\-" tells the command\-line interpreter that subcommands, switches, and revision\-specs are done \- everything after it is a filename, even if it looks like a subcommand or revision number\&. .PP src help [\fIcommand\fR] .RS 4 Displays help for commands\&. .RE .PP src commit [\-|\-m \fIstring\fR|\-f \fIfile\fR|\-e] [\fIfile\fR\&...] .RS 4 Enters a commit for specified files\&. Separately to each one\&. A history is created for the file if it does not already exist\&. With \fI\-\fR, take comment text from stdin; with \fI\-m\fR use the following string as the comment; with \fI\-f\fR take from a file\&. With \fI\-e\fR, edit even after \fI\-\fR, \fI\-f\fR or \fI\-m\fR\&. "ci" is a synonym for "commit"\&. .RE .PP src amend [\-|\-m \fIstring\fR|\-f \fIfile\fR|\-e] [\fIrevision\fR] [\fIfile\fR\&...] .RS 4 Amends the stored comment for a specified revision, defaulting to the latest revision on the current branch\&. Flags are as for commit\&. "am" is a synonym for "amend"\&. .RE .PP src checkout [\fIrevision\fR] [\fIfile\fR\&...] .RS 4 Refresh the working copy of the file(s) from their history files\&. "co" is a synonym for "checkout"\&. .RE .PP src cat [\fIrevision\fR] [\fIfile\fR\&...] .RS 4 Send the specified revision of the files to standard output\&. .RE .PP src status [\-a] [\fIfile\fR\&...] .RS 4 "A" = added, "=" = unmodified, "M" = modified, "!" = missing, "?" = not tracked, "I" = ignored, "L" = locked (recover with "src checkout")\&. The "A" and "L" statuses should only occur if you have used RCS directly on a file\&. Normally "?" and "I" files are not listed; this changes if you either give the \fI\-a\fR switch or specify which files to look at\&. "st" is a synonym for "status"\&. .RE .PP src tag [list|\-l|create|\-c|delete|del|\-d] [\fIname\fR] [\fIrevision\fR] [\fIfile\fR\&...] .RS 4 List tags, create tags, or delete tags\&. Create/delete takes a revision, defaulting to the current branch tip\&. List defaults to all revisions\&. .RE .PP src branch [list|\-l|create|\-c|delete|del|\-d] [\fIname\fR] [\fIfile\fR\&...] .RS 4 List, create, or delete branches\&. When listing, the active branch is first in the list\&. The default branch is "trunk"\&. Create/delete takes a singleton revision, defaulting to the current branch tip\&. List defaults to all revisions, including 0 (the trunk root phantom revision)\&. .RE .PP src rename [\fItag\fR|\fIbranch\fR] [\fIoldname\fR] [\fInewname\fR] [\fIfile\fR\&...] .RS 4 Rename a tag or branch\&. Refuses to step on an existing symbol or rename a nonexistent one\&. "rn" is a synonym for "rename"\&. .RE .PP src list [(\-|\-l )] [\-f \fIfmt\fR] [\fIrevision\-range\fR] [\fIfile\fR\&...] .RS 4 Sends summary information about the specified commits to standard output\&. The summary line tagged with "*" is the state that the file would return to on checkout without a revision\-spec\&. See \fIhelp list\fR for information about custom formats\&. Use \fI\-\fR or \fI\-l \fR, where is a number, to limit the listing length\&. Default range is the current branch, reversed\&. "li" is a synonym for "list"\&. .RE .PP src log [\-v] [(\-|\-l )] [(\-p|\-u|\-c) [\-b|\-w]] [\fIrevision\-range\fR] [\fIfile\fR\&...] .RS 4 Sends log information about the specified commits to standard output\&. Use \fI\-\fR or \fI\-l \fR, where is a number, to limit the listing length\&. Default range is the current branch, reversed\&. The \fI\-\-patch\fR, \fI\-p\fR or \fI\-u\fR option additionally sends a unified format diff listing to standard output for each revision against its immediate ancestor revision; \fI\-c\fR emits a context diff instead\&. When generating a diff, \fI\-b\fR ignores changes in whitespace, and \fI\-w\fR ignores all whitespace\&. Histories imported via \fIfast\-import\fR (when not using its \fI\-p\fR option) have RFC\-822\-style headers inserted into the log comment to preserve metadata not otherwise representable in SRC, such as distinct author and committer identifications and dates\&. These headers are normally suppressed by \fIlog\fR, however, \fI\-v\fR shows a summarized view of important headers; \fI\-v \-v\fR shows all headers as\-is\&. .RE .PP src diff [(\-u|\-c) [\-b|\-w]] [\fIrevision\-range\fR] [\fIfile\fR\&...] .RS 4 Sends a diff listing to standard output\&. With no revision spec, diffs the working copy against the last version checked in\&. With one revno, diffs the working copy against that stored revision; with a range, diff between the beginning and end of the range\&. The actual difference generation is done with diff(1)\&. The default diff format is \fI\-u\fR (unified), but if you specify a \fI\-c\fR option after the verb a context diff will be emitted\&. \fI\-b\fR ignores changes in the amount of whitespace, and \fI\-w\fR ignores all whitespace\&. "di" is a synonym for "diff"\&. .RE .PP src ls .RS 4 List all registered files\&. .RE .PP src visualize .RS 4 Emit a DOT visualization of repository structures\&. To use this, install the graphviz package and pipe the output to something like "dot \-Tpng | display \-"\&. "vis" is a synonym for "visualize"\&. .RE .PP src move \fIold\fR \fInew\fR .RS 4 Rename a workfile and its history\&. Refuses to step on existing workfiles or histories\&. "mv" is a synonym for "move"\&. .RE .PP src copy \fIold\fR \fInew\fR .RS 4 Copy a file and its master\&. Refuses to step on existing files or masters\&. "cp" is a synonym for "copy"\&. .RE .PP src fast\-export [\fIrevision\-range\fR] [\fIfile\fR\&...] .RS 4 Export one or more projects as a Git fast\-import stream\&. For a history originally imported from elsewhere, author and committer identification is gleaned from the RFC\-822\-style headers inserted into the commit comment by \fIfast\-import\fR (if its \fI\-p\fR option was not used)\&. Otherwise, this information is copied from your Git configuration\&. .RE .PP src fast\-import [\-p] [\fIfiles\fR\&...] .RS 4 Parse a git\-fast\-import stream from standard input\&. The modifications for each individual file become separate SRC histories\&. Mark, committer and author data, and mark cross\-references to parent commits, are preserved in RFC\-822\-style headers on log comments unless the \fI\-p\fR (plain) option is given, in which case this metadata is discarded\&. Give arguments to restrict the files imported\&. .RE .PP src release [\fIfile\fR\&...] .RS 4 Release locks on files\&. This is never necessary in a normal workflow, which will be repeated edit\-commit cycles, but it may be handy if you have to interoperate with other tools that expect RCS masters to be in their normal (unlocked) state\&. .RE .sp src srcify Move a directory from being RCS\- or SCCS\-managed to being SRC\-managed\&. That is: if the current directory contains an RCS directory, rename it to \&.src (but leave any SCCS directory in place)\&. Then check out all masters for editing that are not already checked out\&. .PP src version .RS 4 Report the versions of SRC, the underlying Python, and the back end\&. .RE .sp The omission of "src remove" is a deliberate speed bump\&. .sp If no files are specified, all eligible files are operated on in sequence\&. .SH "NOISE CONTROL" .sp Silence is golden\&. When you have selected only one file to operate on, and the command is not a report generator (\fIstatus\fR, \fIcat\fR, \fIlog\fR, \fIlist\fR, \fIfast\-export\fR, the listing modes of \fItag\fR and \fIbranch\fR, \fIls\fR) you will see a reply only if the operation failed\&. .sp Other commands (\fIcommit\fR, \fIcheckout\fR, tag creation and deletion) give you a success message per file when operating on multiple files, so you will not be in doubt about which operation succeeded\&. This behavior can be suppressed with the \fI\-q\fR option, placed \fIbefore\fR the subcommand word\&. .sp If your directory contains a file named "\&.srcignore", each line that is neither blank nor begins with a "#" is interpreted as an ignore pattern\&. It is expanded with glob(3), and files in the expansion are omitted from \fIsrc status\fR \- unless the file is named as an argument, of the status command, in which case its status is "I"\&. Thus, for example, a line reading "*\&.html" will cause all files with an HTML extension to be omitted from the output of "src status", but the output of \fIsrc status *\fR will list them with status "I"\&. .SH "BACKWARD COMPATIBILITY" .sp SRC history files are (normally) RCS master files\&. SRC maintains no permanent state other than these files\&. .sp SRC takes over the little\-used "description" field of RCS (and SCCS) master files to store some state that makes status checks faster\&. If you try to use SRC to edit a pre\-existing RCS\- or SCCS\-registered file with a non\-empty description field, SRC will refuse to step on the old description; you must clear it manually\&. .sp In order to maintain complete backwards compatibility, one other compromise was made: any commit comment containing a string exactly matching an RCS log delimiter (a long string of "\-" characters) will be rejected as malformed\&. .sp The RCS back end will be automatically selected when there is an "\&.src" or "RCS" subdirectory\&. .sp You can explicitly select the RCS back end by making the first command keyword on the src command line be \fIrcs\fR\&. This should only be necessary when your working directory contains two or more of the subdirectories "\&.src", "RCS", and "SCCS"\&. .sp By default, history files are kept in a hidden subdirectory named "\&.src"\&. But if you have an RCS subdirectory and no "\&.src", SRC will quietly operate on the files in the RCS directory in a completely backward\-compatible way\&. .SH "WORKING WITH SCCS" .sp Using SCCS as a back end is also supported, with some limits due to missing features in SCCS implementations: .sp .RS 4 .ie n \{\ \h'-04'\(bu\h'+03'\c .\} .el \{\ .sp -1 .IP \(bu 2.3 .\} SCCS tags are an SRC\-only extension that won\(cqt be visible from SCCS running natively\&. .RE .sp .RS 4 .ie n \{\ \h'-04'\(bu\h'+03'\c .\} .el \{\ .sp -1 .IP \(bu 2.3 .\} All commands relating to branches throw an error in the SCCS back end\&. .RE .sp .RS 4 .ie n \{\ \h'-04'\(bu\h'+03'\c .\} .el \{\ .sp -1 .IP \(bu 2.3 .\} In CSSC SCCS, src cat does not necessarily pipe out binary data correctly\&. This has been fixed in the SunOS and Schilling versions\&. .RE .sp .RS 4 .ie n \{\ \h'-04'\(bu\h'+03'\c .\} .el \{\ .sp -1 .IP \(bu 2.3 .\} The exec bit is not propagated between master and workfile\&. This has been fixed in the SunOS and Schilling versions\&. .RE .sp .RS 4 .ie n \{\ \h'-04'\(bu\h'+03'\c .\} .el \{\ .sp -1 .IP \(bu 2.3 .\} The CSSC and SunOS SCCS backends have a Y2\&.1K problem that SRC cannot effectively work around and will probably not be fixed\&. The Schilling version has repaired this\&. .RE .sp The SCCS back end will be automatically selected when there is an "SCCS" subdirectory and no "\&.src" or "RCS" subdirectory\&. .sp You can explicitly select the SCCS back end by making the first command keyword on the src command line be \fIsccs\fR\&. This should only be necessary when your working directory contains none or two or more of the subdirectories "\&.src", "RCS", and "SCCS"\&. .sp Working with SCCS requires an "SCCS" subdirectory; SRC will quietly create one, if required, then operate on the files in the "SCCS" directory in a completely backward\-compatible way\&. .sp Fast\-import to SCCS is not supported\&. .sp The SCCS mode is not recommended unless you have a specific need to work with legacy SCCS repositories\&. Up\-converting them to something less Paleolithic would be a better idea; in truth, the SCCS support exists mainly because it\(cqs hilarious (for obscure hacker values of \fIhilarious\fR)\&. .SH "DEBUGGING OPTIONS" .sp These will be of interest mainly to developers\&. .sp A \fI\-d\fR (debug) option before the main command word turns on debugging messages\&. Just one "\-d" gives you complete visibility about what commands the back end is running\&. It can be repeated for higher debugging levels that expose more of src\(cqs internal computation\&. .sp A \fI\-S\fR (sandbox) option can be used to set the repository directory to something other than its default of "\&.src"\&. .sp A \fI\-T\fR option sets up an artificial clock that ticks once on each revision and fixes the user information to be used in \fIfast\-export\fR; It also attributes all commits to "J\&. Random Hacker"\&. It is for regression testing\&. .SH "REQUIREMENTS" .sp SRC is written in Python and requires 2\&.7 or later; it will run under Python 3\&.x for x > 2\&. .sp If you wish to use the RCS support (recommended), the RCS tools at version 5\&.7 or later must be installed and accessible in your path\&. .sp If you wish to use the SCCS support, some implementation of SCCS must be accessible\&. GNU\(cqs CSSC (Compatibly Stupid Source Control) will work; so will the SunOS and Schilling forks of AT&T SCCS\&. .sp The rcs\-fast\-import(1) tool at version 1\&.0 or later is required to support the \fIsrc fast\-import\fR command\&. .sp src will die gracefully with a useful error message when it fails due to a missing back end\&. .SH "LIMITATIONS" .sp Branch deletions change the revision numbers of revisions downstream of the branch join\&. .sp To avoid some confusing error cases, src will bail out if both \&.src and RCS directories exist\&. .sp In src fast\-export dumps of repositories with tags, branch labels may not exactly match what git fast\-export would emit\&. .SH "REPORTING BUGS" .sp Report bugs to Eric S\&. Raymond \&. The project page is at http://catb\&.org/~esr/src .SH "SEE ALSO" .sp rcs(1), rcs\-fast\-import(1), sccs(1), svn(1), git(1), dot(1)\&. src-1.26/src.adoc0000664000175000017500000003453713466061227012041 0ustar esresr= src(1) = :doctype: manpage == NAME == src - simple revision control == SYNOPSIS == *src* [command] [revision-spec] ['file'...] == DESCRIPTION == SRC (or src) is simple revision control, a version-control system for single-file projects by solo developers and authors. It modernizes the venerable RCS, hence the anagrammatic acronym. The design is tuned for use cases like all those little scripts in your "~/bin" directory, or a directory full of single-file HOWTOs. SRC revision histories are single, human-readable files beneath a hidden ".src" subdirectory in the directory where they live. There may be multiple histories under one directory; SRC treats them as separate projects, and history files can be moved elsewhere at any time. SRC gives you simple, consecutive integer revision numbers. It supports tags and branching. It does not show committer information, because the committer is always you. The command set is intended to look familiar if you have ever used Subversion, Mercurial, or Git. SRC is lightweight and fast. It uses two small self-contained executables, with no libraries and no complications. SRC interprets the EDITOR variable in the usual way, using it to spawn an editor instance when you perform a commit or amend. SRC is fully supported in Emacs VC mode. == COMMAND SUMMARY == A "revision" is a 1-origin integer, or a tag name designating an integer revision, or a branch name designating the tip revision of its branch. Revision numbers always increase in commit-date order. A revision range is a single revision, or a pair of revisions "M-N" (all revisions numerically from M to N) or "M..N" (all revisions that are branch ancestors of N and branch successors of M). If SRC complains that your revision spec looks like a nonexistent filename, you can prefix it with "@" (this is always allowed). "@" by itself means the current (checked-out) revision. Unless otherwise noted under individual commands, the default revision is the tip revision on the current branch and the default range is all revisions on the current branch. The token "--" tells the command-line interpreter that subcommands, switches, and revision-specs are done - everything after it is a filename, even if it looks like a subcommand or revision number. src help ['command']:: Displays help for commands. src commit [-|-m 'string'|-f 'file'|-e] ['file'...]:: Enters a commit for specified files. Separately to each one. A history is created for the file if it does not already exist. With '-', take comment text from stdin; with '-m' use the following string as the comment; with '-f' take from a file. With '-e', edit even after '-', '-f' or '-m'. "ci" is a synonym for "commit". src amend [-|-m 'string'|-f 'file'|-e] ['revision'] ['file'...]:: Amends the stored comment for a specified revision, defaulting to the latest revision on the current branch. Flags are as for commit. "am" is a synonym for "amend". src checkout ['revision'] ['file'...]:: Refresh the working copy of the file(s) from their history files. "co" is a synonym for "checkout". src cat ['revision'] ['file'...]:: Send the specified revision of the files to standard output. src status [-a] ['file'...]:: "A" = added, "=" = unmodified, "M" = modified, "!" = missing, "?" = not tracked, "I" = ignored, "L" = locked (recover with "src checkout"). The "A" and "L" statuses should only occur if you have used RCS directly on a file. Normally "?" and "I" files are not listed; this changes if you either give the '-a' switch or specify which files to look at. "st" is a synonym for "status". src tag [list|-l|create|-c|delete|del|-d] ['name'] ['revision'] ['file'...]:: List tags, create tags, or delete tags. Create/delete takes a revision, defaulting to the current branch tip. List defaults to all revisions. src branch [list|-l|create|-c|delete|del|-d] ['name'] ['file'...]:: List, create, or delete branches. When listing, the active branch is first in the list. The default branch is "trunk". Create/delete takes a singleton revision, defaulting to the current branch tip. List defaults to all revisions, including 0 (the trunk root phantom revision). src rename ['tag'|'branch'] ['oldname'] ['newname'] ['file'...]:: Rename a tag or branch. Refuses to step on an existing symbol or rename a nonexistent one. "rn" is a synonym for "rename". src list [(-|-l )] [-f 'fmt'] ['revision-range'] ['file'...]:: Sends summary information about the specified commits to standard output. The summary line tagged with "*" is the state that the file would return to on checkout without a revision-spec. See 'help list' for information about custom formats. Use '-' or '-l ', where is a number, to limit the listing length. Default range is the current branch, reversed. "li" is a synonym for "list". src log [-v] [(-|-l )] [(-p|-u|-c) [-b|-w]] ['revision-range'] ['file'...]:: Sends log information about the specified commits to standard output. Use '-' or '-l ', where is a number, to limit the listing length. Default range is the current branch, reversed. The '--patch', '-p' or '-u' option additionally sends a unified format diff listing to standard output for each revision against its immediate ancestor revision; '-c' emits a context diff instead. When generating a diff, '-b' ignores changes in whitespace, and '-w' ignores all whitespace. Histories imported via 'fast-import' (when not using its '-p' option) have RFC-822-style headers inserted into the log comment to preserve metadata not otherwise representable in SRC, such as distinct author and committer identifications and dates. These headers are normally suppressed by 'log', however, '-v' shows a summarized view of important headers; '-v -v' shows all headers as-is. src diff [(-u|-c) [-b|-w]] ['revision-range'] ['file'...]:: Sends a diff listing to standard output. With no revision spec, diffs the working copy against the last version checked in. With one revno, diffs the working copy against that stored revision; with a range, diff between the beginning and end of the range. The actual difference generation is done with diff(1). The default diff format is '-u' (unified), but if you specify a '-c' option after the verb a context diff will be emitted. '-b' ignores changes in the amount of whitespace, and '-w' ignores all whitespace. "di" is a synonym for "diff". src ls:: List all registered files. src visualize:: Emit a DOT visualization of repository structures. To use this, install the graphviz package and pipe the output to something like "dot -Tpng | display -". "vis" is a synonym for "visualize". src move 'old' 'new':: Rename a workfile and its history. Refuses to step on existing workfiles or histories. "mv" is a synonym for "move". src copy 'old' 'new':: Copy a file and its master. Refuses to step on existing files or masters. "cp" is a synonym for "copy". src fast-export ['revision-range'] ['file'...]:: Export one or more projects as a Git fast-import stream. For a history originally imported from elsewhere, author and committer identification is gleaned from the RFC-822-style headers inserted into the commit comment by 'fast-import' (if its '-p' option was not used). Otherwise, this information is copied from your Git configuration. src fast-import [-p] ['files'...]:: Parse a git-fast-import stream from standard input. The modifications for each individual file become separate SRC histories. Mark, committer and author data, and mark cross-references to parent commits, are preserved in RFC-822-style headers on log comments unless the '-p' (plain) option is given, in which case this metadata is discarded. Give arguments to restrict the files imported. src release ['file'...]:: Release locks on files. This is never necessary in a normal workflow, which will be repeated edit-commit cycles, but it may be handy if you have to interoperate with other tools that expect RCS masters to be in their normal (unlocked) state. src srcify Move a directory from being RCS- or SCCS-managed to being SRC-managed. That is: if the current directory contains an RCS directory, rename it to .src (but leave any SCCS directory in place). Then check out all masters for editing that are not already checked out. src version:: Report the versions of SRC, the underlying Python, and the back end. The omission of "src remove" is a deliberate speed bump. If no files are specified, all eligible files are operated on in sequence. == NOISE CONTROL == Silence is golden. When you have selected only one file to operate on, and the command is not a report generator ('status', 'cat', 'log', 'list', 'fast-export', the listing modes of 'tag' and 'branch', 'ls') you will see a reply only if the operation failed. Other commands ('commit', 'checkout', tag creation and deletion) give you a success message per file when operating on multiple files, so you will not be in doubt about which operation succeeded. This behavior can be suppressed with the '-q' option, placed 'before' the subcommand word. If your directory contains a file named ".srcignore", each line that is neither blank nor begins with a "#" is interpreted as an ignore pattern. It is expanded with glob(3), and files in the expansion are omitted from 'src status' - unless the file is named as an argument, of the status command, in which case its status is "I". Thus, for example, a line reading "*.html" will cause all files with an HTML extension to be omitted from the output of "src status", but the output of 'src status *' will list them with status "I". == BACKWARD COMPATIBILITY == SRC history files are (normally) RCS master files. SRC maintains no permanent state other than these files. SRC takes over the little-used "description" field of RCS (and SCCS) master files to store some state that makes status checks faster. If you try to use SRC to edit a pre-existing RCS- or SCCS-registered file with a non-empty description field, SRC will refuse to step on the old description; you must clear it manually. In order to maintain complete backwards compatibility, one other compromise was made: any commit comment containing a string exactly matching an RCS log delimiter (a long string of "-" characters) will be rejected as malformed. The RCS back end will be automatically selected when there is an ".src" or "RCS" subdirectory. You can explicitly select the RCS back end by making the first command keyword on the src command line be 'rcs'. This should only be necessary when your working directory contains two or more of the subdirectories ".src", "RCS", and "SCCS". By default, history files are kept in a hidden subdirectory named ".src". But if you have an RCS subdirectory and no ".src", SRC will quietly operate on the files in the RCS directory in a completely backward-compatible way. == WORKING WITH SCCS == Using SCCS as a back end is also supported, with some limits due to missing features in SCCS implementations: * SCCS tags are an SRC-only extension that won't be visible from SCCS running natively. * All commands relating to branches throw an error in the SCCS back end. * In CSSC SCCS, src cat does not necessarily pipe out binary data correctly. This has been fixed in the SunOS and Schilling versions. * The exec bit is not propagated between master and workfile. This has been fixed in the SunOS and Schilling versions. * The CSSC and SunOS SCCS backends have a Y2.1K problem that SRC cannot effectively work around and will probably not be fixed. The Schilling version has repaired this. The SCCS back end will be automatically selected when there is an "SCCS" subdirectory and no ".src" or "RCS" subdirectory. You can explicitly select the SCCS back end by making the first command keyword on the src command line be 'sccs'. This should only be necessary when your working directory contains none or two or more of the subdirectories ".src", "RCS", and "SCCS". Working with SCCS requires an "SCCS" subdirectory; SRC will quietly create one, if required, then operate on the files in the "SCCS" directory in a completely backward-compatible way. Fast-import to SCCS is not supported. The SCCS mode is not recommended unless you have a specific need to work with legacy SCCS repositories. Up-converting them to something less Paleolithic would be a better idea; in truth, the SCCS support exists mainly because it's hilarious (for obscure hacker values of 'hilarious'). == DEBUGGING OPTIONS == These will be of interest mainly to developers. A '-d' (debug) option before the main command word turns on debugging messages. Just one "-d" gives you complete visibility about what commands the back end is running. It can be repeated for higher debugging levels that expose more of src's internal computation. A '-S' (sandbox) option can be used to set the repository directory to something other than its default of ".src". A '-T' option sets up an artificial clock that ticks once on each revision and fixes the user information to be used in 'fast-export'; It also attributes all commits to "J. Random Hacker". It is for regression testing. == REQUIREMENTS == SRC is written in Python and requires 2.7 or later; it will run under Python 3.x for x > 2. If you wish to use the RCS support (recommended), the RCS tools at version 5.7 or later must be installed and accessible in your path. If you wish to use the SCCS support, some implementation of SCCS must be accessible. GNU's CSSC (Compatibly Stupid Source Control) will work; so will the SunOS and Schilling forks of AT&T SCCS. The rcs-fast-import(1) tool at version 1.0 or later is required to support the 'src fast-import' command. src will die gracefully with a useful error message when it fails due to a missing back end. == LIMITATIONS == Branch deletions change the revision numbers of revisions downstream of the branch join. To avoid some confusing error cases, src will bail out if both .src and RCS directories exist. In src fast-export dumps of repositories with tags, branch labels may not exactly match what git fast-export would emit. == REPORTING BUGS == Report bugs to Eric S. Raymond . The project page is at http://catb.org/~esr/src == SEE ALSO == rcs(1), rcs-fast-import(1), sccs(1), svn(1), git(1), dot(1). src-1.26/srctest0000775000175000017500000010723513466061227012033 0ustar esresr#!/bin/sh # # Regression tester for SRC. # # Use -b to test with a specified back end, rcs or sccs # Use -p to test with a specified Python interpreter # Use -e to rest with an alternate src version # Use -t to put test files and masters at a fixed location, not removing on exit # Set the umask for a bit of defensiveness umask 0077 # Set the PATH to include the current directory, so the repository # head version of src can always be tested. PATH="$(pwd)":$PATH backend="rcs" python="python" testmode=no while getopts b:p:e:t opt do case $opt in b) backend=$OPTARG;; p) python=$OPTARG;; e) src=$OPTARG;; t) testmode=yes;; esac done shift $(($OPTIND - 1)) $backend >/dev/null 2>&1 if [ "$?" = 127 ] then echo "srctest: backend ${backend} is missing." exit 1 fi if [ -z "$src" ] then src="${python} ${PWD}/src" fi check() { case $? in 0) echo "srctest ($python $backend): $1 succeeded";; *) echo "srctest ($python $backend): $1 failed"; exit 1;; esac } historify () { case $backend in rcs) history=.src/$1,v ;; sccs) history=SCCS/s.$1 ;; esac } if [ $testmode = yes ] then SANDBOX=/tmp/srctest echo "Test files and masters will not be removed on exit." rm -fr $SANDBOX else # Needs to not be a subdirectory of here, or git gets confused. Use # -u so that src's initialization will be tested. SANDBOX=$(mktemp -u /tmp/src_XXXXXXXX) trap "rm -fr $SANDBOX" 0 1 2 15 fi if [ ! -d $SANDBOX ] then mkdir $SANDBOX fi check "scratch directory creation: $SANDBOX" if [ "$SANDBOX" = "" ] then echo "srctest refuses to destroy the world." fi cd $SANDBOX; rm -fr * TESTOPTS="-T $* $backend" DIFFOPTS="--label Expected --label Actual -u" COLUMNS=73 export COLUMNS cat >testfile1 </dev/null check "commit with -m option" $src $TESTOPTS cat testfile1 | diff -u testfile1 - >/dev/null check "content check after first commit" cat >testfile1 <testfile4 <testfile5 diff -u testfile4 testfile5 check "nonempty diff" ! $src $TESTOPTS diff -@ testfile1 2>diff.err && grep unexpected diff.err >/dev/null check "bogus diff option" sleep 1 # Force commit to have different timestamp echo "Second comment" | $src $TESTOPTS commit - testfile1 >/dev/null check "commit with -" $src $TESTOPTS cat testfile1 | diff $DIFFOPTS testfile1 - check "content check after second commit" cat >testfile2 <testfile3 diff $DIFFOPTS testfile2 testfile3 check "list test" cat >testfile2 <testfile3 diff $DIFFOPTS testfile2 testfile3 check "2-commit log test" cat >testfile1 <testfile4 </dev/null check "commit with -f" cat >testfile4 <testfile5 diff $DIFFOPTS testfile4 testfile5 check "3-commit log test" cat >testfile14 <testfile15 diff $DIFFOPTS testfile14 testfile15 check "log --patch" cat >testfile6 <testfile7 2>&1 diff $DIFFOPTS testfile6 testfile7 check "oob revision spec check" for rev in 1 2 3 do $src $TESTOPTS checkout $rev testfile1 >/dev/null check "revision $rev checkout test" diff $DIFFOPTS testrev${rev} testfile1 check "revision $rev content test" done $src $TESTOPTS tag create sampletag check "tag set to default tip revision" cat >testfile8 <testfile9 diff $DIFFOPTS testfile8 testfile9 check "tag list check" $src $TESTOPTS tag create basetag 1 check "tag set to revision 1" cat >testfile10 <testfile11 diff $DIFFOPTS testfile10 testfile11 check "second tag list check" $src $TESTOPTS tag delete sampletag check "tag deletion: sampletag" cat >testfile12 <testfile13 diff $DIFFOPTS testfile12 testfile13 check "tag list check after deletion" # Alas, we have to do this or the fast-export regression will fail. # We don't know how to be perfectly canonical about tags yet. $src $TESTOPTS tag delete basetag check "tag deletion: basetag" test_export () { testname="$1" shift srcfi=$testname-src.fi gitfi=$testname-git.fi mkdir foo $src $TESTOPTS fast-export "$@" >$srcfi 2>export.err grep jrh $srcfi >/dev/null check "fast-export: $testname" cat $srcfi | (cd foo >/dev/null; git init --quiet; git fast-import --quiet) (cd foo >/dev/null; git fast-export --all) >$gitfi diff $DIFFOPTS $srcfi $gitfi check "fast-export roundtrip: $testname" rm -fr foo } test_export filename testfile1 # Test multiple-file fast-export. echo flower power >testfile14 $src $TESTOPTS commit -m "Alfred E. Newman" testfile14 >/dev/null test_export filenames testfile1 testfile14 historify testfile14 rm -f $history test_export revspec-filename -- testfile1 grep refs/heads/master revspec-filename-src.fi >/dev/null && ! grep refs/heads/testfile1/master revspec-filename-src.fi >/dev/null check "fast-export revspec/filename distinction" rm -f testfile1 test_export not-checked-out testfile1 check "fast-export consults history only" $src $TESTOPTS checkout testfile1 >/dev/null if [ "$backend" = "sccs" ] then echo "srctest ($python $backend): skipping fast-import checks: RCS-only" elif ! command -v rcs-fast-import >/dev/null 2>&1 then echo "srctest ($python $backend): skipping fast-import checks: rcs-fast-import missing" else mkdir RCS ! $src $TESTOPTS fast-import -p /dev/null 2>err && grep 'existing RCS' err >/dev/null check "fast-import don't clobber RCS" rm -fr RCS historify testfile1 rm -f $history $src $TESTOPTS fast-import -p /dev/null 2>&1 && test -f $history check "fast-import" $src $TESTOPTS fast-export testfile1 >testfile1.fi && diff -u filename-git.fi testfile1.fi check "fast-import roundtrip" fi $src $TESTOPTS move testfile1 newname1 check "move command" historify newname1 if [ -e newname1 -a -e $history ] then echo "srctest ($python $backend): content move succeeded" else echo "srctest ($python $backend): content move failed" exit 1 fi $src $TESTOPTS copy newname1 newname2 check "copy command" historify newname2 if [ -e newname2 -a -e $history ] then echo "srctest ($python $backend): content copy succeeded" else echo "srctest ($python $backend): content copy failed" exit 1 fi cat >testfile16 <>testfile16 $src $TESTOPTS status testfile16 | grep "^M" >/dev/null check "M status check after modification" rm testfile16 $src $TESTOPTS status testfile16 | grep "^!" >/dev/null check "! status check after deletion" $src $TESTOPTS checkout testfile16 $src $TESTOPTS status testfile16 | grep "^=" >/dev/null check "= status check after restoration" historify testfile16 rm -f $history $src $TESTOPTS status testfile16 | grep "^?" >/dev/null check "? status check after master deletion" $src $TESTOPTS amend -m "Amended comment" newname1 check "amend" $src $TESTOPTS list 3 newname1 | grep "Amended comment" >/dev/null check "amended comment content" cat >testfile17 </dev/null check "unadorned status command" if [ "$backend" = "sccs" ] then echo "srctest ($python $backend): skipping tag and branch tests" else # Introduce a test history with some branchiness, so # we can test traversal across branch joins. Also has tags. cat >.src/sample,v <sampledot <1First comment.>]; 1 -> 2; 2 [shape=box,width=5,label=<
2Second comment.
>]; 2 -> 3; 3 [shape=box,width=5,label=<
3Third comment.
>]; 3 -> 4; 4 [shape=box,width=5,label=<
4On a branch?
>]; "trunk" [shape=oval,width=2]; "4" -> "trunk" [style=dotted]; 3 -> 5; 5 [shape=box,width=5,label=<
5Totally unfubared.
>]; 5 -> 6; 6 [shape=box,width=5,label=<
6Still utterly fubar
>]; 6 -> 7; 7 [shape=box,width=5,label=<
7Totally chenille.
>]; 7 -> 8; 8 [shape=box,width=5,label=<
8Utterly fubar
>]; "muggle" [shape=oval,width=2]; "8" -> "muggle" [style=dotted]; 8 -> 9; 9 [shape=box,width=5,label=<
9All fixed up.
>]; 9 -> 10; 10 [shape=box,width=5,label=<
10It' all good.
>]; 10 -> 11; 11 [shape=box,width=5,label=<
11No good.
>]; 11 -> 12; 12 [shape=box,width=5,label=<
12That's good.
>]; 12 -> 13; 13 [shape=box,width=5,label=<
13I see you
>]; "sample" [shape=oval,width=2]; "13" -> "sample" [style=dotted]; {rank=same; "GLARB"; "4"} "GLARB" -> "4" [style=dotted]; {rank=same; "GORP"; "8"} "GORP" -> "8" [style=dotted]; } EOF $src $TESTOPTS visualize sample >tryit diff $DIFFOPTS sampledot tryit check "dot visualization" cat >statuslog <sample.seqlog <tryit diff $DIFFOPTS sample.seqlog tryit check "traversal by -" cat >sample.branchlog <tryit diff $DIFFOPTS sample.branchlog tryit check "traversal by .." cat >sample.branchlog-p <tryit diff $DIFFOPTS sample.branchlog-p tryit check "branchy log --patch" cat >sample.taglog <tryit diff $DIFFOPTS sample.taglog tryit check "named-tag lookup with @" $src $TESTOPTS rename tag GLARB GROTTY sample check "tag renaming" cat >changes <tryit diff $DIFFOPTS tryit changes check "tag list after rename" cat >branchlist <tryit check "branch list" $src $TESTOPTS branch -l sample >tryit diff $DIFFOPTS branchlist tryit check "branch list content" cat >branchlog <branchlog check "branch name resolution" $src $TESTOPTS list @trunk sample >tryit diff $DIFFOPTS branchlog tryit check "branch name resolved content" cat >statuslog <tryit diff $DIFFOPTS statuslog tryit check "status before ignore" echo "newname1" >.srcignore cat >statuslog <tryit diff $DIFFOPTS statuslog tryit check "status after ignore" $src $TESTOPTS branch delete trunk sample check "branch delete" cat >newlist <tryit diff $DIFFOPTS newlist tryit check "branch list check after delete" cat >newlog <tryit diff $DIFFOPTS newlog tryit check "content after branch deletion" fi echo "Random content for numeric file" >23 $src $TESTOPTS commit -m "I don't know why you say goodbye" -- 23 >/dev/null check "commit of file with numeric name" cat >randomcontent <tryit diff $DIFFOPTS randomcontent tryit check "cat of file with numeric name" # Eric Sunshine writes: # # The test itself is working properly. The problem is that stock SCCS # does not preserve executable permission on files under its control, so # the test is correctly failing. # # The GNU version of SCCS does provide an 'x' flag[1] for compatibility # with SCO OpenServer which enables executable permission preservation. # However, I haven't convinced myself that it would make sense to put in # the work to add executable-preservation support to the SCCS backend # for these special cases (GNU CSSC and SCO OpenServer). # # [1]: https://www.gnu.org/software/cssc/manual/Flags.html#Flag # if [ "$backend" = sccs ] then echo "srctest ($python $backend): skipping exec-bit propagation test" else echo "Should not be executable" >exectest $src $TESTOPTS commit -m "First comment on exectest" exectest >/dev/null check "first commit of exectest" chmod a+x exectest echo "Should be executable" >exectest $src $TESTOPTS commit -m "Second comment on exectest" exectest >/dev/null check "second commit of exectest" ls -l exectest | grep '^...x' >/dev/null check "propagation of exec bit" fi cat >diffall.expect <>newname1 echo "and even more" >>newname2 $src $TESTOPTS diff >diffall.actual && diff $DIFFOPTS diffall.expect diffall.actual && $src $TESTOPTS checkout newname1 newname2 >/dev/null check "default file list" cat >limit.list <limit.log <limit.expect diff limit.$i limit.expect check "$i $j" done done # Test for Tom Willemse's multi-commit bug. echo "test 1" > file1 echo "test 2" > file2 $src $TESTOPTS commit -m "Initial commit" file1 file2 >/dev/null check "multi-file registration" echo "test 1 line 2" >> file1 echo "test 2 line 2" >> file2 $src $TESTOPTS commit -m "Second commit" file1 file2 >/dev/null check "multi-file commit" # Test the edit logic cat >modify <<'EOF' echo "Different first line" >modified$$ cat $1 >>modified$$ mv modified$$ $1 EOF chmod a+x modify echo "test 1 line 3" >> file1 EDITOR="./modify" $src $TESTOPTS commit file1 check "edit logic" cat >binary <binary.chk <>binary $src $TESTOPTS commit -m "Binary file after modification." binary cmp binary binary.chk check "binary content in checkouts and commits" if [ "$backend" = "sccs" ] then echo "srctest ($python $backend): skipping binary cat test" else $src $TESTOPTS cat binary >catted cmp binary catted check "binary content in cat" fi cat >newline <newline.chk <>newline $src $TESTOPTS commit -m "DOS newline file after modification." newline cmp newline newline.chk check "newline preservation in checkouts and commits" if [ "$backend" = "sccs" ] then echo "srctest ($python $backend): skipping newline cat test" else $src $TESTOPTS cat newline >ncatted cmp newline ncatted check "newline content in cat" fi cat >padcomment <<'EOF' printf "\n\n\n\n" >modified$$ cat $1 >>modified$$ mv modified$$ $1 EOF chmod a+x padcomment echo gommelgor >padfile $src $TESTOPTS commit -m pingle padfile for i in commit amend do echo "more stuff" >>padfile EDITOR="./padcomment" $src $TESTOPTS $i padfile >padout grep cancelled padout >/dev/null check "whitespace-only $i cancel" $src $TESTOPTS checkout padfile done cat >clonemsg <<'EOF' echo "I think I'm a clone now" >modified$$ cat $1 >>modified$$ mv modified$$ $1 cp $1 clonedmsg EOF chmod a+x clonemsg echo gommelgor >diffledore $src $TESTOPTS commit -m pingle diffledore for i in commit amend do test $i = commit && echo "more stuff" >>diffledore EDITOR="./clonemsg" $src $TESTOPTS $i diffledore >/dev/null grep -F -e 'Changes to be committed' clonedmsg >/dev/null && grep -F -e '@@ ' clonedmsg >/dev/null && grep -F -e '+++ ' clonedmsg >/dev/null && grep -F -e '--- ' clonedmsg >/dev/null check "$i diff in boilerplate" done cat >dontinvoke <<'EOF' echo "panic!" >>nochanges EOF chmod a+x dontinvoke echo "bingleby" >canttouchthis $src $TESTOPTS commit -m pingle canttouchthis EDITOR="./dontinvoke" $src $TESTOPTS commit canttouchthis >>nochanges grep 'no changes to commit' nochanges >/dev/null && ! grep panic nochanges >/dev/null check "nothing to commit" cat >ignore.ws <ignore.ws <ignore.expect-b <ignore.expect-w <ignore.actual$i diff ignore.expect$i ignore.actual$i check "diff $i" done if [ "$backend" = "sccs" ] then echo "srctest ($python $backend): skipping commit date tie-breaking tests" else # Introduce a test history with all commits having same date so we can # test native revision ID tie-breaking. cat >.src/tiebreak,v < Author-Date: Mon 20 Nov 2017 21:37:42 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :22 Parents: :20 eleventh @ text @eleventh @ 1.10 log @Author: Eric Sunshine Author-Date: Mon 20 Nov 2017 21:30:40 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :20 Parents: :18 tenth @ text @d1 1 a1 1 tenth @ 1.9 log @Author: Eric Sunshine Author-Date: Mon 20 Nov 2017 21:27:29 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :18 Parents: :16 ninth @ text @d1 1 a1 1 ninth @ 1.8 log @Author: Eric Sunshine Author-Date: Mon 20 Nov 2017 21:25:22 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :16 Parents: :14 eighth @ text @d1 1 a1 1 eighth @ 1.7 log @Author: Eric Sunshine Author-Date: Mon 20 Nov 2017 23:02:46 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :14 Parents: :12 seventh @ text @d1 1 a1 1 seventh @ 1.6 log @Author: Eric Sunshine Author-Date: Mon 20 Nov 2017 22:56:46 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :12 Parents: :10 sixth @ text @d1 1 a1 1 sixth @ 1.5 log @Author: Eric Sunshine Author-Date: Fri 03 Nov 2017 13:30:17 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :10 Parents: :8 fifth @ text @d1 1 a1 1 fifth @ 1.4 log @Author: Eric Sunshine Author-Date: Fri 03 Nov 2017 13:28:35 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :8 Parents: :6 fourth @ text @d1 1 a1 1 fourth @ 1.3 log @Author: Eric Sunshine Author-Date: Fri 03 Nov 2017 13:26:41 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :6 Parents: :4 third @ text @d1 1 a1 1 third @ 1.2 log @Author: Eric Sunshine Author-Date: Fri 03 Nov 2017 13:25:01 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :4 Parents: :2 second @ text @d1 1 a1 1 second @ 1.1 log @Author: Eric Sunshine Author-Date: Fri 03 Nov 2017 13:12:48 -0500 Committer: Roy G. Biv Committer-Date: Tue 21 Nov 2017 01:45:15 +0000 Mark: :2 first @ text @d1 1 a1 1 first @ EOF cat >tiebreak.expect <tiebreak.actual diff tiebreak.expect tiebreak.actual check "same date tie-breaking" cat >noheaders.expect <noheaders.actual diff noheaders.expect noheaders.actual check "log suppresses headers" cat >logheaders.expect < Author-Date: 2017-11-21T02:37:42Z Author-Date-Offset: -18000 Committer: Roy G. Biv Committer-Date: 2017-11-21T01:45:15Z Committer-Date-Offset: 0 Mark: :22 Parents: :20 eleventh ------------------------------------------------------------------------ 10 | 1970-01-02T00:09:00Z | trunk Author: Eric Sunshine Author-Date: 2017-11-21T02:30:40Z Author-Date-Offset: -18000 Committer: Roy G. Biv Committer-Date: 2017-11-21T01:45:15Z Committer-Date-Offset: 0 Mark: :20 Parents: :18 tenth ------------------------------------------------------------------------ EOF $src $TESTOPTS log -v -v -2 tiebreak >logheaders.actual diff logheaders.expect logheaders.actual check "log -v -v shows all headers" cat >summaryheaders.expect < 2017-11-21T02:37:42Z Committer: Roy G. Biv 2017-11-21T01:45:15Z eleventh ------------------------------------------------------------------------ 10 | 1970-01-02T00:09:00Z | trunk Author: Eric Sunshine 2017-11-21T02:30:40Z Committer: Roy G. Biv 2017-11-21T01:45:15Z tenth ------------------------------------------------------------------------ EOF $src $TESTOPTS log -v -2 tiebreak >summaryheaders.actual diff summaryheaders.expect summaryheaders.actual check "log -v shows summarized headers" cat >authordate.expect <authordate.actual $src ${TESTOPTS#-T} log -2 tiebreak >>authordate.actual diff authordate.expect authordate.actual check "author date from RFC 822 header" cat >rfc822export.expect < 1509732768 -0500 committer Roy G. Biv 1511228715 +0000 EOF $src ${TESTOPTS#-T} fast-export 1 tiebreak | grep -E 'author|committer' >rfc822export.actual diff rfc822export.expect rfc822export.actual check "fast-export: consult RFC 822 headers" fi # Now for the srcify test rm -fr .src RCS SCCS cat >srcifyfile </dev/null fi $src $TESTOPTS srcify && ls $history >/dev/null && ls srcifyfile >/dev/null check "srcify command" echo "srctest ($python $backend): all tests succeeded" rm -fr $SANDBOX # end src-1.26/TODO0000664000175000017500000000030313400032526011056 0ustar esresr SRC TODO list * Eliminate 'L' status, turning it to '=' and automatically checking out the file when required. * Full branch support in the SCCS back end, now that we know it's possible.