cvs2svn_lib/run_options.py

   1 # (Be in -*- python -*- mode.)
   2 #
   3 # ====================================================================
   4 # Copyright (c) 2000-2009 CollabNet.  All rights reserved.
   5 #
   6 # This software is licensed as described in the file COPYING, which
   7 # you should have received as part of this distribution.  The terms
   8 # are also available at http://subversion.tigris.org/license-1.html.
   9 # If newer versions of this license are posted there, you may use a
  10 # newer version instead, at your option.
  11 #
  12 # This software consists of voluntary contributions made by many
  13 # individuals.  For exact contribution history, see the revision
  14 # history and logs, available at http://cvs2svn.tigris.org/.
  15 # ====================================================================
  16
  17 """This module contains classes to set common cvs2xxx run options."""
  18
  19 import sys
  20 import re
  21 import optparse
  22 from optparse import OptionGroup
  23 import time
  24
  25 from cvs2svn_lib.version import VERSION
  26 from cvs2svn_lib import config
  27 from cvs2svn_lib.common import warning_prefix
  28 from cvs2svn_lib.common import error_prefix
  29 from cvs2svn_lib.common import FatalError
  30 from cvs2svn_lib.common import CVSTextDecoder
  31 from cvs2svn_lib.log import Log
  32 from cvs2svn_lib.context import Ctx
  33 from cvs2svn_lib.man_writer import ManOption
  34 from cvs2svn_lib.pass_manager import InvalidPassError
  35 from cvs2svn_lib.symbol_strategy import AllBranchRule
  36 from cvs2svn_lib.symbol_strategy import AllTagRule
  37 from cvs2svn_lib.symbol_strategy import BranchIfCommitsRule
  38 from cvs2svn_lib.symbol_strategy import ExcludeRegexpStrategyRule
  39 from cvs2svn_lib.symbol_strategy import ForceBranchRegexpStrategyRule
  40 from cvs2svn_lib.symbol_strategy import ForceTagRegexpStrategyRule
  41 from cvs2svn_lib.symbol_strategy import ExcludeTrivialImportBranchRule
  42 from cvs2svn_lib.symbol_strategy import HeuristicStrategyRule
  43 from cvs2svn_lib.symbol_strategy import UnambiguousUsageRule
  44 from cvs2svn_lib.symbol_strategy import HeuristicPreferredParentRule
  45 from cvs2svn_lib.symbol_strategy import SymbolHintsFileRule
  46 from cvs2svn_lib.symbol_transform import ReplaceSubstringsSymbolTransform
  47 from cvs2svn_lib.symbol_transform import RegexpSymbolTransform
  48 from cvs2svn_lib.symbol_transform import NormalizePathsSymbolTransform
  49 from cvs2svn_lib.property_setters import AutoPropsPropertySetter
  50 from cvs2svn_lib.property_setters import CVSBinaryFileDefaultMimeTypeSetter
  51 from cvs2svn_lib.property_setters import CVSBinaryFileEOLStyleSetter
  52 from cvs2svn_lib.property_setters import CVSRevisionNumberSetter
  53 from cvs2svn_lib.property_setters import DefaultEOLStyleSetter
  54 from cvs2svn_lib.property_setters import EOLStyleFromMimeTypeSetter
  55 from cvs2svn_lib.property_setters import ExecutablePropertySetter
  56 from cvs2svn_lib.property_setters import KeywordsPropertySetter
  57 from cvs2svn_lib.property_setters import MimeMapper
  58 from cvs2svn_lib.property_setters import SVNBinaryFileKeywordsPropertySetter
  59
  60
  61 usage = """\
  62 Usage: %prog --options OPTIONFILE
  63        %prog [OPTION...] OUTPUT-OPTION CVS-REPOS-PATH"""
  64
  65 description="""\
  66 Convert a CVS repository into a Subversion repository, including history.
  67 """
  68
  69 authors = u"""\
  70 Main authors are:
  71 .br
  72 C. Michael Pilato <cmpilato@collab.net>
  73 .br
  74 Greg Stein <gstein@lyra.org>
  75 .br
  76 Branko \u010cibej <brane@xbc.nu>
  77 .br
  78 Blair Zajac <blair@orcaware.com>
  79 .br
  80 Max Bowsher <maxb@ukf.net>
  81 .br
  82 Brian Fitzpatrick <fitz@red-bean.com>
  83 .br
  84 Tobias Ringstr\u00f6m <tobias@ringstrom.mine.nu>
  85 .br
  86 Karl Fogel <kfogel@collab.net>
  87 .br
  88 Erik H\u00fclsmann <e.huelsmann@gmx.net>
  89 .br
  90 David Summers <david@summersoft.fay.ar.us>
  91 .br
  92 Michael Haggerty <mhagger@alum.mit.edu>
  93 .PP
  94 Manpage was written for the Debian GNU/Linux system by
  95 Laszlo 'GCS' Boszormenyi <gcs@lsc.hu> (but may be used by others).
  96 """
  97
  98
  99 class IncompatibleOption(ManOption):
 100   """A ManOption that is incompatible with the --options option.
 101
 102   Record that the option was used so that error checking can later be
 103   done."""
 104
 105   def __init__(self, *args, **kw):
 106     ManOption.__init__(self, *args, **kw)
 107
 108   def take_action(self, action, dest, opt, value, values, parser):
 109     oio = parser.values.options_incompatible_options
 110     if opt not in oio:
 111       oio.append(opt)
 112     return ManOption.take_action(
 113         self, action, dest, opt, value, values, parser
 114         )
 115
 116
 117 class ContextOption(ManOption):
 118   """A ManOption that stores its value to Ctx."""
 119
 120   def __init__(self, *args, **kw):
 121     if kw.get('action') not in self.STORE_ACTIONS:
 122       raise ValueError('Invalid action: %s' % (kw['action'],))
 123
 124     self.__compatible_with_option = kw.pop('compatible_with_option', False)
 125     self.__action = kw.pop('action')
 126     try:
 127       self.__dest = kw.pop('dest')
 128     except KeyError:
 129       opt = args[0]
 130       if not opt.startswith('--'):
 131         raise ValueError
 132       self.__dest = opt[2:].replace('-', '_')
 133     if 'const' in kw:
 134       self.__const = kw.pop('const')
 135
 136     kw['action'] = 'callback'
 137     kw['callback'] = self.__callback
 138
 139     ManOption.__init__(self, *args, **kw)
 140
 141   def __callback(self, option, opt_str, value, parser):
 142     if not self.__compatible_with_option:
 143       oio = parser.values.options_incompatible_options
 144       if opt_str not in oio:
 145         oio.append(opt_str)
 146
 147     action = self.__action
 148     dest = self.__dest
 149
 150     if action == "store":
 151         setattr(Ctx(), dest, value)
 152     elif action == "store_const":
 153         setattr(Ctx(), dest, self.__const)
 154     elif action == "store_true":
 155         setattr(Ctx(), dest, True)
 156     elif action == "store_false":
 157         setattr(Ctx(), dest, False)
 158     elif action == "append":
 159         getattr(Ctx(), dest).append(value)
 160     elif action == "count":
 161         setattr(Ctx(), dest, getattr(Ctx(), dest, 0) + 1)
 162     else:
 163         raise RuntimeError("unknown action %r" % self.__action)
 164
 165     return 1
 166
 167
 168 class IncompatibleOptionsException(FatalError):
 169   pass
 170
 171
 172 # Options that are not allowed to be used with --trunk-only:
 173 SYMBOL_OPTIONS = [
 174     '--symbol-transform',
 175     '--symbol-hints',
 176     '--force-branch',
 177     '--force-tag',
 178     '--exclude',
 179     '--keep-trivial-imports',
 180     '--symbol-default',
 181     '--no-cross-branch-commits',
 182     ]
 183
 184 class SymbolOptionsWithTrunkOnlyException(IncompatibleOptionsException):
 185   def __init__(self):
 186     IncompatibleOptionsException.__init__(
 187         self,
 188         'The following symbol-related options cannot be used together\n'
 189         'with --trunk-only:\n'
 190         '    %s'
 191         % ('\n    '.join(SYMBOL_OPTIONS),)
 192         )
 193
 194
 195 def not_both(opt1val, opt1name, opt2val, opt2name):
 196   """Raise an exception if both opt1val and opt2val are set."""
 197   if opt1val and opt2val:
 198     raise IncompatibleOptionsException(
 199         "cannot pass both '%s' and '%s'." % (opt1name, opt2name,)
 200         )
 201
 202
 203 class RunOptions(object):
 204   """A place to store meta-options that are used to start the conversion."""
 205
 206   def __init__(self, progname, cmd_args, pass_manager):
 207     """Process the command-line options, storing run options to SELF.
 208
 209     PROGNAME is the name of the program, used in the usage string.
 210     CMD_ARGS is the list of command-line arguments passed to the
 211     program.  PASS_MANAGER is an instance of PassManager, needed to
 212     help process the -p and --help-passes options."""
 213
 214     self.progname = progname
 215     self.cmd_args = cmd_args
 216     self.pass_manager = pass_manager
 217     self.start_pass = 1
 218     self.end_pass = self.pass_manager.num_passes
 219     self.profiling = False
 220
 221     self.projects = []
 222
 223     # A list of one list of SymbolStrategyRules for each project:
 224     self.project_symbol_strategy_rules = []
 225
 226     parser = self.parser = optparse.OptionParser(
 227         usage=usage,
 228         description=self.get_description(),
 229         add_help_option=False,
 230         )
 231     # A place to record any options used that are incompatible with
 232     # --options:
 233     parser.set_default('options_incompatible_options', [])
 234
 235     # Populate the options parser with the options, one group at a
 236     # time:
 237     parser.add_option_group(self._get_options_file_options_group())
 238     parser.add_option_group(self._get_output_options_group())
 239     parser.add_option_group(self._get_conversion_options_group())
 240     parser.add_option_group(self._get_symbol_handling_options_group())
 241     parser.add_option_group(self._get_subversion_properties_options_group())
 242     parser.add_option_group(self._get_extraction_options_group())
 243     parser.add_option_group(self._get_environment_options_group())
 244     parser.add_option_group(self._get_partial_conversion_options_group())
 245     parser.add_option_group(self._get_information_options_group())
 246
 247     (self.options, self.args) = parser.parse_args(args=self.cmd_args)
 248
 249     # Now the log level has been set; log the time when the run started:
 250     Log().verbose(
 251         time.strftime(
 252             'Conversion start time: %Y-%m-%d %I:%M:%S %Z',
 253             time.localtime(Log().start_time)
 254             )
 255         )
 256
 257     if self.options.options_file_found:
 258       # Check that no options that are incompatible with --options
 259       # were used:
 260       self.verify_option_compatibility()
 261     else:
 262       # --options was not specified.  So do the main initialization
 263       # based on other command-line options:
 264       self.process_options()
 265
 266     # Check for problems with the options:
 267     self.check_options()
 268
 269   def get_description(self):
 270     return description
 271
 272   def _get_options_file_options_group(self):
 273     group = OptionGroup(
 274         self.parser, 'Configuration via options file'
 275         )
 276     self.parser.set_default('options_file_found', False)
 277     group.add_option(ManOption(
 278         '--options', type='string',
 279         action='callback', callback=self.callback_options,
 280         help=(
 281             'read the conversion options from PATH.  This '
 282             'method allows more flexibility than using '
 283             'command-line options.  See documentation for info'
 284             ),
 285         man_help=(
 286             'Read the conversion options from \\fIpath\\fR instead of from '
 287             'the command line.  This option allows far more conversion '
 288             'flexibility than can be achieved using the command-line alone. '
 289             'See the documentation for more information.  Only the following '
 290             'command-line options are allowed in combination with '
 291             '\\fB--options\\fR: \\fB-h\\fR/\\fB--help\\fR, '
 292             '\\fB--help-passes\\fR, \\fB--version\\fR, '
 293             '\\fB-v\\fR/\\fB--verbose\\fR, \\fB-q\\fR/\\fB--quiet\\fR, '
 294             '\\fB-p\\fR/\\fB--pass\\fR/\\fB--passes\\fR, \\fB--dry-run\\fR, '
 295             '\\fB--profile\\fR, \\fB--sort\\fR, \\fB--trunk-only\\fR, '
 296             '\\fB--encoding\\fR, and \\fB--fallback-encoding\\fR. '
 297             'Options are processed in the order specified on the command '
 298             'line.'
 299             ),
 300         metavar='PATH',
 301         ))
 302     return group
 303
 304   def _get_output_options_group(self):
 305     group = OptionGroup(self.parser, 'Output options')
 306     return group
 307
 308   def _get_conversion_options_group(self):
 309     group = OptionGroup(self.parser, 'Conversion options')
 310     group.add_option(ContextOption(
 311         '--trunk-only',
 312         action='store_true',
 313         compatible_with_option=True,
 314         help='convert only trunk commits, not tags nor branches',
 315         man_help=(
 316             'Convert only trunk commits, not tags nor branches.'
 317             ),
 318         ))
 319     group.add_option(ManOption(
 320         '--encoding', type='string',
 321         action='callback', callback=self.callback_encoding,
 322         help=(
 323             'encoding for paths and log messages in CVS repos.  '
 324             'If option is specified multiple times, encoders '
 325             'are tried in order until one succeeds.  See '
 326             'http://docs.python.org/lib/standard-encodings.html '
 327             'for a list of standard Python encodings.'
 328             ),
 329         man_help=(
 330             'Use \\fIencoding\\fR as the encoding for filenames, log '
 331             'messages, and author names in the CVS repos.  This option '
 332             'may be specified multiple times, in which case the encodings '
 333             'are tried in order until one succeeds.  Default: ascii.  See '
 334             'http://docs.python.org/lib/standard-encodings.html for a list '
 335             'of other standard encodings.'
 336             ),
 337         metavar='ENC',
 338         ))
 339     group.add_option(ManOption(
 340         '--fallback-encoding', type='string',
 341         action='callback', callback=self.callback_fallback_encoding,
 342         help='If all --encodings fail, use lossy encoding with ENC',
 343         man_help=(
 344             'If none of the encodings specified with \\fB--encoding\\fR '
 345             'succeed in decoding an author name or log message, then fall '
 346             'back to using \\fIencoding\\fR in lossy \'replace\' mode. '
 347             'Use of this option may cause information to be lost, but at '
 348             'least it allows the conversion to run to completion.  This '
 349             'option only affects the encoding of log messages and author '
 350             'names; there is no fallback encoding for filenames.  (By '
 351             'using an \\fB--options\\fR file, it is possible to specify '
 352             'a fallback encoding for filenames.)  Default: disabled.'
 353             ),
 354         metavar='ENC',
 355         ))
 356     group.add_option(ContextOption(
 357         '--retain-conflicting-attic-files',
 358         action='store_true',
 359         help=(
 360             'if a file appears both in and out of '
 361             'the CVS Attic, then leave the attic version in a '
 362             'SVN directory called "Attic"'
 363             ),
 364         man_help=(
 365             'If a file appears both inside an outside of the CVS attic, '
 366             'retain the attic version in an SVN subdirectory called '
 367             '\'Attic\'.  (Normally this situation is treated as a fatal '
 368             'error.)'
 369             ),
 370         ))
 371
 372     return group
 373
 374   def _get_symbol_handling_options_group(self):
 375     group = OptionGroup(self.parser, 'Symbol handling')
 376     self.parser.set_default('symbol_transforms', [])
 377     group.add_option(IncompatibleOption(
 378         '--symbol-transform', type='string',
 379         action='callback', callback=self.callback_symbol_transform,
 380         help=(
 381             'transform symbol names from P to S, where P and S '
 382             'use Python regexp and reference syntax '
 383             'respectively.  P must match the whole symbol name'
 384             ),
 385         man_help=(
 386             'Transform RCS/CVS symbol names before entering them into '
 387             'Subversion. \\fIpattern\\fR is a Python regexp pattern that '
 388             'is matches against the entire symbol name; \\fIreplacement\\fR '
 389             'is a replacement using Python\'s regexp reference syntax. '
 390             'You may specify any number of these options; they will be '
 391             'applied in the order given on the command line.'
 392             ),
 393         metavar='P:S',
 394         ))
 395     self.parser.set_default('symbol_strategy_rules', [])
 396     group.add_option(IncompatibleOption(
 397         '--symbol-hints', type='string',
 398         action='callback', callback=self.callback_symbol_hints,
 399         help='read symbol conversion hints from PATH',
 400         man_help=(
 401             'Read symbol conversion hints from \\fIpath\\fR.  The format of '
 402             '\\fIpath\\fR is the same as the format output by '
 403             '\\fB--write-symbol-info\\fR, namely a text file with four '
 404             'whitespace-separated columns: \\fIproject-id\\fR, '
 405             '\\fIsymbol\\fR, \\fIconversion\\fR, and '
 406             '\\fIparent-lod-name\\fR.  \\fIproject-id\\fR is the numerical '
 407             'ID of the project to which the symbol belongs, counting from '
 408             '0. \\fIproject-id\\fR can be set to \'.\' if '
 409             'project-specificity is not needed.  \\fIsymbol-name\\fR is the '
 410             'name of the symbol being specified.  \\fIconversion\\fR '
 411             'specifies how the symbol should be converted, and can be one '
 412             'of the values \'branch\', \'tag\', or \'exclude\'. If '
 413             '\\fIconversion\\fR is \'.\', then this rule does not affect '
 414             'how the symbol is converted.  \\fIparent-lod-name\\fR is the '
 415             'name of the symbol from which this symbol should sprout, or '
 416             '\'.trunk.\' if the symbol should sprout from trunk.  If '
 417             '\\fIparent-lod-name\\fR is omitted or \'.\', then this rule '
 418             'does not affect the preferred parent of this symbol. The file '
 419             'may contain blank lines or comment lines (lines whose first '
 420             'non-whitespace character is \'#\').'
 421             ),
 422         metavar='PATH',
 423         ))
 424     self.parser.set_default('symbol_default', 'heuristic')
 425     group.add_option(IncompatibleOption(
 426         '--symbol-default', type='choice',
 427         choices=['heuristic', 'strict', 'branch', 'tag'],
 428         action='store',
 429         help=(
 430             'specify how ambiguous symbols are converted.  '
 431             'OPT is "heuristic" (default), "strict", "branch", '
 432             'or "tag"'
 433             ),
 434         man_help=(
 435             'Specify how to convert ambiguous symbols (those that appear in '
 436             'the CVS archive as both branches and tags).  \\fIopt\\fR must '
 437             'be \'heuristic\' (decide how to treat each ambiguous symbol '
 438             'based on whether it was used more often as a branch/tag in '
 439             'CVS), \'strict\' (no default; every ambiguous symbol has to be '
 440             'resolved manually using \\fB--force-branch\\fR, '
 441             '\\fB--force-tag\\fR, or \\fB--exclude\\fR), \'branch\' (treat '
 442             'every ambiguous symbol as a branch), or \'tag\' (treat every '
 443             'ambiguous symbol as a tag).  The default is \'heuristic\'.'
 444             ),
 445         metavar='OPT',
 446         ))
 447     group.add_option(IncompatibleOption(
 448         '--force-branch', type='string',
 449         action='callback', callback=self.callback_force_branch,
 450         help='force symbols matching REGEXP to be branches',
 451         man_help=(
 452             'Force symbols whose names match \\fIregexp\\fR to be branches. '
 453             '\\fIregexp\\fR must match the whole symbol name.'
 454             ),
 455         metavar='REGEXP',
 456         ))
 457     group.add_option(IncompatibleOption(
 458         '--force-tag', type='string',
 459         action='callback', callback=self.callback_force_tag,
 460         help='force symbols matching REGEXP to be tags',
 461         man_help=(
 462             'Force symbols whose names match \\fIregexp\\fR to be tags. '
 463             '\\fIregexp\\fR must match the whole symbol name.'
 464             ),
 465         metavar='REGEXP',
 466         ))
 467     group.add_option(IncompatibleOption(
 468         '--exclude', type='string',
 469         action='callback', callback=self.callback_exclude,
 470         help='exclude branches and tags matching REGEXP',
 471         man_help=(
 472             'Exclude branches and tags whose names match \\fIregexp\\fR '
 473             'from the conversion.  \\fIregexp\\fR must match the whole '
 474             'symbol name.'
 475             ),
 476         metavar='REGEXP',
 477         ))
 478     self.parser.set_default('keep_trivial_imports', False)
 479     group.add_option(IncompatibleOption(
 480         '--keep-trivial-imports',
 481         action='store_true',
 482         help=(
 483             'do not exclude branches that were only used for '
 484             'a single import (usually these are unneeded)'
 485             ),
 486         man_help=(
 487             'Do not exclude branches that were only used for a single '
 488             'import. (By default such branches are excluded because they '
 489             'are usually created by the inappropriate use of \\fBcvs '
 490             'import\\fR.)'
 491             ),
 492         ))
 493
 494     return group
 495
 496   def _get_subversion_properties_options_group(self):
 497     group = OptionGroup(self.parser, 'Subversion properties')
 498     group.add_option(ContextOption(
 499         '--username', type='string',
 500         action='store',
 501         help='username for cvs2svn-synthesized commits',
 502         man_help=(
 503             'Set the default username to \\fIname\\fR when cvs2svn needs '
 504             'to generate a commit for which CVS does not record the '
 505             'original username. This happens when a branch or tag is '
 506             'created. The default is to use no author at all for such '
 507             'commits.'
 508             ),
 509         metavar='NAME',
 510         ))
 511     self.parser.set_default('auto_props_files', [])
 512     group.add_option(IncompatibleOption(
 513         '--auto-props', type='string',
 514         action='append', dest='auto_props_files',
 515         help=(
 516             'set file properties from the auto-props section '
 517             'of a file in svn config format'
 518             ),
 519         man_help=(
 520             'Specify a file in the format of Subversion\'s config file, '
 521             'whose [auto-props] section can be used to set arbitrary '
 522             'properties on files in the Subversion repository based on '
 523             'their filenames. (The [auto-props] section header must be '
 524             'present; other sections of the config file, including the '
 525             'enable-auto-props setting, are ignored.) Filenames are matched '
 526             'to the filename patterns case-insensitively.'
 527
 528             ),
 529         metavar='FILE',
 530         ))
 531     self.parser.set_default('mime_types_files', [])
 532     group.add_option(IncompatibleOption(
 533         '--mime-types', type='string',
 534         action='append', dest='mime_types_files',
 535         help=(
 536             'specify an apache-style mime.types file for setting '
 537             'svn:mime-type'
 538             ),
 539         man_help=(
 540             'Specify an apache-style mime.types \\fIfile\\fR for setting '
 541             'svn:mime-type.'
 542             ),
 543         metavar='FILE',
 544         ))
 545     self.parser.set_default('eol_from_mime_type', False)
 546     group.add_option(IncompatibleOption(
 547         '--eol-from-mime-type',
 548         action='store_true',
 549         help='set svn:eol-style from mime type if known',
 550         man_help=(
 551             'For files that don\'t have the kb expansion mode but have a '
 552             'known mime type, set the eol-style based on the mime type. '
 553             'For such files, set svn:eol-style to "native" if the mime type '
 554             'begins with "text/", and leave it unset (i.e., no EOL '
 555             'translation) otherwise. Files with unknown mime types are '
 556             'not affected by this option.  This option has no effect '
 557             'unless the \\fB--mime-types\\fR option is also specified.'
 558             ),
 559         ))
 560     group.add_option(IncompatibleOption(
 561         '--default-eol', type='choice',
 562         choices=['binary', 'native', 'CRLF', 'LF', 'CR'],
 563         action='store',
 564         help=(
 565             'default svn:eol-style for non-binary files with '
 566             'undetermined mime types.  STYLE is "binary" '
 567             '(default), "native", "CRLF", "LF", or "CR"'
 568             ),
 569         man_help=(
 570             'Set svn:eol-style to \\fIstyle\\fR for files that don\'t have '
 571             'the CVS \'kb\' expansion mode and whose end-of-line '
 572             'translation mode hasn\'t been determined by one of the other '
 573             'options. \\fIstyle\\fR must be \'binary\' (default), '
 574             '\'native\', \'CRLF\', \'LF\', or \'CR\'.'
 575             ),
 576         metavar='STYLE',
 577         ))
 578     self.parser.set_default('keywords_off', False)
 579     group.add_option(IncompatibleOption(
 580         '--keywords-off',
 581         action='store_true',
 582         help=(
 583             'don\'t set svn:keywords on any files (by default, '
 584             'cvs2svn sets svn:keywords on non-binary files to "%s")'
 585             % (config.SVN_KEYWORDS_VALUE,)
 586             ),
 587         man_help=(
 588             'By default, cvs2svn sets svn:keywords on CVS files to "author '
 589             'id date" if the mode of the RCS file in question is either kv, '
 590             'kvl or unset. If you use the --keywords-off switch, cvs2svn '
 591             'will not set svn:keywords for any file. While this will not '
 592             'touch the keywords in the contents of your files, Subversion '
 593             'will not expand them.'
 594             ),
 595         ))
 596     group.add_option(ContextOption(
 597         '--keep-cvsignore',
 598         action='store_true',
 599         help=(
 600             'keep .cvsignore files (in addition to creating '
 601             'the analogous svn:ignore properties)'
 602             ),
 603         man_help=(
 604             'Include \\fI.cvsignore\\fR files in the output.  (Normally '
 605             'they are unneeded because cvs2svn sets the corresponding '
 606             '\\fIsvn:ignore\\fR properties.)'
 607             ),
 608         ))
 609     group.add_option(IncompatibleOption(
 610         '--cvs-revnums',
 611         action='callback', callback=self.callback_cvs_revnums,
 612         help='record CVS revision numbers as file properties',
 613         man_help=(
 614             'Record CVS revision numbers as file properties in the '
 615             'Subversion repository. (Note that unless it is removed '
 616             'explicitly, the last CVS revision number will remain '
 617             'associated with the file even after the file is changed '
 618             'within Subversion.)'
 619             ),
 620         ))
 621
 622     # Deprecated options:
 623     group.add_option(IncompatibleOption(
 624         '--no-default-eol',
 625         action='store_const', dest='default_eol', const=None,
 626         help=optparse.SUPPRESS_HELP,
 627         man_help=optparse.SUPPRESS_HELP,
 628         ))
 629     self.parser.set_default('auto_props_ignore_case', True)
 630     # True is the default now, so this option has no effect:
 631     group.add_option(IncompatibleOption(
 632         '--auto-props-ignore-case',
 633         action='store_true',
 634         help=optparse.SUPPRESS_HELP,
 635         man_help=optparse.SUPPRESS_HELP,
 636         ))
 637
 638     return group
 639
 640   def _get_extraction_options_group(self):
 641     group = OptionGroup(self.parser, 'Extraction options')
 642
 643     return group
 644
 645   def _get_environment_options_group(self):
 646     group = OptionGroup(self.parser, 'Environment options')
 647     group.add_option(ContextOption(
 648         '--tmpdir', type='string',
 649         action='store',
 650         help=(
 651             'directory to use for temporary data files '
 652             '(default "cvs2svn-tmp")'
 653             ),
 654         man_help=(
 655             'Set the \\fIpath\\fR to use for temporary data. Default '
 656             'is a directory called \\fIcvs2svn-tmp\\fR under the current '
 657             'directory.'
 658             ),
 659         metavar='PATH',
 660         ))
 661     self.parser.set_default('co_executable', config.CO_EXECUTABLE)
 662     group.add_option(IncompatibleOption(
 663         '--co', type='string',
 664         action='store', dest='co_executable',
 665         help='path to the "co" program (required if --use-rcs)',
 666         man_help=(
 667             'Path to the \\fIco\\fR program.  (\\fIco\\fR is needed if the '
 668             '\\fB--use-rcs\\fR option is used.)'
 669             ),
 670         metavar='PATH',
 671         ))
 672     self.parser.set_default('cvs_executable', config.CVS_EXECUTABLE)
 673     group.add_option(IncompatibleOption(
 674         '--cvs', type='string',
 675         action='store', dest='cvs_executable',
 676         help='path to the "cvs" program (required if --use-cvs)',
 677         man_help=(
 678             'Path to the \\fIcvs\\fR program.  (\\fIcvs\\fR is needed if the '
 679             '\\fB--use-cvs\\fR option is used.)'
 680             ),
 681         metavar='PATH',
 682         ))
 683     group.add_option(ContextOption(
 684         '--sort', type='string',
 685         action='store', dest='sort_executable',
 686         compatible_with_option=True,
 687         help='path to the GNU "sort" program',
 688         man_help=(
 689             'Path to the GNU \\fIsort\\fR program.  (cvs2svn requires GNU '
 690             'sort.)'
 691             ),
 692         metavar='PATH',
 693         ))
 694
 695     return group
 696
 697   def _get_partial_conversion_options_group(self):
 698     group = OptionGroup(self.parser, 'Partial conversions')
 699     group.add_option(ManOption(
 700         '--pass', type='string',
 701         action='callback', callback=self.callback_passes,
 702         help='execute only specified PASS of conversion',
 703         man_help=(
 704             'Execute only pass \\fIpass\\fR of the conversion. '
 705             '\\fIpass\\fR can be specified by name or by number (see '
 706             '\\fB--help-passes\\fR).'
 707             ),
 708         metavar='PASS',
 709         ))
 710     group.add_option(ManOption(
 711         '--passes', '-p', type='string',
 712         action='callback', callback=self.callback_passes,
 713         help=(
 714             'execute passes START through END, inclusive (PASS, '
 715             'START, and END can be pass names or numbers)'
 716             ),
 717         man_help=(
 718             'Execute passes \\fIstart\\fR through \\fIend\\fR of the '
 719             'conversion (inclusive). \\fIstart\\fR and \\fIend\\fR can be '
 720             'specified by name or by number (see \\fB--help-passes\\fR). '
 721             'If \\fIstart\\fR or \\fIend\\fR is missing, it defaults to '
 722             'the first or last pass, respectively. For this to work the '
 723             'earlier passes must have been completed before on the '
 724             'same CVS repository, and the generated data files must be '
 725             'in the temporary directory (see \\fB--tmpdir\\fR).'
 726             ),
 727         metavar='[START]:[END]',
 728         ))
 729
 730     return group
 731
 732   def _get_information_options_group(self):
 733     group = OptionGroup(self.parser, 'Information options')
 734     group.add_option(ManOption(
 735         '--version',
 736         action='callback', callback=self.callback_version,
 737         help='print the version number',
 738         man_help='Print the version number.',
 739         ))
 740     group.add_option(ManOption(
 741         '--help', '-h',
 742         action="help",
 743         help='print this usage message and exit with success',
 744         man_help='Print the usage message and exit with success.',
 745         ))
 746     group.add_option(ManOption(
 747         '--help-passes',
 748         action='callback', callback=self.callback_help_passes,
 749         help='list the available passes and their numbers',
 750         man_help=(
 751             'Print the numbers and names of the conversion passes and '
 752             'exit with success.'
 753             ),
 754         ))
 755     group.add_option(ManOption(
 756         '--man',
 757         action='callback', callback=self.callback_manpage,
 758         help='write the manpage for this program to standard output',
 759         man_help=(
 760             'Output the unix-style manpage for this program to standard '
 761             'output.'
 762             ),
 763         ))
 764     group.add_option(ManOption(
 765         '--verbose', '-v',
 766         action='callback', callback=self.callback_verbose,
 767         help='verbose (may be specified twice for debug output)',
 768         man_help=(
 769             'Print more information while running. This option may be '
 770             'specified twice to output voluminous debugging information.'
 771             ),
 772         ))
 773     group.add_option(ManOption(
 774         '--quiet', '-q',
 775         action='callback', callback=self.callback_quiet,
 776         help='quiet (may be specified twice for very quiet)',
 777         man_help=(
 778             'Print less information while running. This option may be '
 779             'specified twice to suppress all non-error output.'
 780             ),
 781         ))
 782     group.add_option(ContextOption(
 783         '--write-symbol-info', type='string',
 784         action='store', dest='symbol_info_filename',
 785         help='write information and statistics about CVS symbols to PATH.',
 786         man_help=(
 787             'Write to \\fIpath\\fR symbol statistics and information about '
 788             'how symbols were converted during CollateSymbolsPass.'
 789             ),
 790         metavar='PATH',
 791         ))
 792     group.add_option(ContextOption(
 793         '--skip-cleanup',
 794         action='store_true',
 795         help='prevent the deletion of intermediate files',
 796         man_help='Prevent the deletion of temporary files.',
 797         ))
 798     group.add_option(ManOption(
 799         '--profile',
 800         action='callback', callback=self.callback_profile,
 801         help='profile with \'hotshot\' (into file cvs2svn.hotshot)',
 802         man_help=(
 803             'Profile with \'hotshot\' (into file \\fIcvs2svn.hotshot\\fR).'
 804             ),
 805         ))
 806
 807     return group
 808
 809   def callback_options(self, option, opt_str, value, parser):
 810     parser.values.options_file_found = True
 811     self.process_options_file(value)
 812
 813   def callback_encoding(self, option, opt_str, value, parser):
 814     ctx = Ctx()
 815
 816     try:
 817       ctx.cvs_author_decoder.add_encoding(value)
 818       ctx.cvs_log_decoder.add_encoding(value)
 819       ctx.cvs_filename_decoder.add_encoding(value)
 820     except LookupError, e:
 821       raise FatalError(str(e))
 822
 823   def callback_fallback_encoding(self, option, opt_str, value, parser):
 824     ctx = Ctx()
 825
 826     try:
 827       ctx.cvs_author_decoder.set_fallback_encoding(value)
 828       ctx.cvs_log_decoder.set_fallback_encoding(value)
 829       # Don't use fallback_encoding for filenames.
 830     except LookupError, e:
 831       raise FatalError(str(e))
 832
 833   def callback_help_passes(self, option, opt_str, value, parser):
 834     self.pass_manager.help_passes()
 835     sys.exit(0)
 836
 837   def callback_manpage(self, option, opt_str, value, parser):
 838     raise NotImplementedError()
 839
 840   def callback_version(self, option, opt_str, value, parser):
 841     sys.stdout.write(
 842         '%s version %s\n' % (self.progname, VERSION)
 843         )
 844     sys.exit(0)
 845
 846   def callback_verbose(self, option, opt_str, value, parser):
 847     Log().increase_verbosity()
 848
 849   def callback_quiet(self, option, opt_str, value, parser):
 850     Log().decrease_verbosity()
 851
 852   def callback_passes(self, option, opt_str, value, parser):
 853     if value.find(':') >= 0:
 854       start_pass, end_pass = value.split(':')
 855       self.start_pass = self.pass_manager.get_pass_number(start_pass, 1)
 856       self.end_pass = self.pass_manager.get_pass_number(
 857           end_pass, self.pass_manager.num_passes
 858           )
 859     else:
 860       self.end_pass = \
 861           self.start_pass = \
 862           self.pass_manager.get_pass_number(value)
 863
 864   def callback_profile(self, option, opt_str, value, parser):
 865     self.profiling = True
 866
 867   def callback_symbol_hints(self, option, opt_str, value, parser):
 868     parser.values.symbol_strategy_rules.append(SymbolHintsFileRule(value))
 869
 870   def callback_force_branch(self, option, opt_str, value, parser):
 871     parser.values.symbol_strategy_rules.append(
 872         ForceBranchRegexpStrategyRule(value)
 873         )
 874
 875   def callback_force_tag(self, option, opt_str, value, parser):
 876     parser.values.symbol_strategy_rules.append(
 877         ForceTagRegexpStrategyRule(value)
 878         )
 879
 880   def callback_exclude(self, option, opt_str, value, parser):
 881     parser.values.symbol_strategy_rules.append(
 882         ExcludeRegexpStrategyRule(value)
 883         )
 884
 885   def callback_cvs_revnums(self, option, opt_str, value, parser):
 886     Ctx().svn_property_setters.append(CVSRevisionNumberSetter())
 887
 888   def callback_symbol_transform(self, option, opt_str, value, parser):
 889     [pattern, replacement] = value.split(":")
 890     try:
 891       parser.values.symbol_transforms.append(
 892           RegexpSymbolTransform(pattern, replacement)
 893           )
 894     except re.error:
 895       raise FatalError("'%s' is not a valid regexp." % (pattern,))
 896
 897   def process_symbol_strategy_options(self):
 898     """Process symbol strategy-related options."""
 899
 900     ctx = Ctx()
 901     options = self.options
 902
 903     # Add the standard symbol name cleanup rules:
 904     self.options.symbol_transforms.extend([
 905         ReplaceSubstringsSymbolTransform('\\','/'),
 906         # Remove leading, trailing, and repeated slashes:
 907         NormalizePathsSymbolTransform(),
 908         ])
 909
 910     if ctx.trunk_only:
 911       if options.symbol_strategy_rules or options.keep_trivial_imports:
 912         raise SymbolOptionsWithTrunkOnlyException()
 913
 914     else:
 915       if not options.keep_trivial_imports:
 916         options.symbol_strategy_rules.append(ExcludeTrivialImportBranchRule())
 917
 918       options.symbol_strategy_rules.append(UnambiguousUsageRule())
 919       if options.symbol_default == 'strict':
 920         pass
 921       elif options.symbol_default == 'branch':
 922         options.symbol_strategy_rules.append(AllBranchRule())
 923       elif options.symbol_default == 'tag':
 924         options.symbol_strategy_rules.append(AllTagRule())
 925       elif options.symbol_default == 'heuristic':
 926         options.symbol_strategy_rules.append(BranchIfCommitsRule())
 927         options.symbol_strategy_rules.append(HeuristicStrategyRule())
 928       else:
 929         assert False
 930
 931       # Now add a rule whose job it is to pick the preferred parents of
 932       # branches and tags:
 933       options.symbol_strategy_rules.append(HeuristicPreferredParentRule())
 934
 935   def process_property_setter_options(self):
 936     """Process the options that set SVN properties."""
 937
 938     ctx = Ctx()
 939     options = self.options
 940
 941     for value in options.auto_props_files:
 942       ctx.svn_property_setters.append(
 943           AutoPropsPropertySetter(value, options.auto_props_ignore_case)
 944           )
 945
 946     for value in options.mime_types_files:
 947       ctx.svn_property_setters.append(MimeMapper(value))
 948
 949     ctx.svn_property_setters.append(CVSBinaryFileEOLStyleSetter())
 950
 951     ctx.svn_property_setters.append(CVSBinaryFileDefaultMimeTypeSetter())
 952
 953     if options.eol_from_mime_type:
 954       ctx.svn_property_setters.append(EOLStyleFromMimeTypeSetter())
 955
 956     ctx.svn_property_setters.append(
 957         DefaultEOLStyleSetter(options.default_eol)
 958         )
 959
 960     ctx.svn_property_setters.append(SVNBinaryFileKeywordsPropertySetter())
 961
 962     if not options.keywords_off:
 963       ctx.svn_property_setters.append(
 964           KeywordsPropertySetter(config.SVN_KEYWORDS_VALUE))
 965
 966     ctx.svn_property_setters.append(ExecutablePropertySetter())
 967
 968   def process_options(self):
 969     """Do the main configuration based on command-line options.
 970
 971     This method is only called if the --options option was not
 972     specified."""
 973
 974     raise NotImplementedError()
 975
 976   def check_options(self):
 977     """Check the the run options are OK.
 978
 979     This should only be called after all options have been processed."""
 980
 981     # Convenience var, so we don't have to keep instantiating this Borg.
 982     ctx = Ctx()
 983
 984     if not self.start_pass <= self.end_pass:
 985       raise InvalidPassError(
 986           'Ending pass must not come before starting pass.')
 987
 988     if not ctx.dry_run and ctx.output_option is None:
 989       raise FatalError('No output option specified.')
 990
 991     if ctx.output_option is not None:
 992       ctx.output_option.check()
 993
 994     if not self.projects:
 995       raise FatalError('No project specified.')
 996
 997   def verify_option_compatibility(self):
 998     """Verify that no options incompatible with --options were used.
 999
1000     The --options option was specified.  Verify that no incompatible
1001     options or arguments were specified."""
1002
1003     if self.options.options_incompatible_options or self.args:
1004       if self.options.options_incompatible_options:
1005         oio = self.options.options_incompatible_options
1006         Log().error(
1007             '%s: The following options cannot be used in combination with '
1008             'the --options\n'
1009             'option:\n'
1010             '    %s\n'
1011             % (error_prefix, '\n    '.join(oio))
1012             )
1013       if self.args:
1014         Log().error(
1015             '%s: No cvs-repos-path arguments are allowed with the --options '
1016             'option.\n'
1017             % (error_prefix,)
1018             )
1019       sys.exit(1)
1020
1021   def process_options_file(self, options_filename):
1022     """Read options from the file named OPTIONS_FILENAME.
1023
1024     Store the run options to SELF."""
1025
1026     g = {
1027       'ctx' : Ctx(),
1028       'run_options' : self,
1029       }
1030     execfile(options_filename, g)
1031
1032   def usage(self):
1033     self.parser.print_help()
1034
1035