19 Default values for trunk/scripts flags can be specified in valid Python syntax

    20 in the ~/.soc_scripts_settings file.  For example, a default value for the

    21 --user flag can be specified with a variable assignment in the settings file

    22 like:

    23 

    24   user = 'joeuser'

    25 

    26 Defaults in the ~/.soc_scripts_settings file can be explicitly overridden by

    27 supplied the actual flag.  For example, supplying:

    28 

    29   --user=someotheruser

    30 

    31 would override the default value present in the settings file.

    32 

   126 

   127 

   128 def printErrors(errors, exit_code=1):

   129   """Prints error message strings to sys.stderr and returns an exit code.

   130 

   131   Args:

   132     errors: error message string or list of error message strings to be printed

   133       to sys.stderr

   134     exit_code: exit code to return (so that this function can be used as an

   135       expression in sys.exit() for example); default is 1

   136 

   137   Returns:

   138     exit_code

   139   """

   140   sys.stderr.write('\nERRORS:\n')

   141 

   142   if (not isinstance(errors, tuple)) and (not isinstance(errors, list)):

   143     errors = [errors]

   144 

   145   for msg in errors:

   146     sys.stderr.write('  %s\n' % msg)

   147 

   148   sys.stderr.write('\n')

   149 

   150   return exit_code

   151 

   152 

   153 def printErrorsAndUsage(errors, parser, exit_code=1):

   154   """Prints error messages and usage text to sys.stderr and returns exit code.

   155 

   156   Args:

   157     errors: error message string or list of error message strings to be printed

   158       to sys.stderr

   159     parser: OptionParser with a print_help() method

   160     exit_code: exit code to return (so that this function can be used as an

   161       expression in sys.exit() for example); default is 1

   162 

   163   Returns:

   164     exit_code

   165   """

   166   exit_code = printErrors(errors, exit_code=exit_code)

   167   parser.print_help(file=sys.stderr)

   168 

   169   return exit_code

   170 

   171 

   172 def getExpandedPath(path):

   173   """Returns an expanded, normalized, absolute path.

   174 

   175   Args:

   176     path: path (possibly relative, possibly containing environment variables,

   177       etc.) to be expanded, normalized and made absolute

   178 

   179   Returns:

   180     absolute path, after expanding any environment variables and "~", then

   181     removing excess . and .. path elements

   182   """

   183   return os.path.abspath(

   184       os.path.normpath(

   185           os.path.expanduser(

   186               os.path.expandvars(path))))

   237 

   238 

   239 def readPythonSettingsOrDie(parser=None,

   240                             defaults={},  # {} OK since defaults is always copied

   241                             settings_dir=DEF_SETTINGS_FILE_DIR,

   242                             settings_file=DEF_SETTINGS_FILE_NAME):

   243   """Calls readPythonSettings(), calling sys.exit() on any errors.

   244 

   245   Args:

   246     parser: if supplied, an OptionParser instance used to call print_help()

   247       to print usage information if errors occur

   248     defaults, settings_dir, settings_file: see readPythonSettings()

   249 

   250   Returns:

   251     On success, returns results of readPythonSettings().

   252 

   253   Exits:

   254     On any error from readPythonSettings(), prints error messages to stderr,

   255     possibly prints usage information, and calls sys.exit(1).

   256   """

   257   try:

   258     return readPythonSettings(defaults=defaults, settings_dir=settings_dir,

   259                               settings_file=settings_file)

   260   except Error, error:

   261     if parser:

   262       sys.exit(printErrorsAndUsage(error.args, parser))

   263     else:

   264       sys.exit(printErrors(error.args))

   265 

   266 

   267 def makeOptionParserOrDie(*args, **kwargs):

   268   """Creates and returns an OptionParser, calling sys.exit() on any errors.

   269 

   270   Args:

   271     *args, **kwargs: supplied directly to OptionParser constructor

   272 

   273   Returns:

   274     On success, returns an OptionParser instance.

   275 

   276   Exits:

   277     On any error, prints error messages to stderr and calls sys.exit(1).

   278   """

   279   try:

   280     return OptionParser(*args, **kwargs)

   281   except Error, error:

   282     sys.exit(printErrors(error.args))

   283 

   284 

   285 def parseOptionsOrDie(parser, args):

   286   """Parses command-line options, calling sys.exit() on any errors.

   287 

   288   Args:

   289     parser: an OptionParser instance

   290     args: list of command-line arguments to supply to parser

   291 

   292   Returns:

   293     On success, returns (options, args) returned by parser.parse_args(args).

   294 

   295   Exits:

   296     On any error, prints error messages and usage information to stderr and

   297     calls sys.exit(1).

   298   """

   299   try:

   300     return parser.parse_args(args)

   301   except Error, error:

   302     sys.exit(printErrorsAndUsage(error.args, parser))

   303 

   304 

   305 def checkCommonSvnOptions(options):

   306   """Checks a common subset of command-line options.

   307 

   308   Multiple scripts accept a subset of common command-line options.

   309 

   310   Args:

   311     options: OptionParser.parse_args() options instance to check

   312 

   313   Returns:

   314     list of error message strings, or an empty list if no errors

   315   """

   316   errors = []

   317 

   318   if not options.repo:

   319     errors.extend(

   320         ['--repo must be supplied or have a settings file default'])

   321 

   322   if not options.wc:

   323     errors.extend(

   324         ['--wc must be supplied or have a settings file default'])

   325 

   326   if not options.branch:

   327     if not options.user:

   328       errors.extend(

   329           ['at least one of --branch or --user must be supplied'])

   330 

   331   return errors

   332 

   333 

   334 def checkCommonSvnOptionsOrDie(options, parser):

   335   """Checks subset of command-line options, calling sys.exit() on any errors.

   336 

   337   Args:

   338     options: see checkCommonSvnOptions()

   339     parser: an OptionParser instance used to call print_help() to print

   340       usage information if errors occur

   341 

   342   Exits:

   343     On any error messages returned by checkCommonSvnOptions(), prints error

   344     messages and usage information to stderr and calls sys.exit(1).

   345   """

   346   errors = checkCommonSvnOptions(options)

   347 

   348   if errors:

   349     sys.exit(printErrorsAndUsage(errors, parser))