Coverage for cogapp\cogapp : 51%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
""" Cog code generation tool. http://nedbatchelder.com/code/cog
Copyright 2004-2009, Ned Batchelder. """
# The recommended way to compute md5's changed in Python 2.5 except ImportError: import md5 hash_factory = md5.new
cog - generate code with inlined Python code.
cog [OPTIONS] [INFILE | @FILELIST] ...
INFILE is the name of an input file. FILELIST is the name of a text file containing file names or other @FILELISTs.
OPTIONS: -c Checksum the output to protect it against accidental change. -d Delete the generator code from the output file. -D name=val Define a global string available to your generator code. -e Warn if a file has no cog code in it. -I PATH Add PATH to the list of directories for data files and modules. -o OUTNAME Write the output to OUTNAME. -r Replace the input file with the output. -s STRING Suffix all generated output lines with STRING. -U Write the output with Unix newlines (only LF line-endings). -w CMD Use CMD if the output file needs to be made writable. A %s in the CMD will be filled with the filename. -x Excise all the generated output without running the generators. -z The [[[end]]] marker can be omitted, and is assumed at eof. -v Print the version of cog and exit. -h Print this help. """
# Other package modules
""" Any exception raised by Cog. """ else: Exception.__init__(self, msg)
""" An error in usage of command-line arguments in cog. """ pass #pragma: no cover
""" An error in the coding of Cog. Should never happen. """ pass #pragma: no cover
""" An error raised by a user's cog generator. """ pass #pragma: no cover
""" An object with its own stdout and stderr files. """
""" Assign new files for standard out and/or standard error. """ self.stderr = stderr
""" A generator pulled from a source file. """
""" Extract the executable Python code from the generator. """ # If the markers and lines all have the same prefix # (end-of-line comment chars, for example), # then remove it from all the lines.
# figure out the right whitespace prefix for the output
# In Python 2.2, the last line has to end in a newline.
# Make sure the "cog" module has our state.
# We need to make sure that the last line in the output # ends with a newline, or it will be joined to the # end-output line, ruining cog's idempotency.
print >>self.stdout, "Message: "+s
""" The cog.out function. """
""" The cog.outl function. """
""" The cog.error function. Instead of raising standard python errors, cog generators can use this function. It will display the error without a scary Python traceback. """ raise CogGeneratedError(msg)
""" A decorator for files that counts the readline()'s called. """
""" Options for a run of cog. """ # Defaults for argument values.
""" Comparison operator for tests to use. """ return self.__dict__.__cmp__(other.__dict__)
""" Make a clone of these options, for further refinement. """ return copy.deepcopy(self)
""" Add directories to the include path. """ dirs = dirs.split(os.pathsep) self.includePath.extend(dirs)
# Parse the command line arguments. try: opts, self.args = getopt.getopt(argv, 'cdD:eI:o:rs:Uvw:xz') except getopt.error, msg: raise CogUsageError(msg)
# Handle the command line arguments. for o, a in opts: if o == '-c': self.bHashOutput = True elif o == '-d': self.bDeleteCode = True elif o == '-D': if a.count('=') < 1: raise CogUsageError("-D takes a name=value argument") name, value = a.split('=', 1) self.defines[name] = value elif o == '-e': self.bWarnEmpty = True elif o == '-I': self.addToIncludePath(a) elif o == '-o': self.sOutputName = a elif o == '-r': self.bReplace = True elif o == '-s': self.sSuffix = a elif o == '-U': self.bNewlines = True elif o == '-v': self.bShowVersion = True elif o == '-w': self.sMakeWritableCmd = a elif o == '-x': self.bNoGenerate = True elif o == '-z': self.bEofCanBeEnd = True else: # Since getopt.getopt is given a list of possible flags, # this is an internal error. raise CogInternalError("Don't understand argument %s" % o)
""" Does nothing if everything is OK, raises CogError's if it's not. """ if self.bReplace and self.bDeleteCode: raise CogUsageError("Can't use -d with -r (or you would delete all your source!)")
if self.bReplace and self.sOutputName: raise CogUsageError("Can't use -o with -r (they are opposites)")
""" The Cog engine. """
print >>self.stdout, "Warning:", msg
not self.isEndOutputLine(s)
""" Magic mumbo-jumbo so that imported Python modules can say "import cog" and get our state. """
""" Process an input file object to an output file object. fIn and fOut can be file objects, or file names. """
# Convert filenames to files. # Open the input file. sFileIn = fIn fIn = fInToClose = open(fIn, 'r') # Open the output file. sFileOut = fOut fOut = fOutToClose = open(fOut, self.sOutputMode)
# The globals dict we'll use for this file.
# If there are any global defines, put them in the globals.
# loop over generator chunks # Find the next spec begin raise CogError("Unexpected '%s'" % self.sEndSpec, file=sFileIn, line=fIn.linenumber()) raise CogError("Unexpected '%s'" % self.sEndOutput, file=sFileIn, line=fIn.linenumber())
# l is the begin spec
# If the spec begin is also a spec end, then process the single # line of code inside. file=sFileIn, line=firstLineNum) else: else: # Deal with an ordinary code block.
# Get all the lines in the spec raise CogError("Unexpected '%s'" % self.sBeginSpec, file=sFileIn, line=fIn.linenumber()) raise CogError("Unexpected '%s'" % self.sEndOutput, file=sFileIn, line=fIn.linenumber()) raise CogError( "Cog block begun but never ended.", file=sFileIn, line=firstLineNum)
# Eat all the lines in the output section. While reading past # them, compute the md5 hash of the old output. raise CogError("Unexpected '%s'" % self.sBeginSpec, file=sFileIn, line=fIn.linenumber()) raise CogError("Unexpected '%s'" % self.sEndSpec, file=sFileIn, line=fIn.linenumber())
# We reached end of file before we found the end output line. raise CogError("Missing '%s' before end of file." % self.sEndOutput, file=sFileIn, line=fIn.linenumber())
# Write the output of the spec to be the new output if we're # supposed to generate code.
# Write the ending output line if hashMatch: oldHash = hashMatch.groupdict()['hash'] if oldHash != curHash: raise CogError("Output has been edited! Delete old checksum to unprotect.", file=sFileIn, line=fIn.linenumber()) # Create a new end line with the correct hash. endpieces = l.split(hashMatch.group(0), 1) else: # There was no old hash, but we want a new hash. endpieces = l.split(self.sEndOutput, 1) l = (self.sEndFormat % newHash).join(endpieces) else: # We don't want hashes output, so if there was one, get rid of # it. l = l.replace(hashMatch.groupdict()['hashsect'], '', 1)
self.showWarning("no cog code found in %s" % sFileIn) finally: fInToClose.close() fOutToClose.close()
# A regex for non-empty lines, used by suffixLines.
""" Add suffixes to the lines in text, if our options desire it. text is many lines, as a single string. """ # Find all non-blank lines, and add the suffix to the end. repl = r"\g<0>" + self.options.sSuffix.replace('\\', '\\\\') text = self.reNonEmptyLines.sub(repl, text)
""" Process sInput as the text to cog. Return the cogged output as a string. """
""" Replace file sOldPath with the contents sNewText """ if not os.access(sOldPath, os.W_OK): # Need to ensure we can write. if self.options.sMakeWritableCmd: # Use an external command to make the file writable. cmd = self.options.sMakeWritableCmd.replace('%s', sOldPath) self.stdout.write(os.popen(cmd).read()) if not os.access(sOldPath, os.W_OK): raise CogError("Couldn't make %s writable" % sOldPath) else: # Can't write! raise CogError("Can't overwrite %s" % sOldPath) f = open(sOldPath, self.sOutputMode) f.write(sNewText) f.close()
self.savedInclude = self.options.includePath[:] self.savedSysPath = sys.path[:]
self.options.includePath = self.savedInclude self.cogmodule.path = self.options.includePath sys.path = self.savedSysPath
self.cogmodule.path.extend(includePath) sys.path.extend(includePath)
""" Process one filename through cog. """
self.saveIncludePath()
try: self.addToIncludePath(self.options.includePath) # Since we know where the input file came from, # push its directory onto the include path. self.addToIncludePath([os.path.dirname(sFile)])
# Set the file output mode based on whether we want \n or native # line endings. self.sOutputMode = 'w' if self.options.bNewlines: self.sOutputMode = 'wb'
# How we process the file depends on where the output is going. if self.options.sOutputName: self.processFile(sFile, self.options.sOutputName, sFile) elif self.options.bReplace: # We want to replace the cog file with the output, # but only if they differ. print >>self.stdout, "Cogging %s" % sFile, bNeedNewline = True
try: fOldFile = open(sFile) sOldText = fOldFile.read() fOldFile.close() sNewText = self.processString(sOldText, fname=sFile) if sOldText != sNewText: print >>self.stdout, " (changed)" bNeedNewline = False self.replaceFile(sFile, sNewText) finally: # The try-finally block is so we can print a partial line # with the name of the file, and print (changed) on the # same line, but also make sure to break the line before # any traceback. if bNeedNewline: print >>self.stdout else: self.processFile(sFile, self.stdout, sFile) finally: self.restoreIncludePath()
""" Process the files in a file list. """ flist = open(sFileList) lines = flist.readlines() flist.close() for l in lines: # Use shlex to parse the line like a shell. lex = shlex.shlex(l, posix=True) lex.whitespace_split = True lex.commenters = '#' # No escapes, so that backslash can be part of the path lex.escape = '' args = list(lex) if args: self.processArguments(args)
""" Process one command-line. """ saved_options = self.options self.options = self.options.clone()
self.options.parseArgs(args[1:]) self.options.validate()
if args[0][0] == '@': if self.options.sOutputName: raise CogUsageError("Can't use -o with @file") self.processFileList(args[0][1:]) else: self.processOneFile(args[0])
self.options = saved_options
""" All of command-line cog, but in a callable form. This is used by main. argv is the equivalent of sys.argv. """ argv0 = argv.pop(0)
# Provide help if asked for anywhere in the command line. if '-?' in argv or '-h' in argv: print >>self.stderr, usage, return
self.options.parseArgs(argv) self.options.validate()
if self.options.bShowVersion: print >>self.stdout, "Cog version %s" % __version__ return
if self.options.args: for a in self.options.args: self.processArguments([a]) else: raise CogUsageError("No files to process")
""" Handle the command-line execution for cog. """
try: self.callableMain(argv) return 0 except CogUsageError, err: print >>self.stderr, err print >>self.stderr, "(for help use -?)" return 2 except CogGeneratedError, err: print >>self.stderr, "Error: %s" % err return 3 except CogError, err: print >>self.stderr, err return 1 except: traceback.print_exc(None, self.stderr) return 1
# History: # 20040210: First public version. # 20040220: Text preceding the start and end marker are removed from Python lines. # -v option on the command line shows the version. # 20040311: Make sure the last line of output is properly ended with a newline. # 20040605: Fixed some blank line handling in cog. # Fixed problems with assigning to xml elements in handyxml. # 20040621: Changed all line-ends to LF from CRLF. # 20041002: Refactor some option handling to simplify unittesting the options. # 20041118: cog.out and cog.outl have optional string arguments. # 20041119: File names weren't being properly passed around for warnings, etc. # 20041122: Added cog.firstLineNum: a property with the line number of the [[[cog line. # Added cog.inFile and cog.outFile: the names of the input and output file. # 20041218: Single-line cog generators, with start marker and end marker on # the same line. # 20041230: Keep a single globals dict for all the code fragments in a single # file so they can share state. # 20050206: Added the -x switch to remove all generated output. # 20050218: Now code can be on the marker lines as well. # 20050219: Added -c switch to checksum the output so that edits can be # detected before they are obliterated. # 20050521: Added cog.error, contributed by Alexander Belchenko. # 20050720: Added code deletion and settable globals contributed by Blake Winton. # 20050724: Many tweaks to improve code coverage. # 20050726: Error messages are now printed with no traceback. # Code can no longer appear on the marker lines, # except for single-line style. # -z allows omission of the [[[end]]] marker, and it will be assumed # at the end of the file. # 20050729: Refactor option parsing into a separate class, in preparation for # future features. # 20050805: The cogmodule.path wasn't being properly maintained. # 20050808: Added the -D option to define a global value. # 20050810: The %s in the -w command is dealt with more robustly. # Added the -s option to suffix output lines with a marker. # 20050817: Now @files can have arguments on each line to change the cog's # behavior for that line. # 20051006: Version 2.0 # 20080521: -U options lets you create Unix newlines on Windows. Thanks, # Alexander Belchenko. # 20080522: It's now ok to have -d with output to stdout, and now we validate # the args after each line of an @file. # 20090520: Use hashlib where it's available, to avoid a warning. # Use the builtin compile() instead of compiler, for Jython. # Explicitly close files we opened, Jython likes this. |