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 error_prefix
  30 from cvs2svn_lib.common import FatalError
  31 from cvs2svn_lib.man_writer import ManWriter
  32 from cvs2svn_lib.log import Log
  33 from cvs2svn_lib.context import Ctx
  34 from cvs2svn_lib.man_writer import ManOption
  35 from cvs2svn_lib.pass_manager import InvalidPassError
  36 from cvs2svn_lib.revision_manager import NullRevisionCollector
  37 from cvs2svn_lib.rcs_revision_manager import RCSRevisionReader
  38 from cvs2svn_lib.cvs_revision_manager import CVSRevisionReader
  39 from cvs2svn_lib.checkout_internal import InternalRevisionCollector
  40 from cvs2svn_lib.checkout_internal import InternalRevisionReader
  41 from cvs2svn_lib.symbol_strategy import AllBranchRule
  42 from cvs2svn_lib.symbol_strategy import AllExcludedRule
  43 from cvs2svn_lib.symbol_strategy import AllTagRule
  44 from cvs2svn_lib.symbol_strategy import BranchIfCommitsRule
  45 from cvs2svn_lib.symbol_strategy import ExcludeRegexpStrategyRule
  46 from cvs2svn_lib.symbol_strategy import ForceBranchRegexpStrategyRule
  47 from cvs2svn_lib.symbol_strategy import ForceTagRegexpStrategyRule
  48 from cvs2svn_lib.symbol_strategy import ExcludeTrivialImportBranchRule
  49 from cvs2svn_lib.symbol_strategy import HeuristicStrategyRule
  50 from cvs2svn_lib.symbol_strategy import UnambiguousUsageRule
  51 from cvs2svn_lib.symbol_strategy import HeuristicPreferredParentRule
  52 from cvs2svn_lib.symbol_strategy import SymbolHintsFileRule
  53 from cvs2svn_lib.symbol_transform import ReplaceSubstringsSymbolTransform
  54 from cvs2svn_lib.symbol_transform import RegexpSymbolTransform
  55 from cvs2svn_lib.symbol_transform import NormalizePathsSymbolTransform
  56 from cvs2svn_lib.property_setters import AutoPropsPropertySetter
  57 from cvs2svn_lib.property_setters import CVSBinaryFileDefaultMimeTypeSetter
  58 from cvs2svn_lib.property_setters import CVSBinaryFileEOLStyleSetter
  59 from cvs2svn_lib.property_setters import CVSRevisionNumberSetter
  60 from cvs2svn_lib.property_setters import DefaultEOLStyleSetter
  61 from cvs2svn_lib.property_setters import EOLStyleFromMimeTypeSetter
  62 from cvs2svn_lib.property_setters import ExecutablePropertySetter
  63 from cvs2svn_lib.property_setters import DescriptionPropertySetter
  64 from cvs2svn_lib.property_setters import KeywordsPropertySetter
  65 from cvs2svn_lib.property_setters import MimeMapper
  66 from cvs2svn_lib.property_setters import SVNBinaryFileKeywordsPropertySetter
  67
  68
  69 usage = """\
  70 Usage: %prog --options OPTIONFILE
  71        %prog [OPTION...] OUTPUT-OPTION CVS-REPOS-PATH"""
  72
  73 description="""\
  74 Convert a CVS repository into a Subversion repository, including history.
  75 """
  76
  77
  78 class IncompatibleOption(ManOption):
  79   """A ManOption that is incompatible with the --options option.
  80
  81   Record that the option was used so that error checking can later be
  82   done."""
  83
  84   def __init__(self, *args, **kw):
  85     ManOption.__init__(self, *args, **kw)
  86
  87   def take_action(self, action, dest, opt, value, values, parser):
  88     oio = parser.values.options_incompatible_options
  89     if opt not in oio:
  90       oio.append(opt)
  91     return ManOption.take_action(
  92         self, action, dest, opt, value, values, parser
  93         )
  94
  95
  96 class ContextOption(ManOption):
  97   """A ManOption that stores its value to Ctx."""
  98
  99   def __init__(self, *args, **kw):
 100     if kw.get('action') not in self.STORE_ACTIONS:
 101       raise ValueError('Invalid action: %s' % (kw['action'],))
 102
 103     self.__compatible_with_option = kw.pop('compatible_with_option', False)
 104     self.__action = kw.pop('action')
 105     try:
 106       self.__dest = kw.pop('dest')
 107     except KeyError:
 108       opt = args[0]
 109       if not opt.startswith('--'):
 110         raise ValueError
 111       self.__dest = opt[2:].replace('-', '_')
 112     if 'const' in kw:
 113       self.__const = kw.pop('const')
 114
 115     kw['action'] = 'callback'
 116     kw['callback'] = self.__callback
 117
 118     ManOption.__init__(self, *args, **kw)
 119
 120   def __callback(self, option, opt_str, value, parser):
 121     if not self.__compatible_with_option:
 122       oio = parser.values.options_incompatible_options
 123       if opt_str not in oio:
 124         oio.append(opt_str)
 125
 126     action = self.__action
 127     dest = self.__dest
 128
 129     if action == "store":
 130         setattr(Ctx(), dest, value)
 131     elif action == "store_const":
 132         setattr(Ctx(), dest, self.__const)
 133     elif action == "store_true":
 134         setattr(Ctx(), dest, True)
 135     elif action == "store_false":
 136         setattr(Ctx(), dest, False)
 137     elif action == "append":
 138         getattr(Ctx(), dest).append(value)
 139     elif action == "count":
 140         setattr(Ctx(), dest, getattr(Ctx(), dest, 0) + 1)
 141     else:
 142         raise RuntimeError("unknown action %r" % self.__action)
 143
 144     return 1
 145
 146
 147 class IncompatibleOptionsException(FatalError):
 148   pass
 149
 150
 151 # Options that are not allowed to be used with --trunk-only:
 152 SYMBOL_OPTIONS = [
 153     '--symbol-transform',
 154     '--symbol-hints',
 155     '--force-branch',
 156     '--force-tag',
 157     '--exclude',
 158     '--keep-trivial-imports',
 159     '--symbol-default',
 160     '--no-cross-branch-commits',
 161     ]
 162
 163 class SymbolOptionsWithTrunkOnlyException(IncompatibleOptionsException):
 164   def __init__(self):
 165     IncompatibleOptionsException.__init__(
 166         self,
 167         'The following symbol-related options cannot be used together\n'
 168         'with --trunk-only:\n'
 169         '    %s'
 170         % ('\n    '.join(SYMBOL_OPTIONS),)
 171         )
 172
 173
 174 def not_both(opt1val, opt1name, opt2val, opt2name):
 175   """Raise an exception if both opt1val and opt2val are set."""
 176   if opt1val and opt2val:
 177     raise IncompatibleOptionsException(
 178         "cannot pass both '%s' and '%s'." % (opt1name, opt2name,)
 179         )
 180
 181
 182 class RunOptions(object):
 183   """A place to store meta-options that are used to start the conversion."""
 184
 185   # Components of the man page.  Attributes set to None here must be set
 186   # by subclasses; others may be overridden/augmented by subclasses if
 187   # they wish.
 188   short_desc = None
 189   synopsis = None
 190   long_desc = None
 191   files = None
 192   authors = [
 193     u"C. Michael Pilato <cmpilato@collab.net>",
 194     u"Greg Stein <gstein@lyra.org>",
 195     u"Branko \u010cibej <brane@xbc.nu>",
 196     u"Blair Zajac <blair@orcaware.com>",
 197     u"Max Bowsher <maxb@ukf.net>",
 198     u"Brian Fitzpatrick <fitz@red-bean.com>",
 199     u"Tobias Ringstr\u00f6m <tobias@ringstrom.mine.nu>",
 200     u"Karl Fogel <kfogel@collab.net>",
 201     u"Erik H\u00fclsmann <e.huelsmann@gmx.net>",
 202     u"David Summers <david@summersoft.fay.ar.us>",
 203     u"Michael Haggerty <mhagger@alum.mit.edu>",
 204     ]
 205   see_also = None
 206
 207   def __init__(self, progname, cmd_args, pass_manager):
 208     """Process the command-line options, storing run options to SELF.
 209
 210     PROGNAME is the name of the program, used in the usage string.
 211     CMD_ARGS is the list of command-line arguments passed to the
 212     program.  PASS_MANAGER is an instance of PassManager, needed to
 213     help process the -p and --help-passes options."""
 214
 215     self.progname = progname
 216     self.cmd_args = cmd_args
 217     self.pass_manager = pass_manager
 218     self.start_pass = 1
 219     self.end_pass = self.pass_manager.num_passes
 220     self.profiling = False
 221
 222     self.projects = []
 223
 224     # A list of one list of SymbolStrategyRules for each project:
 225     self.project_symbol_strategy_rules = []
 226
 227     parser = self.parser = optparse.OptionParser(
 228         usage=usage,
 229         description=self.get_description(),
 230         add_help_option=False,
 231         )
 232     # A place to record any options used that are incompatible with
 233     # --options:
 234     parser.set_default('options_incompatible_options', [])
 235
 236     # Populate the options parser with the options, one group at a
 237     # time:
 238     parser.add_option_group(self._get_options_file_options_group())
 239     parser.add_option_group(self._get_output_options_group())
 240     parser.add_option_group(self._get_conversion_options_group())
 241     parser.add_option_group(self._get_symbol_handling_options_group())
 242     parser.add_option_group(self._get_subversion_properties_options_group())
 243     parser.add_option_group(self._get_extraction_options_group())
 244     parser.add_option_group(self._get_environment_options_group())
 245     parser.add_option_group(self._get_partial_conversion_options_group())
 246     parser.add_option_group(self._get_information_options_group())
 247
 248     (self.options, self.args) = parser.parse_args(args=self.cmd_args)
 249
 250     # Now the log level has been set; log the time when the run started:
 251     Log().verbose(
 252         time.strftime(
 253             'Conversion start time: %Y-%m-%d %I:%M:%S %Z',
 254             time.localtime(Log().start_time)
 255             )
 256         )
 257
 258     if self.options.options_file_found:
 259       # Check that no options that are incompatible with --options
 260       # were used:
 261       self.verify_option_compatibility()
 262     else:
 263       # --options was not specified.  So do the main initialization
 264       # based on other command-line options:
 265       self.process_options()
 266
 267     # Check for problems with the options:
 268     self.check_options()
 269
 270   def get_description(self):
 271     return description
 272
 273   def _get_options_file_options_group(self):
 274     group = OptionGroup(
 275         self.parser, 'Configuration via options file'
 276         )
 277     self.parser.set_default('options_file_found', False)
 278     group.add_option(ManOption(
 279         '--options', type='string',
 280         action='callback', callback=self.callback_options,
 281         help=(
 282             'read the conversion options from PATH.  This '
 283             'method allows more flexibility than using '
 284             'command-line options.  See documentation for info'
 285             ),
 286         man_help=(
 287             'Read the conversion options from \\fIpath\\fR instead of from '
 288             'the command line.  This option allows far more conversion '
 289             'flexibility than can be achieved using the command-line alone. '
 290             'See the documentation for more information.  Only the following '
 291             'command-line options are allowed in combination with '
 292             '\\fB--options\\fR: \\fB-h\\fR/\\fB--help\\fR, '
 293             '\\fB--help-passes\\fR, \\fB--version\\fR, '
 294             '\\fB-v\\fR/\\fB--verbose\\fR, \\fB-q\\fR/\\fB--quiet\\fR, '
 295             '\\fB-p\\fR/\\fB--pass\\fR/\\fB--passes\\fR, \\fB--dry-run\\fR, '
 296             '\\fB--profile\\fR, \\fB--trunk-only\\fR, \\fB--encoding\\fR, '
 297             'and \\fB--fallback-encoding\\fR. '
 298             'Options are processed in the order specified on the command '
 299             'line.'
 300             ),
 301         metavar='PATH',
 302         ))
 303     return group
 304
 305   def _get_output_options_group(self):
 306     group = OptionGroup(self.parser, 'Output options')
 307     return group
 308
 309   def _get_conversion_options_group(self):
 310     group = OptionGroup(self.parser, 'Conversion options')
 311     group.add_option(ContextOption(
 312         '--trunk-only',
 313         action='store_true',
 314         compatible_with_option=True,
 315         help='convert only trunk commits, not tags nor branches',
 316         man_help=(
 317             'Convert only trunk commits, not tags nor branches.'
 318             ),
 319         ))
 320     group.add_option(ManOption(
 321         '--encoding', type='string',
 322         action='callback', callback=self.callback_encoding,
 323         help=(
 324             'encoding for paths and log messages in CVS repos.  '
 325             'If option is specified multiple times, encoders '
 326             'are tried in order until one succeeds.  See '
 327             'http://docs.python.org/lib/standard-encodings.html '
 328             'for a list of standard Python encodings.'
 329             ),
 330         man_help=(
 331             'Use \\fIencoding\\fR as the encoding for filenames, log '
 332             'messages, and author names in the CVS repos.  This option '
 333             'may be specified multiple times, in which case the encodings '
 334             'are tried in order until one succeeds.  Default: ascii.  See '
 335             'http://docs.python.org/lib/standard-encodings.html for a list '
 336             'of other standard encodings.'
 337             ),
 338         metavar='ENC',
 339         ))
 340     group.add_option(ManOption(
 341         '--fallback-encoding', type='string',
 342         action='callback', callback=self.callback_fallback_encoding,
 343         help='If all --encodings fail, use lossy encoding with ENC',
 344         man_help=(
 345             'If none of the encodings specified with \\fB--encoding\\fR '
 346             'succeed in decoding an author name or log message, then fall '
 347             'back to using \\fIencoding\\fR in lossy \'replace\' mode. '
 348             'Use of this option may cause information to be lost, but at '
 349             'least it allows the conversion to run to completion.  This '
 350             'option only affects the encoding of log messages and author '
 351             'names; there is no fallback encoding for filenames.  (By '
 352             'using an \\fB--options\\fR file, it is possible to specify '
 353             'a fallback encoding for filenames.)  Default: disabled.'
 354             ),
 355         metavar='ENC',
 356         ))
 357     group.add_option(ContextOption(
 358         '--retain-conflicting-attic-files',
 359         action='store_true',
 360         help=(
 361             'if a file appears both in and out of '
 362             'the CVS Attic, then leave the attic version in a '
 363             'SVN directory called "Attic"'
 364             ),
 365         man_help=(
 366             'If a file appears both inside an outside of the CVS attic, '
 367             'retain the attic version in an SVN subdirectory called '
 368             '\'Attic\'.  (Normally this situation is treated as a fatal '
 369             'error.)'
 370             ),
 371         ))
 372
 373     return group
 374
 375   def _get_symbol_handling_options_group(self):
 376     group = OptionGroup(self.parser, 'Symbol handling')
 377     self.parser.set_default('symbol_transforms', [])
 378     group.add_option(IncompatibleOption(
 379         '--symbol-transform', type='string',
 380         action='callback', callback=self.callback_symbol_transform,
 381         help=(
 382             'transform symbol names from P to S, where P and S '
 383             'use Python regexp and reference syntax '
 384             'respectively.  P must match the whole symbol name'
 385             ),
 386         man_help=(
 387             'Transform RCS/CVS symbol names before entering them into '
 388             'Subversion. \\fIpattern\\fR is a Python regexp pattern that '
 389             'is matches against the entire symbol name; \\fIreplacement\\fR '
 390             'is a replacement using Python\'s regexp reference syntax. '
 391             'You may specify any number of these options; they will be '
 392             'applied in the order given on the command line.'
 393             ),
 394         metavar='P:S',
 395         ))
 396     self.parser.set_default('symbol_strategy_rules', [])
 397     group.add_option(IncompatibleOption(
 398         '--symbol-hints', type='string',
 399         action='callback', callback=self.callback_symbol_hints,
 400         help='read symbol conversion hints from PATH',
 401         man_help=(
 402             'Read symbol conversion hints from \\fIpath\\fR.  The format of '
 403             '\\fIpath\\fR is the same as the format output by '
 404             '\\fB--write-symbol-info\\fR, namely a text file with four '
 405             'whitespace-separated columns: \\fIproject-id\\fR, '
 406             '\\fIsymbol\\fR, \\fIconversion\\fR, and '
 407             '\\fIparent-lod-name\\fR.  \\fIproject-id\\fR is the numerical '
 408             'ID of the project to which the symbol belongs, counting from '
 409             '0. \\fIproject-id\\fR can be set to \'.\' if '
 410             'project-specificity is not needed.  \\fIsymbol-name\\fR is the '
 411             'name of the symbol being specified.  \\fIconversion\\fR '
 412             'specifies how the symbol should be converted, and can be one '
 413             'of the values \'branch\', \'tag\', or \'exclude\'. If '
 414             '\\fIconversion\\fR is \'.\', then this rule does not affect '
 415             'how the symbol is converted.  \\fIparent-lod-name\\fR is the '
 416             'name of the symbol from which this symbol should sprout, or '
 417             '\'.trunk.\' if the symbol should sprout from trunk.  If '
 418             '\\fIparent-lod-name\\fR is omitted or \'.\', then this rule '
 419             'does not affect the preferred parent of this symbol. The file '
 420             'may contain blank lines or comment lines (lines whose first '
 421             'non-whitespace character is \'#\').'
 422             ),
 423         metavar='PATH',
 424         ))
 425     self.parser.set_default('symbol_default', 'heuristic')
 426     group.add_option(IncompatibleOption(
 427         '--symbol-default', type='choice',
 428         choices=['heuristic', 'strict', 'branch', 'tag', 'exclude'],
 429         action='store',
 430         help=(
 431             'specify how ambiguous symbols are converted.  '
 432             'OPT is "heuristic" (default), "strict", "branch", '
 433             '"tag" or "exclude"'
 434             ),
 435         man_help=(
 436             'Specify how to convert ambiguous symbols (those that appear in '
 437             'the CVS archive as both branches and tags).  \\fIopt\\fR must '
 438             'be \'heuristic\' (decide how to treat each ambiguous symbol '
 439             'based on whether it was used more often as a branch/tag in '
 440             'CVS), \'strict\' (no default; every ambiguous symbol has to be '
 441             'resolved manually using \\fB--force-branch\\fR, '
 442             '\\fB--force-tag\\fR, or \\fB--exclude\\fR), \'branch\' (treat '
 443             'every ambiguous symbol as a branch), \'tag\' (treat every '
 444             'ambiguous symbol as a tag), or \'exclude\' (do not convert '
 445             'ambiguous symbols).  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     prof = 'cProfile'
 839     try:
 840         import cProfile
 841     except ImportError, e:
 842         prof = 'hotshot'
 843     group.add_option(ManOption(
 844         '--profile',
 845         action='callback', callback=self.callback_profile,
 846         help='profile with \'' + prof + '\' (into file cvs2svn.' + prof + ')',
 847         man_help=(
 848             'Profile with \'' + prof + '\' (into file \\fIcvs2svn.' + prof + '\\fR).'
 849             ),
 850         ))
 851
 852     return group
 853
 854   def callback_options(self, option, opt_str, value, parser):
 855     parser.values.options_file_found = True
 856     self.process_options_file(value)
 857
 858   def callback_encoding(self, option, opt_str, value, parser):
 859     ctx = Ctx()
 860
 861     try:
 862       ctx.cvs_author_decoder.add_encoding(value)
 863       ctx.cvs_log_decoder.add_encoding(value)
 864       ctx.cvs_filename_decoder.add_encoding(value)
 865     except LookupError, e:
 866       raise FatalError(str(e))
 867
 868   def callback_fallback_encoding(self, option, opt_str, value, parser):
 869     ctx = Ctx()
 870
 871     try:
 872       ctx.cvs_author_decoder.set_fallback_encoding(value)
 873       ctx.cvs_log_decoder.set_fallback_encoding(value)
 874       # Don't use fallback_encoding for filenames.
 875     except LookupError, e:
 876       raise FatalError(str(e))
 877
 878   def callback_help_passes(self, option, opt_str, value, parser):
 879     self.pass_manager.help_passes()
 880     sys.exit(0)
 881
 882   def callback_manpage(self, option, opt_str, value, parser):
 883     f = codecs.getwriter('utf_8')(sys.stdout)
 884     writer = ManWriter(parser,
 885                        section='1',
 886                        date=datetime.date.today(),
 887                        source='Version %s' % (VERSION,),
 888                        manual='User Commands',
 889                        short_desc=self.short_desc,
 890                        synopsis=self.synopsis,
 891                        long_desc=self.long_desc,
 892                        files=self.files,
 893                        authors=self.authors,
 894                        see_also=self.see_also)
 895     writer.write_manpage(f)
 896     sys.exit(0)
 897
 898   def callback_version(self, option, opt_str, value, parser):
 899     sys.stdout.write(
 900         '%s version %s\n' % (self.progname, VERSION)
 901         )
 902     sys.exit(0)
 903
 904   def callback_verbose(self, option, opt_str, value, parser):
 905     Log().increase_verbosity()
 906
 907   def callback_quiet(self, option, opt_str, value, parser):
 908     Log().decrease_verbosity()
 909
 910   def callback_passes(self, option, opt_str, value, parser):
 911     if value.find(':') >= 0:
 912       start_pass, end_pass = value.split(':')
 913       self.start_pass = self.pass_manager.get_pass_number(start_pass, 1)
 914       self.end_pass = self.pass_manager.get_pass_number(
 915           end_pass, self.pass_manager.num_passes
 916           )
 917     else:
 918       self.end_pass = \
 919           self.start_pass = \
 920           self.pass_manager.get_pass_number(value)
 921
 922   def callback_profile(self, option, opt_str, value, parser):
 923     self.profiling = True
 924
 925   def callback_symbol_hints(self, option, opt_str, value, parser):
 926     parser.values.symbol_strategy_rules.append(SymbolHintsFileRule(value))
 927
 928   def callback_force_branch(self, option, opt_str, value, parser):
 929     parser.values.symbol_strategy_rules.append(
 930         ForceBranchRegexpStrategyRule(value)
 931         )
 932
 933   def callback_force_tag(self, option, opt_str, value, parser):
 934     parser.values.symbol_strategy_rules.append(
 935         ForceTagRegexpStrategyRule(value)
 936         )
 937
 938   def callback_exclude(self, option, opt_str, value, parser):
 939     parser.values.symbol_strategy_rules.append(
 940         ExcludeRegexpStrategyRule(value)
 941         )
 942
 943   def callback_cvs_revnums(self, option, opt_str, value, parser):
 944     Ctx().revision_property_setters.append(CVSRevisionNumberSetter())
 945
 946   def callback_symbol_transform(self, option, opt_str, value, parser):
 947     [pattern, replacement] = value.split(":")
 948     try:
 949       parser.values.symbol_transforms.append(
 950           RegexpSymbolTransform(pattern, replacement)
 951           )
 952     except re.error:
 953       raise FatalError("'%s' is not a valid regexp." % (pattern,))
 954
 955   # Common to SVNRunOptions, HgRunOptions (GitRunOptions and
 956   # BzrRunOptions do not support --use-internal-co, so cannot use this).
 957   def process_all_extraction_options(self):
 958     ctx = Ctx()
 959     options = self.options
 960
 961     not_both(options.use_rcs, '--use-rcs',
 962              options.use_cvs, '--use-cvs')
 963
 964     not_both(options.use_rcs, '--use-rcs',
 965              options.use_internal_co, '--use-internal-co')
 966
 967     not_both(options.use_cvs, '--use-cvs',
 968              options.use_internal_co, '--use-internal-co')
 969
 970     if options.use_rcs:
 971       ctx.revision_collector = NullRevisionCollector()
 972       ctx.revision_reader = RCSRevisionReader(options.co_executable)
 973     elif options.use_cvs:
 974       ctx.revision_collector = NullRevisionCollector()
 975       ctx.revision_reader = CVSRevisionReader(options.cvs_executable)
 976     else:
 977       # --use-internal-co is the default:
 978       ctx.revision_collector = InternalRevisionCollector(compress=True)
 979       ctx.revision_reader = InternalRevisionReader(compress=True)
 980
 981   def process_symbol_strategy_options(self):
 982     """Process symbol strategy-related options."""
 983
 984     ctx = Ctx()
 985     options = self.options
 986
 987     # Add the standard symbol name cleanup rules:
 988     self.options.symbol_transforms.extend([
 989         ReplaceSubstringsSymbolTransform('\\','/'),
 990         # Remove leading, trailing, and repeated slashes:
 991         NormalizePathsSymbolTransform(),
 992         ])
 993
 994     if ctx.trunk_only:
 995       if options.symbol_strategy_rules or options.keep_trivial_imports:
 996         raise SymbolOptionsWithTrunkOnlyException()
 997
 998     else:
 999       if not options.keep_trivial_imports:
1000         options.symbol_strategy_rules.append(ExcludeTrivialImportBranchRule())
1001
1002       options.symbol_strategy_rules.append(UnambiguousUsageRule())
1003       if options.symbol_default == 'strict':
1004         pass
1005       elif options.symbol_default == 'branch':
1006         options.symbol_strategy_rules.append(AllBranchRule())
1007       elif options.symbol_default == 'tag':
1008         options.symbol_strategy_rules.append(AllTagRule())
1009       elif options.symbol_default == 'heuristic':
1010         options.symbol_strategy_rules.append(BranchIfCommitsRule())
1011         options.symbol_strategy_rules.append(HeuristicStrategyRule())
1012       elif options.symbol_default == 'exclude':
1013         options.symbol_strategy_rules.append(AllExcludedRule())
1014       else:
1015         assert False
1016
1017       # Now add a rule whose job it is to pick the preferred parents of
1018       # branches and tags:
1019       options.symbol_strategy_rules.append(HeuristicPreferredParentRule())
1020
1021   def process_property_setter_options(self):
1022     """Process the options that set SVN properties."""
1023
1024     ctx = Ctx()
1025     options = self.options
1026
1027     for value in options.auto_props_files:
1028       ctx.file_property_setters.append(
1029           AutoPropsPropertySetter(value, options.auto_props_ignore_case)
1030           )
1031
1032     for value in options.mime_types_files:
1033       ctx.file_property_setters.append(MimeMapper(value))
1034
1035     ctx.file_property_setters.append(CVSBinaryFileEOLStyleSetter())
1036
1037     ctx.file_property_setters.append(CVSBinaryFileDefaultMimeTypeSetter())
1038
1039     if options.eol_from_mime_type:
1040       ctx.file_property_setters.append(EOLStyleFromMimeTypeSetter())
1041
1042     ctx.file_property_setters.append(
1043         DefaultEOLStyleSetter(options.default_eol)
1044         )
1045
1046     ctx.file_property_setters.append(SVNBinaryFileKeywordsPropertySetter())
1047
1048     if not options.keywords_off:
1049       ctx.file_property_setters.append(
1050         KeywordsPropertySetter(config.SVN_KEYWORDS_VALUE)
1051         )
1052
1053     ctx.file_property_setters.append(ExecutablePropertySetter())
1054
1055     ctx.file_property_setters.append(DescriptionPropertySetter())
1056
1057   def process_options(self):
1058     """Do the main configuration based on command-line options.
1059
1060     This method is only called if the --options option was not
1061     specified."""
1062
1063     raise NotImplementedError()
1064
1065   def check_options(self):
1066     """Check the the run options are OK.
1067
1068     This should only be called after all options have been processed."""
1069
1070     # Convenience var, so we don't have to keep instantiating this Borg.
1071     ctx = Ctx()
1072
1073     if not self.start_pass <= self.end_pass:
1074       raise InvalidPassError(
1075           'Ending pass must not come before starting pass.')
1076
1077     if not ctx.dry_run and ctx.output_option is None:
1078       raise FatalError('No output option specified.')
1079
1080     if ctx.output_option is not None:
1081       ctx.output_option.check()
1082
1083     if not self.projects:
1084       raise FatalError('No project specified.')
1085
1086   def verify_option_compatibility(self):
1087     """Verify that no options incompatible with --options were used.
1088
1089     The --options option was specified.  Verify that no incompatible
1090     options or arguments were specified."""
1091
1092     if self.options.options_incompatible_options or self.args:
1093       if self.options.options_incompatible_options:
1094         oio = self.options.options_incompatible_options
1095         Log().error(
1096             '%s: The following options cannot be used in combination with '
1097             'the --options\n'
1098             'option:\n'
1099             '    %s\n'
1100             % (error_prefix, '\n    '.join(oio))
1101             )
1102       if self.args:
1103         Log().error(
1104             '%s: No cvs-repos-path arguments are allowed with the --options '
1105             'option.\n'
1106             % (error_prefix,)
1107             )
1108       sys.exit(1)
1109
1110   def process_options_file(self, options_filename):
1111     """Read options from the file named OPTIONS_FILENAME.
1112
1113     Store the run options to SELF."""
1114
1115     g = {
1116       'ctx' : Ctx(),
1117       'run_options' : self,
1118       }
1119     execfile(options_filename, g)
1120
1121   def usage(self):
1122     self.parser.print_help()
1123
1124