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