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