upstream/mercurial-mirror Commit - r5760:0145f9af

Removed tabs and trailing whitespace in python files

Thomas Arendsen Hein -

r5760:0145f9af default

parent child

hgext/convert/__init__.py

0 +1 -1

                   exclude path/to/file
                   rename from/file to/file
                 The 'include' directive causes a file, or all files under a
                 directory, to be included in the destination repository, and the
                 exclusion of all other files and dirs not explicitely included.

hgext/convert/common.py

0 +3 -3

                 def getchangedfiles(self, rev, i):
                     """Return the files changed by rev compared to parent[i].
                     i is an index selecting one of the parents of rev.  The return
                     value should be the list of files that are different in rev and
                     this parent.
                     If rev has no parents, i is None.
                     This function is only needed to support --filemap
                     """
                     raise NotImplementedError()
                             self.order.append(key)
                         super(mapfile, self).__setitem__(key, value)
                     fp.close()
                 def __setitem__(self, key, value):
                     if self.fp is None:
                         try:

hgext/convert/subversion.py

0 +4 -4

                             self.heads.append(brev)
                         if oldmodule:
                             self.tags = '%s/%s' % (oldmodule, tags)
                         else:
                             self.tags = '/%s' % tags
                 def join(self, name):
                     return os.path.join(self.wc, '.svn', name)
                 def revmapfile(self):
                     return self.join('hg-shamap')
                             if not path.startswith('/'):
                                 path = '/' + path
                             path = 'file://' + path
                         ui.status(_('initializing svn wc %r\n') % os.path.basename(wcpath))
                         self.run0('checkout', path, wcpath)
                     if files:
                         self.run('add', quiet=True, *files)
                     return files
                 def tidy_dirs(self, names):
                     dirs = list(self.dirs_of(names))
                     dirs.sort(reverse=True)

hgext/hgk.py

0 +3 -3

             # querying of information, and an extension to mercurial named hgk.py,
             # which provides hooks for hgk to get information. hgk can be found in
             # the contrib directory, and hgk.py can be found in the hgext
             # directory.
             #
             # To load the hgext.py extension, add it to your .hgrc file (you have
             # to use your global $HOME/.hgrc file, not one in a repository). You
             def config(ui, repo, **opts):
                 """print extension options"""
                 def writeopt(name, value):
                     ui.write('k=%s\nv=%s\n' % (name, value))
                 writeopt('vdiff', ui.config('hgk', 'vdiff', ''))
             def view(ui, repo, *etc, **opts):
                 "start interactive history viewer"

mercurial/cmdutil.py

0 +2 -2

                     def showcopies(**args):
                         c = [{'name': x[0], 'source': x[1]} for x in copies]
                         return showlist('file_copy', c, plural='file_copies', **args)
                     files = []
                     def getfiles():
                         if not files:
                             files[:] = self.repo.status(
                                 log.parents(changenode)[0], changenode)[:3]
                         return files

mercurial/commands.py

0 +2 -2

                         ui.write(_(" (Current patch tool may be incompatible with patch,"
                                    " or misconfigured. Please check your .hgrc file)\n"))
                     else:
                         ui.write(_(" Internal patcher failure, please report this error"
                                    " to http://www.selenic.com/mercurial/bts\n"))
                 problems += patchproblems
                 The manifest is the list of files being version controlled. If no revision
                 is given then the first parent of the working directory is used.
                 With -v flag, print file permissions, symlink and executable bits. With
                 --debug flag, print file revision hashes.
                 """

mercurial/context.py

0 +1 -1

                             return self._manifest.flags(path)
                         except KeyError:
                             return ''
                     pnode = self._parents[0].changeset()[0]
                     orig = self._repo.dirstate.copies().get(path, path)
                     node, flag = self._repo.manifest.find(pnode, orig)

mercurial/hgweb/common.py

0 +1 -1

                 from BaseHTTPServer import BaseHTTPRequestHandler
                 responses = BaseHTTPRequestHandler.responses
                 return responses.get(code, ('Error', 'Unknown error'))[0]
             def statusmessage(code):
                 return '%d %s' % (code, _statusmessage(code))

mercurial/hgweb/hgwebdir_mod.py

0 +3 -3

                         try:
                             virtual = req.env.get("PATH_INFO", "").strip('/')
                             # a static file
                             if virtual.startswith('static/') or 'static' in req.form:
                                 static = os.path.join(templater.templatepath(), 'static')
                             # prefixes not found
                             tmpl = self.templater(req)
                             req.respond(404, tmpl("notfound", repo=virtual))
                         except ErrorResponse, err:
                             tmpl = self.templater(req)
                             req.respond(err.code, tmpl('error', error=err.message or ''))
                             parts = [req.env['PATH_INFO'], name]
                             if req.env['SCRIPT_NAME']:
-                            	parts.insert(0, req.env['SCRIPT_NAME'])
+                                parts.insert(0, req.env['SCRIPT_NAME'])
                             url = ('/'.join(parts).replace("//", "/")) + '/'
                             # update time with local timezone

mercurial/hgweb/request.py

0 +5 -5

                             except socket.error, inst:
                                 if inst[0] != errno.ECONNRESET:
                                     raise
                 def write(self, *things):
                     self.respond('200 Script output follows', *things)
                     self.header(headers)
             def wsgiapplication(app_maker):
-            	application = app_maker()
+                application = app_maker()
-            	def run_wsgi(env, respond):
+                def run_wsgi(env, respond):
-            		application(env, respond)
+                    application(env, respond)
-            	return run_wsgi
+                return run_wsgi

mercurial/localrepo.py

0 +1 -1

                     '''
                     self.tags()
                     return self._tagstypecache.get(tagname)
                 def _hgtagsnodes(self):

mercurial/patch.py

0 +3 -3

                         fname = (afile in bfile) and afile or bfile
                     elif gooda:
                         fname = afile
                 if not fname:
                     if not nullb:
                         fname = (afile in bfile) and afile or bfile
                         fname = afile
                     else:
                         raise PatchError(_("undefined source and destination files"))
                 return fname, missing
             class linereader:
                         for gp in gitpatches:
                             if gp.op in ('COPY', 'RENAME'):
                                 copyfile(gp.oldpath, gp.path)
                             changed[gp.path] = (gp.op, gp)
                     else:
                         raise util.Abort(_('unsupported parser state: %s') % state)

mercurial/util.py

0 +1 -1

             def hidepassword(url):
                 '''replaces the password in the url string by three asterisks (***)
                 >>> hidepassword('http://www.example.com/some/path#fragment')
                 'http://www.example.com/some/path#fragment'
                 >>> hidepassword('http://me@www.example.com/some/path#fragment')

tests/coverage.py

0 +53 -53

                     self.excluded = excluded
                     self.suite_spots = suite_spots
                     self.excluding_suite = 0
                 def doRecursive(self, node):
                     for n in node.getChildNodes():
                         self.dispatch(n)
                 visitStmt = visitModule = doRecursive
                 def doCode(self, node):
                     if hasattr(node, 'decorators') and node.decorators:
                         self.dispatch(node.decorators)
                         self.recordAndDispatch(node.code)
                     else:
                         self.doSuite(node, node.code)
                 visitFunction = visitClass = doCode
                 def getFirstLine(self, node):
                     for n in node.getChildNodes():
                         lineno = max(lineno, self.getLastLine(n))
                     return lineno
                 def doStatement(self, node):
                     self.recordLine(self.getFirstLine(node))
                 visitAssert = visitAssign = visitAssTuple = visitPrint = \
                     visitPrintnl = visitRaise = visitSubscript = visitDecorators = \
                     doStatement
                 def visitPass(self, node):
                     # Pass statements have weird interactions with docstrings.  If this
                     # pass statement is part of one of those pairs, claim that the statement
                     if l:
                         lines = self.suite_spots.get(l, [l,l])
                         self.statements[lines[1]] = 1
                 def visitDiscard(self, node):
                     # Discard nodes are statements that execute an expression, but then
                     # discard the results.  This includes function calls, so we can't
                     # ignore them all.  But if the expression is a constant, the statement
                     # won't be "executed", so don't count it now.
                     if node.expr.__class__.__name__ != 'Const':
                         return self.recordLine(self.getFirstLine(node))
                     else:
                         return 0
                 def recordLine(self, lineno):
                     # Returns a bool, whether the line is included or excluded.
                     if lineno:
                             self.statements[lineno] = 1
                             return 1
                     return 0
                 default = recordNodeLine
                 def recordAndDispatch(self, node):
                     self.recordNodeLine(node)
                     self.dispatch(node)
                         self.excluding_suite = 1
                     self.recordAndDispatch(body)
                     self.excluding_suite = exsuite
                 def doPlainWordSuite(self, prevsuite, suite):
                     # Finding the exclude lines for else's is tricky, because they aren't
                     # present in the compiler parse tree.  Look at the previous suite,
                             break
                     else:
                         self.doSuite(None, suite)
                 def doElse(self, prevsuite, node):
                     if node.else_:
                         self.doPlainWordSuite(prevsuite, node.else_)
                 def visitFor(self, node):
                     self.doSuite(node, node.body)
                     self.doElse(node.body, node)
                         else:
                             self.doSuite(a, h)
                     self.doElse(node.handlers[-1][2], node)
                 def visitTryFinally(self, node):
                     self.doSuite(node, node.body)
                     self.doPlainWordSuite(node.body, node.final)
                 def visitWith(self, node):
                     self.doSuite(node, node.body)
                 def visitGlobal(self, node):
                     # "global" statements don't execute like others (they don't call the
                     # trace function), so don't record their line numbers.
                 # A dictionary with an entry for (Python source file name, line number
                 # in that file) if that line has been executed.
                 c = {}
                 # A map from canonical Python source file name to a dictionary in
                 # which there's an entry for each line number that has been
                 # executed.
                     self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.sep)
                     self.exclude('# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]')
                 # t(f, x, y).  This method is passed to sys.settrace as a trace function.
                 # See [van Rossum 2001-07-20b, 9.2] for an explanation of sys.settrace and
                 # the arguments and return value of the trace function.
                 # See [van Rossum 2001-07-20a, 3.2] for a description of frame and code
                 # objects.
                 def t(self, f, w, unused):                                   #pragma: no cover
                     if w == 'line':
                         #print "Executing %s @ %d" % (f.f_code.co_filename, f.f_lineno)
                         for c in self.cstack:
                             c[(f.f_code.co_filename, f.f_lineno)] = 1
                     return self.t
                 def help(self, error=None):     #pragma: no cover
                     if error:
                         print error
                     args_needed = (settings.get('execute')
                                    or settings.get('annotate')
                                    or settings.get('report'))
                     action = (settings.get('erase')
                               or settings.get('collect')
                               or args_needed)
                     if not action:
                         help_fn("You must specify at least one of -e, -x, -c, -r, or -a.")
                     if not args_needed and args:
                         help_fn("Unexpected arguments: %s" % " ".join(args))
                     self.parallel_mode = settings.get('parallel-mode')
                     self.get_ready()
                         self.collect()
                     if not args:
                         args = self.cexecuted.keys()
                     ignore_errors = settings.get('ignore-errors')
                     show_missing = settings.get('show-missing')
                     directory = settings.get('directory=')
                     self.usecache = usecache
                     if cache_file and not self.cache:
                         self.cache_default = cache_file
                 def get_ready(self, parallel_mode=False):
                     if self.usecache and not self.cache:
                         self.cache = os.environ.get(self.cache_env, self.cache_default)
                             self.cache += "." + gethostname() + "." + str(os.getpid())
                         self.restore()
                     self.analysis_cache = {}
                 def start(self, parallel_mode=False):
                     self.get_ready()
                     if self.nesting == 0:                               #pragma: no cover
                         if hasattr(threading, 'settrace'):
                             threading.settrace(self.t)
                     self.nesting += 1
                 def stop(self):
                     self.nesting -= 1
                     if self.nesting == 0:                               #pragma: no cover
                 def begin_recursive(self):
                     self.cstack.append(self.c)
                     self.xstack.append(self.exclude_re)
                 def end_recursive(self):
                     self.c = self.cstack.pop()
                     self.exclude_re = self.xstack.pop()
                         self.canonical_filename_cache[filename] = cf
                     return self.canonical_filename_cache[filename]
                 # canonicalize_filenames().  Copy results from "c" to "cexecuted",
                 # canonicalizing filenames on the way.  Clear the "c" map.
                 def canonicalize_filenames(self):
                 # in the source code, (3) a list of lines of excluded statements,
                 # and (4), a map of line numbers to multi-line line number ranges, for
                 # statements that cross lines.
                 def analyze_morf(self, morf):
                     if self.analysis_cache.has_key(morf):
                         return self.analysis_cache[morf]
                         if len(tree) == 3 and type(tree[2]) == type(1):
                             return tree[2]
                         tree = tree[1]
                 def last_line_of_tree(self, tree):
                     while True:
                         if len(tree) == 3 and type(tree[2]) == type(1):
                             return tree[2]
                         tree = tree[-1]
                 def find_docstring_pass_pair(self, tree, spots):
                     for i in range(1, len(tree)):
                         if self.is_string_constant(tree[i]) and self.is_pass_stmt(tree[i+1]):
                             first_line = self.first_line_of_tree(tree[i])
                             last_line = self.last_line_of_tree(tree[i+1])
                             self.record_multiline(spots, first_line, last_line)
                 def is_string_constant(self, tree):
                     try:
                         return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.expr_stmt
                     except:
                         return False
                 def is_pass_stmt(self, tree):
                     try:
                         return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.pass_stmt
                 def record_multiline(self, spots, i, j):
                     for l in range(i, j+1):
                         spots[l] = (i, j)
                 def get_suite_spots(self, tree, spots):
                     """ Analyze a parse tree to find suite introducers which span a number
                         of lines.
                                 # treat them differently, especially in the common case of a
                                 # function with a doc string and a single pass statement.
                                 self.find_docstring_pass_pair(tree[i], spots)
                             elif tree[i][0] == symbol.simple_stmt:
                                 first_line = self.first_line_of_tree(tree[i])
                                 last_line = self.last_line_of_tree(tree[i])
                     tree = parser.suite(text+'\n\n').totuple(1)
                     self.get_suite_spots(tree, suite_spots)
                     #print "Suite spots:", suite_spots
                     # Use the compiler module to parse the text and find the executable
                     # statements.  We add newlines to be impervious to final partial lines.
                     statements = {}
                         else:
                             globbed.append(morf)
                     morfs = globbed
                     morfs = self.filter_by_prefix(morfs, omit_prefixes)
                     morfs.sort(self.morf_name_compare)
                         except:
                             if not ignore_errors:
                                 raise
                 def annotate_file(self, filename, statements, excluded, missing, directory=None):
                     source = open(filename, 'r')
                     if directory:
                         if self.blank_re.match(line):
                             dest.write('  ')
                         elif self.else_re.match(line):
                             # Special logic for lines containing only 'else:'.
                             # See [GDR 2001-12-04b, 3.2].
                             if i >= len(statements) and j >= len(missing):
                                 dest.write('! ')
             the_coverage = coverage()
             # Module functions call methods in the singleton object.
             def use_cache(*args, **kw):
                 return the_coverage.use_cache(*args, **kw)
             def start(*args, **kw):
                 return the_coverage.start(*args, **kw)
             def stop(*args, **kw):
                 return the_coverage.stop(*args, **kw)
             def erase(*args, **kw):
                 return the_coverage.erase(*args, **kw)
             def begin_recursive(*args, **kw):
                 return the_coverage.begin_recursive(*args, **kw)
             def end_recursive(*args, **kw):
                 return the_coverage.end_recursive(*args, **kw)
             def exclude(*args, **kw):
                 return the_coverage.exclude(*args, **kw)
             def analysis(*args, **kw):
                 return the_coverage.analysis(*args, **kw)
             def analysis2(*args, **kw):
                 return the_coverage.analysis2(*args, **kw)
             def report(*args, **kw):
                 return the_coverage.report(*args, **kw)
             def annotate(*args, **kw):
                 return the_coverage.annotate(*args, **kw)
             def annotate_file(*args, **kw):
                 return the_coverage.annotate_file(*args, **kw)
             # Save coverage data when Python exits.  (The atexit module wasn't
             # Thanks, Allen.
             #
             # 2005-12-02 NMB Call threading.settrace so that all threads are measured.
             # Thanks Martin Fuzzey. Add a file argument to report so that reports can be
             # captured to a different destination.
             #
             # 2005-12-03 NMB coverage.py can now measure itself.

tests/run-tests.py

0 +1 -1

                         fp = os.fdopen(options.child, 'w')
                         fp.write('%d\n%d\n%d\n' % (tested, skipped, failed))
                         for s in skips:
                             fp.write("%s %s\n" % s)
                         fp.close()
                     else:
                         print

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages