rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
order = req.args.get('order', 'name').lower() req.hdf['browser.order'] = order desc = req.args.has_key('desc') req.hdf['browser.desc'] = desc and 1 or 0 | def _render_directory(self, req, repos, node, rev=None): req.perm.assert_permission('BROWSER_VIEW') | |
req.hdf['browser.items'] = info req.hdf['browser.changes'] = changes | switch_ordering_hrefs = {} for col in ('name', 'size', 'date'): switch_ordering_hrefs[col] = req.href.browser( node.path, rev=rev, order=col, desc=(col == order and not desc and 1 or None)) | def browse_order(a): return a['is_dir'] and dir_order or 0, file_order(a) |
return "%s <%s>" % (name, email) | return "\"%s\" <%s>" % (name, email) | def format_header(self, name, email=None): from email.Header import Header try: tmp = unicode(name, 'ascii') name = Header(tmp, 'ascii', maxlinelen=self.maxheaderlen) except UnicodeDecodeError: name = Header(name, self._charset, maxlinelen=self.maxheaderlen) if not email: return name else: return "%s <%s>" % (name, ema... |
print "hej" | def _create_file(fname, data=None): fd = open(fname, 'w') if data: fd.write(data) fd.close() | |
def _get_changes(env, db, repos, revs, full=None, req=None): | def _get_changes(env, db, repos, revs, full=None, req=None, raw=False): | def _get_changes(env, db, repos, revs, full=None, req=None): changes = {} for rev in filter(lambda x: x in revs, revs): changeset = repos.get_changeset(rev) if changeset.message: message = util.wiki_escape_newline(changeset.message) # FIXME (#48) if not full: message = util.shorten_line(message) message = wiki_to_oneli... |
if changeset.message: | message = changeset.message if raw: files = [c[0] for c in changeset.get_changes()] elif message: | def _get_changes(env, db, repos, revs, full=None, req=None): changes = {} for rev in filter(lambda x: x in revs, revs): changeset = repos.get_changeset(rev) if changeset.message: message = util.wiki_escape_newline(changeset.message) # FIXME (#48) if not full: message = util.shorten_line(message) message = wiki_to_oneli... |
else: | if not message: | def _get_changes(env, db, repos, revs, full=None, req=None): changes = {} for rev in filter(lambda x: x in revs, revs): changeset = repos.get_changeset(rev) if changeset.message: message = util.wiki_escape_newline(changeset.message) # FIXME (#48) if not full: message = util.shorten_line(message) message = wiki_to_oneli... |
'message': message | 'message': message, 'files': files, | def _get_changes(env, db, repos, revs, full=None, req=None): changes = {} for rev in filter(lambda x: x in revs, revs): changeset = repos.get_changeset(rev) if changeset.message: message = util.wiki_escape_newline(changeset.message) # FIXME (#48) if not full: message = util.shorten_line(message) message = wiki_to_oneli... |
req.hdf['log.log_path_history_href'] = self.env.href.log(path, rev=rev, log_mode='path_history') | def render(self, req): self.perm.assert_permission(perm.LOG_VIEW) | |
def add_page_link(what, page): args = { | def make_log_href(**args): args.update({ | def add_page_link(what, page): args = { 'rev': rev, 'log_mode': log_mode, 'limit': limit, 'page': page, 'pages': urllib.quote_plus(' '.join(pages)), } if full_messages: args['full_messages'] = full_messages add_link(req, what, self.env.href.log(path, **args), 'Revision Log (Page %d)' % (page)) |
'page': page, 'pages': urllib.quote_plus(' '.join(pages)), } | }) | def add_page_link(what, page): args = { 'rev': rev, 'log_mode': log_mode, 'limit': limit, 'page': page, 'pages': urllib.quote_plus(' '.join(pages)), } if full_messages: args['full_messages'] = full_messages add_link(req, what, self.env.href.log(path, **args), 'Revision Log (Page %d)' % (page)) |
add_link(req, what, self.env.href.log(path, **args), | return self.env.href.log(path, **args) def add_page_link(what, page): add_link(req, what, make_log_href(page=page, pages=urllib.quote_plus(' '.join(pages))), | def add_page_link(what, page): args = { 'rev': rev, 'log_mode': log_mode, 'limit': limit, 'page': page, 'pages': urllib.quote_plus(' '.join(pages)), } if full_messages: args['full_messages'] = full_messages add_link(req, what, self.env.href.log(path, **args), 'Revision Log (Page %d)' % (page)) |
req.hdf['log.changes'] = _get_changes(self.env, self.db, repos, [i['rev'] for i in info], full_messages, req) rss_href = self.env.href.log(path, rev=rev, format='rss') add_link(req, 'alternate', rss_href, 'RSS Feed', 'application/rss+xml', 'rss') if req.args.get('format') == 'rss': | changes = _get_changes(self.env, self.db, repos, [i['rev'] for i in info], full_messages, req, format == 'changelog') if format == 'rss': for cs in changes.values(): cs['message'] = util.escape(cs['message']) elif format == 'changelog': for cs in changes.values(): cs['message'] = '\n'.join(['\t' + m for m in cs['messag... | def add_page_link(what, page): args = { 'rev': rev, 'log_mode': log_mode, 'limit': limit, 'page': page, 'pages': urllib.quote_plus(' '.join(pages)), } if full_messages: args['full_messages'] = full_messages add_link(req, what, self.env.href.log(path, **args), 'Revision Log (Page %d)' % (page)) |
env.log.debug('Loading plugin %s from %s', name, egg.location) | env.log.debug('Loading plugin %s', egg.location) | def flatten(dists): for dist in dists: if dist in memo: continue memo.add(dist) try: predecessors = ws.resolve([dist.as_requirement()]) for predecessor in flatten(predecessors): yield predecessor yield dist except pkg_resources.DistributionNotFound, e: env.log.error('Skipping "%s" ("%s" not found)', dist, e) except pkg... |
sorter = ColumnSorter(colIndex, int(asc)) req.hdf[k] = asc | asc = int(asc) | def _render_view(self, req, db, id): """ uses a user specified sql query to extract some information from the database and presents it as a html table. """ actions = {'create': 'REPORT_CREATE', 'delete': 'REPORT_DELETE', 'modify': 'REPORT_MODIFY'} for action in [k for k,v in actions.items() if req.perm.has_permission(v... |
sorter = ColumnSorter(colIndex) req.hdf[k] = 1 rows.sort(sorter.sort) | asc = 1 req.hdf[k] = asc def sortkey(row): val = row[colIndex] if isinstance(val, basestring): val = val.lower() return val rows = sorted(rows, key=sortkey, reverse=(not asc)) | def _render_view(self, req, db, id): """ uses a user specified sql query to extract some information from the database and presents it as a html table. """ actions = {'create': 'REPORT_CREATE', 'delete': 'REPORT_DELETE', 'modify': 'REPORT_MODIFY'} for action in [k for k,v in actions.items() if req.perm.has_permission(v... |
return '<div class="system-message">Macro %s(%s) failed: %s</span' \ | return '<div class="system-message">Macro %s(%s) failed: %s</div>' \ | def _macro_formatter(self, match, fullmatch): name = fullmatch.group('macroname') if name in ['br', 'BR']: return '<br />' args = fullmatch.group('macroargs') try: macro = self.load_macro(name) return macro(self.hdf, args, self.env) except Exception, e: return '<div class="system-message">Macro %s(%s) failed: %s</span'... |
else: author_email = '' for username,name,email in self.env.get_known_users(): if email and username == author: author_email = email | elif author in email_map.keys(): author_email = email_map[author] | def make_log_href(path, **args): link_rev = rev if rev == str(repos.youngest_rev): link_rev = None params = {'rev': link_rev, 'mode': mode, 'limit': limit} params.update(args) if verbose: params['verbose'] = verbose return self.env.href.log(path, **params) |
self.failIf(int(mo.group('dm')) not in range(1,31)) | self.failIf(int(mo.group('dm')) not in range(1,32)) | def test_date(self): """ Validate date format Date format hould be compliant with RFC822, we do not support 'military' format """ date_str = r"^((?P<day>\w{3}),\s*)*(?P<dm>\d{2})\s+" \ r"(?P<month>\w{3})\s+(?P<year>200\d)\s+" \ r"(?P<hour>\d{2}):(?P<min>[0-5][0-9])" \ r"(:(?P<sec>[0-5][0-9]))*\s" \ r"((?P<tz>\w{2,3})|(... |
cursor.execute("UPDATE ticket SET %s=%s WHERE id=%s", (fname, self[name], id)) | cursor.execute("UPDATE ticket SET %s=%%s WHERE id=%%s" % fname, (self[name], id)) | def save_changes(self, db, author, comment, when = 0): """Store ticket changes in the database. The ticket must already exist in the database.""" assert self.has_key('id') cursor = db.cursor() if not when: when = int(time.time()) id = self['id'] |
self.parser.read(self.filename) | self.parser.readfp(open(self.filename)) | def parse_if_needed(self): if not self.filename: return modtime = os.path.getmtime(self.filename) if modtime > self.__lastmtime: self.parser.read(self.filename) self.__lastmtime = modtime |
path = re.sub(self.req.path_info + '$', '', self.req.uri) | path = re.sub('%s$' % re.escape(self.req.path_info), '', self.req.uri) | def init_request(self): core.Request.init_request(self) |
r"(?P<definition>^\s+((?:%s.*?%s|%s.*?%s|[^%s%s])+?::)(?:\s+|$))" % (INLINE_TOKEN, INLINE_TOKEN, STARTBLOCK_TOKEN, ENDBLOCK_TOKEN, INLINE_TOKEN, STARTBLOCK[0]), | r"(?P<definition>^\s+((?:%s[^%s]*%s|%s.*?%s|[^%s%s:]|:[^:])+::)(?:\s+|$))" % (INLINE_TOKEN, INLINE_TOKEN, INLINE_TOKEN, STARTBLOCK_TOKEN, ENDBLOCK_TOKEN, INLINE_TOKEN, STARTBLOCK[0]), | def process(self, req, text, in_paragraph=False): if self.error: text = system_message(Markup('Error: Failed to load processor ' '<code>%s</code>', self.name), self.error) else: text = self.processor(req, text) if not text: return '' if in_paragraph: content_for_span = None interrupt_paragraph = False if isinstance(tex... |
missing = 'missing' in link.attr.get('class', '') | missing = 'missing' in link.attr.get('class_', '') | def trac_get_reference(rawtext, target, text): link = wiki_to_link(target, self.env, req) uri = None missing = False if isinstance(link, Element): uri = link.attr.get('href', '') missing = 'missing' in link.attr.get('class', '') else: uri = req.href.wiki(target) missing = not WikiSystem(self.env).has_page(target) if ur... |
self.send_response(200) mtype, enc = mimetypes.guess_type(filename) stat = os.fstat(f.fileno()) content_length = stat[6] last_modified = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(stat[8])) self.send_header('Content-Type', mtype) self.send_header('Conten-Length', str(content_length)) self.send_header('Last-... | try: self.send_response(200) mtype, enc = mimetypes.guess_type(filename) stat = os.fstat(f.fileno()) content_length = stat[6] last_modified = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(stat[8])) self.send_header('Content-Type', mtype) self.send_header('Content-Length', str(content_length)) self.send_header(... | def do_htdocs_req(self, path): """This function serves request for static img/css files""" path = urllib.unquote(path) # Make sure the path doesn't contain any dangerous ".."-parts. path = '/'.join(filter(lambda x: x not in ['..', ''], path.split('/'))) filename = os.path.join(siteconfig.__default_htdocs_dir__, os.path... |
send_pretty_error(e, env, req) | try: send_pretty_error(e, env, req) except socket.error, (code, msg): if code == errno.EPIPE or code == 10053: self.log_message('Lost connection to client: %s', self.address_string()) else: raise | def do_trac_req(self): m = self.url_re.findall(self.path) if not m: self.send_error(400, 'Bad Request') return project_name, path_info, query_string = m[0] if not self.server.projects.has_key(project_name): self.send_error(404, 'Not Found') return path_info = urllib.unquote(path_info) env = self.server.projects[project... |
f[i] = space_re.sub(htmlify, line) | f[i] = Markup(space_re.sub(htmlify, line)) | def htmlify(match): div, mod = divmod(len(match.group(0)), 2) return div * ' ' + mod * ' ' |
t[i] = space_re.sub(htmlify, line) | t[i] = Markup(space_re.sub(htmlify, line)) | def htmlify(match): div, mod = divmod(len(match.group(0)), 2) return div * ' ' + mod * ' ' |
blocks[-1]['base.lines'].append(line) | blocks[-1]['base.lines'].append(Markup(line)) | def markup_intraline_changes(opcodes): for tag, i1, i2, j1, j2 in opcodes: if tag == 'replace' and i2 - i1 == j2 - j1: for i in range(i2 - i1): fromline, toline = fromlines[i1 + i], tolines[j1 + i] (start, end) = _get_change_extent(fromline, toline) |
blocks[-1]['changed.lines'].append(line) | blocks[-1]['changed.lines'].append(Markup(line)) | def markup_intraline_changes(opcodes): for tag, i1, i2, j1, j2 in opcodes: if tag == 'replace' and i2 - i1 == j2 - j1: for i in range(i2 - i1): fromline, toline = fromlines[i1 + i], tolines[j1 + i] (start, end) = _get_change_extent(fromline, toline) |
blocks[-1]['base.lines'].append(space_re.sub(htmlify, line)) | blocks[-1]['base.lines'].append(Markup(space_re.sub(htmlify, line))) | def markup_intraline_changes(opcodes): for tag, i1, i2, j1, j2 in opcodes: if tag == 'replace' and i2 - i1 == j2 - j1: for i in range(i2 - i1): fromline, toline = fromlines[i1 + i], tolines[j1 + i] (start, end) = _get_change_extent(fromline, toline) |
blocks[-1]['changed.lines'].append(space_re.sub(htmlify, line)) | blocks[-1]['changed.lines'].append(Markup(space_re.sub(htmlify, line))) | def markup_intraline_changes(opcodes): for tag, i1, i2, j1, j2 in opcodes: if tag == 'replace' and i2 - i1 == j2 - j1: for i in range(i2 - i1): fromline, toline = fromlines[i1 + i], tolines[j1 + i] (start, end) = _get_change_extent(fromline, toline) |
def my_sum(list): """Python2.2 doesn't have sum()""" tot = 0 for item in list: tot += item return tot | try: sum except NameError: def sum(list): """Python2.2 doesn't have sum()""" tot = 0 for item in list: tot += item return tot | def my_sum(list): """Python2.2 doesn't have sum()""" tot = 0 for item in list: tot += item return tot |
def db_open(self): | def env_open(self): | def db_open(self): try: if not self.__env: self.__env = Environment(self.envname) return self.__env.get_db_cnx() except Exception, e: print 'Failed to open environment.', e sys.exit(1) |
return self.__env.get_db_cnx() | return self.__env except Exception, e: print 'Failed to open environment.', e sys.exit(1) def db_open(self): try: return self.env_open().get_db_cnx() | def db_open(self): try: if not self.__env: self.__env = Environment(self.envname) return self.__env.get_db_cnx() except Exception, e: print 'Failed to open environment.', e sys.exit(1) |
xrange(0, (1 + len(sep)) * cnum + my_sum(colw))]) | xrange(0, (1 + len(sep)) * cnum + sum(colw))]) | def print_listing(self, headers, data, sep=' ', decor=True): ldata = list(data) if decor: ldata.insert(0, headers) print colw = [] ncols = len(ldata[0]) # assumes all rows are of equal length for cnum in xrange(0, ncols): mw = 0 for cell in [str(d[cnum]) or '' for d in ldata]: if len(cell) > mw: mw = len(cell) colw.app... |
for c in Component.select(self.__env): | for c in Component.select(self.env_open()): | def _do_component_list(self): data = [] for c in Component.select(self.__env): data.append((c.name, c.owner)) self.print_listing(['Name', 'Owner'], data) |
component = Component(self.__env) | component = Component(self.env_open()) | def _do_component_add(self, name, owner): component = Component(self.__env) component.name = name component.owner = owner component.insert() |
component = Component(self.__env, name) | component = Component(self.env_open(), name) | def _do_component_rename(self, name, newname): component = Component(self.__env, name) component.name = newname component.update() |
component = Component(self.__env, name) | component = Component(self.env_open(), name) | def _do_component_remove(self, name): component = Component(self.__env, name) component.delete() |
component = Component(self.__env, name) | component = Component(self.env_open(), name) | def _do_component_set_owner(self, name, owner): component = Component(self.__env, name) component.owner = owner component.update() |
self.db_open() | def do_resync(self, line): self.db_open() # We need to call this function to open the env, really stupid | |
cnx = self.__env.get_db_cnx() | cnx = self.db_open() | def do_resync(self, line): self.db_open() # We need to call this function to open the env, really stupid |
[(e.name,) for e in enum_cls.select(self.__env)]) | [(e.name,) for e in enum_cls.select(self.env_open())]) | def _do_enum_list(self, type): enum_cls = self._enum_map[type] self.print_listing(['Possible Values'], [(e.name,) for e in enum_cls.select(self.__env)]) |
enum = enum_cls(self.__env, name) | enum = enum_cls(self.env_open(), name) | def _do_enum_change(self, type, name, newname): enum_cls = self._enum_map[type] enum = enum_cls(self.__env, name) enum.name = newname enum.update() |
enum = enum_cls(self.__env, name) | enum = enum_cls(self.env_open(), name) | def _do_enum_remove(self, type, name): enum_cls = self._enum_map[type] enum = enum_cls(self.__env, name) enum.delete() |
for m in Milestone.select(self.__env, include_completed=True): | for m in Milestone.select(self.env_open(), include_completed=True): | def _do_milestone_list(self): data = [] for m in Milestone.select(self.__env, include_completed=True): data.append((m.name, m.due and self._format_date(m.due), m.completed and self._format_datetime(m.completed))) |
milestone = Milestone(self.__env, name) | milestone = Milestone(self.env_open(), name) | def _do_milestone_rename(self, name, newname): milestone = Milestone(self.__env, name) milestone.name = newname milestone.update() |
milestone = Milestone(self.__env) | milestone = Milestone(self.env_open()) | def _do_milestone_add(self, name): milestone = Milestone(self.__env) milestone.name = name milestone.insert() |
milestone = Milestone(self.__env, name) | milestone = Milestone(self.env_open(), name) | def _do_milestone_remove(self, name): milestone = Milestone(self.__env, name) milestone.delete() |
milestone = Milestone(self.__env, name) | milestone = Milestone(self.env_open(), name) | def _do_milestone_set_due(self, name, t): milestone = Milestone(self.__env, name) milestone.due = self._parse_date(t) milestone.update() |
milestone = Milestone(self.__env, name) | milestone = Milestone(self.env_open(), name) | def _do_milestone_set_completed(self, name, t): milestone = Milestone(self.__env, name) milestone.completed = self._parse_date(t) milestone.update() |
for v in Version.select(self.__env): | for v in Version.select(self.env_open()): | def _do_version_list(self): data = [] for v in Version.select(self.__env): data.append((v.name, v.time and self._format_date(v.time))) self.print_listing(['Name', 'Time'], data) |
version = Version(self.__env, name) | version = Version(self.env_open(), name) | def _do_version_rename(self, name, newname): version = Version(self.__env, name) version.name = newname version.update() |
version = Version(self.__env) | version = Version(self.env_open()) | def _do_version_add(self, name): version = Version(self.__env) version.name = name version.insert() |
version = Version(self.__env, name) | version = Version(self.env_open(), name) | def _do_version_remove(self, name): version = Version(self.__env, name) version.delete() |
version = Version(self.__env, name) | version = Version(self.env_open(), name) | def _do_version_time(self, name, t): version = Version(self.__env, name) version.time = self._parse_date(t) version.update() |
if item['author'].find('@') != -1: item['author.email'] = item['author'] | if event['author'].find('@') != -1: event['author.email'] = event['author'] | def render(self, req): self.perm.assert_permission(perm.TIMELINE_VIEW) self.authzperm = SubversionAuthorizer(self.env, req.authname) # Kludge |
component_name = cls | component_name = cls.lower() | def is_component_enabled(self, cls): """Implemented to only allow activation of components that are not disabled in the configuration. This is called by the `ComponentManager` base class when a component is about to be activated. If this method returns false, the component does not get activated.""" if not isinstance(... |
message = util.escape(info) | message = util.Markup(info) | def produce((id, t, author, type, summary), status, fields, comment): if status == 'edit': if 'ticket_details' in filters: info = '' if len(fields) > 0: info = ', '.join(['<i>%s</i>' % f for f in \ fields.keys()]) + ' changed<br />' else: return None elif 'ticket' in filters: if status == 'closed' and fields.has_key('r... |
Format = WikiProcessor(self.env, language) html = Format.process(hdf, text) raw = nodes.raw('',html, format='html') | processor = WikiProcessor(self.env, language) html = processor.process(req.hdf, text) raw = nodes.raw('', html, format='html') | def code_formatter(language, text): Format = WikiProcessor(self.env, language) html = Format.process(hdf, text) raw = nodes.raw('',html, format='html') return raw |
return '<a title="%s" href="%s">%s</a>' % (title,link, text) | return '<a title="%s" href="%s">%s</a>' % (title or '',link, text) | def _modulehref_formatter(self, match, fullmatch): link, text, missing, title = self._expand_module_link(match) if link and missing: return '<a title="%s" class="missing" href="%s">%s?</a>' % (title,link, text) elif link: return '<a title="%s" href="%s">%s</a>' % (title,link, text) else: return match |
req.redirect(req.get_header('Referer') or env.href.wiki()) | req.redirect(referer or env.href.wiki()) | def dispatch_request(path_info, args, req, env, database=None): import Wiki if not database: database = env.get_db_cnx() # Let the wiki module build a dictionary of all page names database = env.get_db_cnx() Wiki.populate_page_dict(database, env) authenticator = auth.Authenticator(database, req) if path_info == '/lo... |
self._send_csv(req, cols, results) | self._send_csv(req, cols, results, mimetype='text/csv') | def sortkey(row): val = row[idx] if isinstance(val, basestring): val = val.lower() return val |
self._send_csv(req, cols, results, '\t') | self._send_csv(req, cols, results, '\t', mimetype='text/tab-separated-values') | def sortkey(row): val = row[idx] if isinstance(val, basestring): val = val.lower() return val |
def _send_csv(self, req, cols, rows, sep=','): | def _send_csv(self, req, cols, rows, sep=',', mimetype='text/plain'): | def _send_csv(self, req, cols, rows, sep=','): req.send_response(200) req.send_header('Content-Type', 'text/plain;charset=utf-8') req.end_headers() |
req.send_header('Content-Type', 'text/plain;charset=utf-8') | req.send_header('Content-Type', mimetype + ';charset=utf-8') | def _send_csv(self, req, cols, rows, sep=','): req.send_response(200) req.send_header('Content-Type', 'text/plain;charset=utf-8') req.end_headers() |
msg['Date'] = time.strftime('%a, %d %b %Y %H:%M:%S +0000', time.gmtime()); | msg['Date'] = formatdate() | def send(self, rcpt, mime_headers={}): from email.MIMEText import MIMEText from email.Header import Header body = self.hdf.render(self.template_name) msg = MIMEText(body, 'plain', 'utf-8') msg['X-Mailer'] = 'Trac %s, by Edgewall Software' % __version__ msg['X-Trac-Version'] = __version__ projname = self.config.get('pr... |
(milestone.encode('utf-8'))) | (milestone.encode('utf-8'),)) | def setMilestoneList(self, m, key): """Remove all milestones, set them to `m`""" self.assertNoTickets() c = self.db().cursor() c.execute("DELETE FROM milestone") for ms in m: milestone = ms[key] print " inserting milestone '%s'" % (milestone) c.execute("INSERT INTO milestone (name) VALUES (%s)", (milestone.encode('ut... |
self.assertTrue(page, listener.deleted_version[0]) | self.assertEqual(page, listener.deleted_version[0]) | def test_delete_page_version(self): cursor = self.db.cursor() cursor.executemany("INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)", [('TestPage', 1, 42, 'joe', '::1', 'Bla bla', 'Testing', 0), ('TestPage', 2, 43, 'kate', '192.168.0.101', 'Bla', 'Changing', 0)]) |
title = 'Changeset <em>[%s]</em> by %s' % ( util.escape(chgset.rev), util.escape(chgset.author)) | excerpt = util.shorten_line(chgset.message or '--') | def get_timeline_events(self, req, start, stop, filters): if 'changeset' in filters: format = req.args.get('format') show_files = int(self.config.get('timeline', 'changeset_show_files')) db = self.env.get_db_cnx() repos = self.env.get_repository() rev = repos.youngest_rev while rev: chgset = repos.get_changeset(rev) if... |
excerpt = util.shorten_line(chgset.message or '--') | def get_timeline_events(self, req, start, stop, filters): if 'changeset' in filters: format = req.args.get('format') show_files = int(self.config.get('timeline', 'changeset_show_files')) db = self.env.get_db_cnx() repos = self.env.get_repository() rev = repos.youngest_rev while rev: chgset = repos.get_changeset(rev) if... | |
yield line | yield escape(line) | def render(self, req, mimetype, content, filename=None, rev=None): if is_binary(content): self.env.log.debug("Binary data; no preview available") return |
odata = np.out.splitlines()[1] | odata = ''.join(np.out.splitlines()[1:-1]) | def render(self, req, mimetype, content, filename=None, rev=None): cmdline = self.config.get('mimeviewer', 'php_path') # -n to ignore php.ini so we're using default colors cmdline += ' -sn' self.env.log.debug("PHP command line: %s" % cmdline) |
self._dormant.append(cnx) | if cnx.poolable: self._dormant.append(cnx) else: self._cursize -= 1 | def _return_cnx(self, cnx): self._available.acquire() try: tid = threading._get_ident() if tid in self._active: num, cnx_ = self._active.get(tid) assert cnx is cnx_ if num > 1: self._active[tid][0] = num - 1 else: del self._active[tid] if cnx not in self._dormant: cnx.rollback() self._dormant.append(cnx) self._availabl... |
sqlite.Cursor.execute(self, sql, args or []) | return self._rollback_on_error(sqlite.Cursor.execute, sql, args or []) | def execute(self, sql, args=None): if args: sql = sql % (('?',) * len(args)) sqlite.Cursor.execute(self, sql, args or []) |
sqlite.Cursor.executemany(self, sql, args or []) | return self._rollback_on_error(sqlite.Cursor.executemany, sql, args or []) | def executemany(self, sql, args=None): if args: sql = sql % (('?',) * len(args[0])) sqlite.Cursor.executemany(self, sql, args or []) |
__slots__ = ['cnx'] | __slots__ = ['cnx', '_active_cursors'] poolable = False | def fetchall(self): rows = sqlite.Cursor.fetchall(self) return rows != None and [self._convert_row(row) for row in rows] or None |
timeout = int(params.get('timeout', 10000)) | def __init__(self, path, params={}): assert have_pysqlite > 0 self.cnx = None if path != ':memory:': if not os.access(path, os.F_OK): raise TracError, 'Database "%s" not found.' % path | |
check_same_thread=False, timeout=timeout) | timeout=timeout) | def __init__(self, path, params={}): assert have_pysqlite > 0 self.cnx = None if path != ':memory:': if not os.access(path, os.F_OK): raise TracError, 'Database "%s" not found.' % path |
return self.cnx.cursor(PyFormatCursor) | cursor = self.cnx.cursor(PyFormatCursor) self._active_cursors[cursor] = True cursor.cnx = self return cursor def rollback(self): for cursor in self._active_cursors.keys(): cursor.close() self.cnx.rollback() | def cursor(self): return self.cnx.cursor(PyFormatCursor) |
FROM ticket t, enum p | FROM ticket t LEFT JOIN enum p ON p.name = t.priority AND p.type = 'priority' | def get_reports(db): owner = db.concat('owner', "' *'") return ( |
AND p.name = t.priority AND p.type = 'priority' | def get_reports(db): owner = db.concat('owner', "' *'") return ( | |
FROM ticket t,enum p WHERE p.name=t.priority AND p.type='priority' | FROM ticket t LEFT JOIN enum p ON p.name = t.priority AND p.type = 'priority' | def get_reports(db): owner = db.concat('owner', "' *'") return ( |
FROM ticket t, enum p WHERE t.status IN ('new', 'assigned', 'reopened') AND p.name = t.priority AND p.type = 'priority' AND owner = '$USER' | FROM ticket t LEFT JOIN enum p ON p.name = t.priority AND p.type = 'priority' WHERE t.status IN ('new', 'assigned', 'reopened') AND owner = '$USER' | def get_reports(db): owner = db.concat('owner', "' *'") return ( |
for line in html.split('<br />'): yield line.replace(' ', ' ') | return [line.replace(' ', ' ') for line in html.split('<br />')] | def render(self, context, mimetype, content, filename=None, rev=None): # -n to ignore php.ini so we're using default colors cmdline = '%s -sn' % self.path self.env.log.debug("PHP command line: %s" % cmdline) |
for i in range(0, min(len(str), 1000)): if str[i] == '\0': return True return False | return '\0' in str[:1000] | def is_binary(str): """Detect binary content by checking the first thousand bytes for zeroes.""" if detect_unicode(str): return False for i in range(0, min(len(str), 1000)): if str[i] == '\0': return True return False |
if mimetype.startswith('text/'): return 1 return 0 | if mimetype in TREAT_AS_BINARY: return 0 return 1 | def get_quality_ratio(self, mimetype): if mimetype.startswith('text/'): return 1 return 0 |
if StrictVersion(__version__) < StrictVersion('0.3.3'): | if StrictVersion(__version__) < StrictVersion('0.3.9'): | def render(self, req, mimetype, content, filename=None, rev=None): try: from docutils import nodes from docutils.core import publish_string from docutils.parsers import rst from docutils import __version__ except ImportError: raise TracError, 'Docutils not found' if StrictVersion(__version__) < StrictVersion('0.3.3'): ... |
% ('0.3.3', __version__) | % ('0.3.9', __version__) | def render(self, req, mimetype, content, filename=None, rev=None): try: from docutils import nodes from docutils.core import publish_string from docutils.parsers import rst from docutils import __version__ except ImportError: raise TracError, 'Docutils not found' if StrictVersion(__version__) < StrictVersion('0.3.3'): ... |
settings_overrides={'halt_level': 6}) | settings_overrides={'halt_level': 6, 'file_insertion_enabled': 0, 'raw_enabled': 0}) | def code_block(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): """ Create a code-block directive for docutils. |
application_pool = None | def history_cb(path, rev, pool): if authz.has_permission(path): history.append((path, rev)) | |
return [None, path, dir_pool] | def add_directory(self, path, parent_baton, copyfrom_path, copyfrom_revision, dir_pool): self.cursor.execute('INSERT INTO node_change (rev, name, change) ' 'VALUES (%s, %s, \'A\')', self.rev, path) return [None, path, dir_pool] | |
changelog = ticket.get_changelog(db=db) curr_author = None curr_date = 0 | def export_rss(self, req, ticket): db = self.env.get_db_cnx() changelog = ticket.get_changelog(db=db) curr_author = None curr_date = 0 changes = [] change_summary = {} | |
def update_title(): if not changes: return title = '; '.join(['%s %s' % (', '.join(v), k) for k, v in change_summary.iteritems()]) changes[-1]['title'] = title for date, author, field, old, new in changelog: if date != curr_date or author != curr_author: update_title() change_summary = {} changes.append({ 'date': htt... | for change in self.grouped_changelog_entries(ticket, db): changes.append(change) change_summary = {} if 'comment' in change: comment = change['comment'] change['comment'] = unicode(wiki_to_html( comment, self.env, req, db, absurls=True)) | def update_title(): if not changes: return title = '; '.join(['%s %s' % (', '.join(v), k) for k, v in change_summary.iteritems()]) changes[-1]['title'] = title |
changes[-1]['comment'] = unicode(wiki_to_html(new, self.env, req, db, absurls=True)) elif field == 'description': change_summary.setdefault('changed', []).append(field) changes[-1]['fields'][field] = '' else: change = 'changed' if not old: change = 'set' elif not new: change = 'deleted' change_summary.setdefault(change... | for field, values in change['fields'].iteritems(): if field == 'description': change_summary.setdefault('changed', []).append(field) else: chg = 'changed' if not values['old']: chg = 'set' elif not values['new']: chg = 'deleted' change_summary.setdefault(chg, []).append(field) change['title'] = '; '.join(['%s %s' % (',... | def update_title(): if not changes: return title = '; '.join(['%s %s' % (', '.join(v), k) for k, v in change_summary.iteritems()]) changes[-1]['title'] = title |
changelog = ticket.get_changelog(db=db) autonum = 0 | def quote_original(author, original, link): if not 'comment' in req.args: # i.e. the comment was not yet edited req.hdf['ticket.comment'] = '\n'.join( ['Replying to [%s %s]:' % (link, author)] + ['> %s' % line for line in original.splitlines()] + ['']) | |
last_uid = current = None for date, author, field, old, new, permanent in changelog: uid = date, author, permanent if uid != last_uid: last_uid = uid current = { 'date': format_datetime(date), 'author': author, 'fields': {} } changes.append(current) if permanent: autonum += 1 current['cnum'] = autonum if field == 'comm... | cnum = 0 for change in self.grouped_changelog_entries(ticket, db): changes.append(change) comment = '' if 'comment' in change: comment = change['comment'] change['comment'] = wiki_to_html(comment, self.env, req, db) if change['permanent']: cnum = change['cnum'] if 'replyto' in change: replies.setdefault(change['reply... | def quote_original(author, original, link): if not 'comment' in req.args: # i.e. the comment was not yet edited req.hdf['ticket.comment'] = '\n'.join( ['Replying to [%s %s]:' % (link, author)] + ['> %s' % line for line in original.splitlines()] + ['']) |
'cnum': autonum + 1 | 'cnum': cnum + 1 | def quote_original(author, original, link): if not 'comment' in req.args: # i.e. the comment was not yet edited req.hdf['ticket.comment'] = '\n'.join( ['Replying to [%s %s]:' % (link, author)] + ['> %s' % line for line in original.splitlines()] + ['']) |
node = get_existing_node(self.env, repos, path, rev) rev = repos.normalize_rev(rev) hidden_properties = [p.strip() for p in self.config.get('browser', 'hide_properties').split(',')] | if rev: rev = repos.normalize_rev(rev) rev_or_latest = rev or repos.youngest_rev node = get_existing_node(self.env, repos, path, rev_or_latest) hidden_properties = self.config.getlist('browser', 'hide_properties') | def process_request(self, req): path = req.args.get('path', '/') rev = req.args.get('rev') |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.